Update app.py

app.py

@@ -1,149 +1,158 @@
-import gradio as gr
+import datetime
+import io
 import logging
+import sys
+import requests
+import traceback
+import gradio as gr
+import pandas as pd
 from simple_salesforce import Salesforce
 
 # Configure logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[logging.FileHandler('app_log.txt'), logging.StreamHandler(sys.stdout)]
+)
 logger = logging.getLogger(__name__)
 
-# Salesforce Credentials
+# Replace with your actual Salesforce credentials
 SALESFORCE_USERNAME = "vaneshdevarapalli866@agentforce.com"
 SALESFORCE_PASSWORD = "vanesh@331"
 SALESFORCE_SECURITY_TOKEN = "VRUVbBOdG0s9Q4xy0W6DB1Y6b"
 
-# 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
-
-# Fetch Equipment records (Id, Name)
-def fetch_equipment_records():
+def connect_to_salesforce():
     try:
-        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"Error fetching equipment records: {e}")
-        return []
-
-# Fetch Project records (Id, Name)
-def fetch_project_records():
-    try:
-        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
+        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
     except Exception as e:
-        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)
+        logger.error(f"Salesforce connection failed: {e}")
+        raise
+
+sf = connect_to_salesforce()
+
+# Sample Equipment and Project entries (Name, Salesforce Record ID)
+equipment_choices = [
+    ("Bulldozer", "a0B3X00000FfPqLUAV"),
+    ("Crane", "a0B3X00000FfPqLVAV"),
+    ("Excavator", "a0B3X00000FfPqLWAV")
+]
+
+project_choices = [
+    ("Project Alpha", "a0C3X00000PqPqXUAV"),
+    ("Project Beta", "a0C3X00000PqPqYUAV"),
+    ("Project Gamma", "a0C3X00000PqPqZUAV")
+]
+
+def get_id_from_name(name, choices):
+    for n, id_ in choices:
+        if n == name:
+            return id_
+    return None
+
+def process_equipment_utilization(equipment_name, project_name, usage_hours, idle_hours,
+                                  movement_frequency, cost_per_hour, report_link, last_maintenance):
+    equipment_id = get_id_from_name(equipment_name, equipment_choices)
+    project_id = get_id_from_name(project_name, project_choices)
 
     if not equipment_id or not project_id:
-        return {"error": "Invalid Equipment or Project selected. Please select valid options from dropdown."}
+        return {"error": "Could not find Salesforce record IDs for Equipment or Project. Please check names."}
 
-    record = {
+    last_maintenance_str = last_maintenance.strftime('%Y-%m-%d') if last_maintenance else None
+
+    # Dummy AI suggestion for example
+    ai_suggestion = "Move"
+    suggestion_confidence = 90
+    utilization_score = 85
+
+    salesforce_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 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 ""
+        "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
     }
+    try:
+        response = sf.Equipment_Utilization_Record__c.create(salesforce_record)
+        logger.info(f"Salesforce Equipment Utilization Record created: {response}")
+        return {
+            "Salesforce_Record_Id": response["id"],
+            "status": "Success",
+            "AI_Suggestion": ai_suggestion,
+            "Suggestion_Confidence": suggestion_confidence,
+            "Utilization_Score": utilization_score,
+            "Report_Link": report_link
+        }
+    except Exception as e:
+        logger.error(f"Error creating Salesforce record: {e}")
+        return {"error": str(e)}
+
+def gradio_upload_process(equipment_name, project_name, usage_hours, idle_hours,
+                         movement_frequency, cost_per_hour,
+                         report_link, last_maintenance):
+    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: {str(e)}"}
 
     try:
-        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']}"}
+        last_maintenance_dt = datetime.datetime.strptime(last_maintenance, "%Y-%m-%d") if last_maintenance else None
     except Exception as e:
-        logger.error(f"Error creating Equipment Utilization Record: {e}")
-        return {"error": f"Failed to create record: {str(e)}"}
+        return {"error": f"Invalid date format for Last Maintenance (expected YYYY-MM-DD): {str(e)}"}
+
+    try:
+        result = process_equipment_utilization(
+            equipment_name,
+            project_name,
+            usage_hours,
+            idle_hours,
+            movement_frequency,
+            cost_per_hour,
+            report_link,
+            last_maintenance_dt
+        )
+        return result
+    except Exception as e:
+        tb = traceback.format_exc()
+        logger.error(f"Unexpected error in upload process: {tb}")
+        return {"error": f"Unexpected error: {str(e)}\n{tb}"}
 
-# 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
-        )
-
-    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)
-
+        equipment_dropdown = gr.Dropdown(choices=[name for name, _ in equipment_choices], label="Equipment")
+        project_dropdown = gr.Dropdown(choices=[name for name, _ in project_choices], label="Project")
+
+    usage_hours = gr.Number(label="Usage Hours", value=0, minimum=0)
+    idle_hours = gr.Number(label="Idle Hours", value=0, minimum=0)
+    movement_frequency = gr.Number(label="Movement Frequency", value=0, minimum=0)
+    cost_per_hour = gr.Number(label="Cost per Hour", value=0, minimum=0)
+    report_link = gr.Textbox(label="Report Link (URL)")
     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)
-
-    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")
 
+    submit_button = gr.Button("Submit")
     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
-        ],
+    submit_button.click(
+        fn=gradio_upload_process,
+        inputs=[equipment_dropdown, project_dropdown, usage_hours, idle_hours,
+                movement_frequency, cost_per_hour, report_link, last_maintenance],
         outputs=output
     )