Update app.py

app.py

@@ -1,6 +1,5 @@
 import datetime
 import logging
-import os
 import sys
 import uuid
 from pathlib import Path
@@ -9,10 +8,6 @@ import gradio as gr
 from reportlab.lib.pagesizes import letter
 from reportlab.pdfgen import canvas
 from simple_salesforce import Salesforce
-from dotenv import load_dotenv
-
-# Load environment variables
-load_dotenv()
 
 # Configure logging
 logging.basicConfig(
@@ -22,13 +17,10 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# Salesforce credentials from environment variables
-SALESFORCE_USERNAME = os.getenv("SALESFORCE_USERNAME", "your_username@example.com")
-SALESFORCE_PASSWORD = os.getenv("SALESFORCE_PASSWORD", "your_password")
-SALESFORCE_SECURITY_TOKEN = os.getenv("SALESFORCE_SECURITY_TOKEN", "your_security_token")
-
-# Base URL configuration
-BASE_URL = os.getenv("BASE_URL", "http://localhost:7860")
+# Salesforce credentials
+SALESFORCE_USERNAME = "vaneshdevarapalli866@agentforce.com"
+SALESFORCE_PASSWORD = "vanesh@331"
+SALESFORCE_SECURITY_TOKEN = "VRUVbBOdG0s9Q4xy0W6DB1Y6b"
 
 # Connect to Salesforce
 def connect_to_salesforce():
@@ -47,79 +39,66 @@ def connect_to_salesforce():
 
 sf = connect_to_salesforce()
 
-# Equipment choices
 equipment_choices = [
     "Bulldozer", "Crane", "Excavator", "Loader", "Forklift",
     "Backhoe", "Grader", "Scraper", "Dump Truck", "Roller"
 ]
 
-# Project choices
 project_choices = [
     "Project Alpha", "Project Beta", "Project Gamma", "Project Delta", "Project Epsilon",
     "Project Zeta", "Project Theta", "Project Sigma", "Project Omega", "Project Phoenix"
 ]
 
-# AI suggestion choices
 ai_suggestion_choices = ["Move", "Pause Rent", "Repair", "Replace"]
 
+# Generate PDF report
 def generate_pdf_report(record_id, data_dict):
-    """Generate PDF report and return both local path and public URL"""
     report_id = str(uuid.uuid4())[:8]
     report_filename = f"report_{report_id}.pdf"
-    report_dir = Path("static/reports/")
-    report_dir.mkdir(parents=True, exist_ok=True)
-    report_path = report_dir / report_filename
+    report_path = Path(f"static/reports/{report_filename}")
+    report_path.parent.mkdir(parents=True, exist_ok=True)
 
-    # Create PDF
     c = canvas.Canvas(str(report_path), pagesize=letter)
-    c.setFont("Helvetica-Bold", 16)
-    c.drawString(100, 750, "Equipment Utilization Report")
     c.setFont("Helvetica", 12)
-    c.drawString(100, 730, f"Generated on: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-    c.drawString(100, 710, f"Salesforce Record ID: {record_id}")
-    
-    y = 680
+    c.drawString(100, 750, f"Equipment Utilization Report")
+    c.drawString(100, 735, f"Salesforce Record ID: {record_id}")
+
+    y = 710
     for key, val in data_dict.items():
         c.drawString(100, y, f"{key}: {val}")
         y -= 20
-    
+
     c.save()
-    
-    public_url = f"{BASE_URL}/static/reports/{report_filename}"
-    return str(report_path), public_url
+    return str(report_path)
+
+# Generate CSV report (without public URL)
+def generate_csv_report(record_id, data_dict):
+    report_id = str(uuid.uuid4())[:8]
+    csv_filename = f"report_{report_id}.csv"
+    csv_path = Path(f"static/reports/{csv_filename}")
+    csv_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(csv_path, mode='w', newline='') as f:
+        writer = csv.writer(f)
+        writer.writerow(["Field", "Value"])
+        writer.writerow(["Salesforce Record ID", record_id])
+        for k, v in data_dict.items():
+            writer.writerow([k, v])
+
+    return str(csv_path)
 
 def call_ai_model(usage_hours, idle_hours, movement_frequency, cost_per_hour, last_maintenance_str):
-    """Mock AI model call"""
-    logger.info("AI model called with parameters:")
-    logger.info(f"Usage Hours: {usage_hours}, Idle Hours: {idle_hours}")
-    logger.info(f"Movement Frequency: {movement_frequency}, Cost per Hour: {cost_per_hour}")
-    logger.info(f"Last Maintenance: {last_maintenance_str}")
-    
-    # Simple logic for demo purposes
-    utilization_score = min(1.0, usage_hours / (usage_hours + idle_hours + 0.001))
-    
-    if utilization_score < 0.3:
-        return "Pause Rent", 0.85, utilization_score
-    elif last_maintenance_str and (datetime.datetime.now() - datetime.datetime.strptime(last_maintenance_str, "%Y-%m-%d")).days > 180:
-        return "Repair", 0.9, utilization_score
-    elif cost_per_hour > 100 and idle_hours > usage_hours:
-        return "Move", 0.8, utilization_score
-    else:
-        return "No Action", 0.7, utilization_score
+    # Placeholder response since API endpoint is removed
+    logger.info("AI model endpoint removed; returning placeholder response.")
+    return "No Action", 0.0, 0.0
 
 def process_equipment_utilization(equipment_name, project_name, usage_hours, idle_hours,
-                                movement_frequency, cost_per_hour, last_maintenance, ai_suggestion=None):
-    """Process equipment data and create Salesforce record"""
+                                  movement_frequency, cost_per_hour, last_maintenance, ai_suggestion):
     last_maintenance_str = last_maintenance.strftime('%Y-%m-%d') if last_maintenance else None
-    
-    # Get AI suggestion if not provided
+
     if not ai_suggestion:
         ai_suggestion, suggestion_confidence, utilization_score = call_ai_model(
-            float(usage_hours),
-            float(idle_hours),
-            float(movement_frequency),
-            float(cost_per_hour),
-            last_maintenance_str or ""
+            usage_hours, idle_hours, movement_frequency, cost_per_hour, last_maintenance_str or ""
         )
     else:
         suggestion_confidence = 0.9
@@ -128,244 +107,153 @@ def process_equipment_utilization(equipment_name, project_name, usage_hours, idl
     summary_data = {
         "Equipment Name": equipment_name,
         "Project": project_name,
-        "Usage Hours": f"{usage_hours:.2f}",
-        "Idle Hours": f"{idle_hours:.2f}",
-        "Movement Frequency": f"{movement_frequency:.2f}",
-        "Cost per Hour": f"${cost_per_hour:.2f}",
-        "AI Suggestion": ai_suggestion,
-        "Confidence Level": f"{suggestion_confidence*100:.1f}%",
-        "Utilization Score": f"{utilization_score*100:.1f}%",
-        "Last Maintenance": last_maintenance_str or "Not Recorded",
-        "Report Date": datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        "Usage Hours": usage_hours,
+        "Idle Hours": idle_hours,
+        "Suggestion": ai_suggestion,
+        "Confidence": suggestion_confidence,
+        "Utilization Score": utilization_score,
+        "Cost per Hour": cost_per_hour  # Added to summary_data for the report
     }
 
     try:
-        # Create Salesforce record
+        # Log the data being sent to Salesforce
         record_data = {
             "Equipment_Name__c": equipment_name,
             "Project_Name__c": project_name,
-            "Usage_Hours__c": float(usage_hours),
-            "Idle_Hours__c": float(idle_hours),
-            "Movement_Frequency__c": float(movement_frequency),
-            "Cost_per_Hour__c": float(cost_per_hour),
+            "Usage_Hours__c": usage_hours,
+            "Idle_Hours__c": idle_hours,
             "AI_Suggestion__c": ai_suggestion,
             "Suggestion_Confidence__c": suggestion_confidence * 100,
             "Utilization_Score__c": utilization_score * 100,
-            "Last_Maintenance__c": last_maintenance_str,
+            "Cost_per_Hour__c": cost_per_hour,
             "Report_Link__c": "Pending",
+            "Last_Maintenance__c": last_maintenance_str,
             "Dashboard_Flag__c": False
         }
+        logger.info(f"Creating Salesforce record with data: {record_data}")
 
         response = sf.Equipment_Utilization_Record__c.create(record_data)
+
         record_id = response.get("id")
-        logger.info(f"Created Salesforce record with ID: {record_id}")
-
-        # Generate PDF report
-        pdf_path, pdf_url = generate_pdf_report(record_id, summary_data)
-        
-        # Update record with report URL
-        sf.Equipment_Utilization_Record__c.update(record_id, {"Report_Link__c": pdf_url})
-        
+        logger.info(f"Successfully created Salesforce record with ID: {record_id}")
+
+        # Generate both CSV and PDF reports
+        csv_path = generate_csv_report(record_id, summary_data)
+        pdf_path = generate_pdf_report(record_id, summary_data)
+
+        # Update the Salesforce record with the local PDF path
+        sf.Equipment_Utilization_Record__c.update(record_id, {"Report_Link__c": pdf_path})
+        logger.info(f"Updated Salesforce record {record_id} with Report_Link__c: {pdf_path}")
+
         return {
+            "Salesforce_Record_Id": record_id,
             "status": "Success",
-            "record_id": record_id,
-            "equipment": equipment_name,
-            "project": project_name,
-            "ai_suggestion": ai_suggestion,
-            "confidence": f"{suggestion_confidence*100:.1f}%",
-            "utilization": f"{utilization_score*100:.1f}%",
-            "report_url": pdf_url,
-            "pdf_path": pdf_path
+            "AI_Suggestion": ai_suggestion,
+            "Suggestion_Confidence": suggestion_confidence,
+            "Utilization_Score": utilization_score,
+            "Report_Link": pdf_path,
+            "report_file_path": pdf_path
         }
     except Exception as e:
-        logger.error(f"Error processing equipment utilization: {str(e)}")
-        return {
-            "status": "Error",
-            "error": str(e)
-        }
+        logger.error(f"Error creating or updating Salesforce record: {e}")
+        return {"error": str(e)}
 
-def gradio_interface(equipment_name, project_name, usage_hours, idle_hours,
-                    movement_frequency, cost_per_hour, last_maintenance, ai_suggestion):
-    """Gradio interface handler function"""
+def gradio_upload_process(equipment_name, project_name, usage_hours, idle_hours,
+                         movement_frequency, cost_per_hour, last_maintenance, ai_suggestion):
     try:
-        # Validate numeric inputs
-        usage_hours = float(usage_hours) if usage_hours else 0.0
-        idle_hours = float(idle_hours) if idle_hours else 0.0
-        movement_frequency = float(movement_frequency) if movement_frequency else 0.0
-        cost_per_hour = float(cost_per_hour) if cost_per_hour else 0.0
-
-        # Validate date input
-        last_maintenance_dt = None
-        if last_maintenance:
-            try:
-                last_maintenance_dt = datetime.datetime.strptime(last_maintenance, "%Y-%m-%d")
-            except ValueError:
-                return (
-                    {"status": "Error", "error": "Invalid date format. Use YYYY-MM-DD."},
-                    None,
-                    None
-                )
-
-        # Process the data
-        result = process_equipment_utilization(
-            equipment_name,
-            project_name,
-            usage_hours,
-            idle_hours,
-            movement_frequency,
-            cost_per_hour,
-            last_maintenance_dt,
-            ai_suggestion if ai_suggestion else None
-        )
+        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)}"}, None
 
-        # Return results
-        if result["status"] == "Success":
-            return (
-                result,
-                result["pdf_path"],
-                result["report_url"]
-            )
-        else:
-            return (
-                result,
-                None,
-                None
-            )
+    try:
+        last_maintenance_dt = datetime.datetime.strptime(last_maintenance, "%Y-%m-%d") if last_maintenance else None
     except Exception as e:
-        logger.error(f"Error in Gradio interface: {str(e)}")
-        return (
-            {"status": "Error", "error": str(e)},
-            None,
-            None
-        )
+        return {"error": f"Invalid date format for Last Maintenance (expected YYYY-MM-DD): {str(e)}"}, None
 
-# Create Gradio interface
-with gr.Blocks(theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 🏗️ Equipment Utilization Analyzer")
-    gr.Markdown("Track and optimize your construction equipment usage with AI-powered recommendations.")
-
-    with gr.Row():
-        with gr.Column():
-            equipment_dropdown = gr.Dropdown(
-                choices=equipment_choices,
-                label="Equipment Type",
-                interactive=True,
-                value=equipment_choices[0] if equipment_choices else None
-            )
-            
-            project_dropdown = gr.Dropdown(
-                choices=project_choices,
-                label="Project",
-                interactive=True,
-                value=project_choices[0] if project_choices else None
-            )
-            
-            ai_suggestion_dropdown = gr.Dropdown(
-                choices=[""] + ai_suggestion_choices,
-                label="Pre-selected AI Suggestion (optional)",
-                interactive=True
-            )
-            
-            last_maintenance = gr.Textbox(
-                label="Last Maintenance Date (YYYY-MM-DD)",
-                placeholder="e.g., 2023-01-15",
-                interactive=True
-            )
-
-        with gr.Column():
-            usage_hours = gr.Number(
-                label="Usage Hours (last 30 days)",
-                value=0.0,
-                minimum=0,
-                step=1.0,
-                interactive=True
-            )
-            
-            idle_hours = gr.Number(
-                label="Idle Hours (last 30 days)",
-                value=0.0,
-                minimum=0,
-                step=1.0,
-                interactive=True
-            )
-            
-            movement_frequency = gr.Number(
-                label="Movement Frequency (times moved)",
-                value=0.0,
-                minimum=0,
-                step=1.0,
-                interactive=True
-            )
-            
-            cost_per_hour = gr.Number(
-                label="Cost per Hour ($)",
-                value=0.0,
-                minimum=0,
-                step=0.1,
-                precision=2,
-                interactive=True
-            )
-
-    submit_btn = gr.Button("Analyze Equipment", variant="primary")
-
-    with gr.Row():
-        with gr.Column():
-            result_json = gr.JSON(
-                label="Analysis Results",
-                visible=True
-            )
-            
-            report_url = gr.Textbox(
-                label="Report URL",
-                interactive=False,
-                visible=True
-            )
-            
-            report_download = gr.File(
-                label="Download Report",
-                visible=True
-            )
-            
-            error_output = gr.Textbox(
-                label="Error Messages",
-                visible=False,
-                interactive=False
-            )
-
-    # Handle form submission
-    submit_btn.click(
-        fn=gradio_interface,
-        inputs=[
-            equipment_dropdown,
-            project_dropdown,
-            usage_hours,
-            idle_hours,
-            movement_frequency,
-            cost_per_hour,
-            last_maintenance,
-            ai_suggestion_dropdown
-        ],
-        outputs=[
-            result_json,
-            report_download,
-            report_url
-        ]
+    result = process_equipment_utilization(
+        equipment_name,
+        project_name,
+        usage_hours,
+        idle_hours,
+        movement_frequency,
+        cost_per_hour,
+        last_maintenance_dt,
+        ai_suggestion
     )
+    return result, result.get("report_file_path")
+
+with gr.Blocks() as app:
+    gr.Markdown("## 📋 Equipment Utilization Record Uploader")
+    gr.Markdown("Fill in the details below to generate AI suggestions and save them to Salesforce.")
+
+    with gr.Group():
+        with gr.Row():
+            equipment_dropdown = gr.Dropdown(choices=equipment_choices, label="🔧 Equipment Name", interactive=True)
+            project_dropdown = gr.Dropdown(choices=project_choices, label="🏍️ Project Name", interactive=True)
+            ai_suggestion_dropdown = gr.Dropdown(choices=[""] + ai_suggestion_choices, label="🧐 AI Suggestion (optional)", interactive=True)
+
+        gr.Markdown("---")
+
+        with gr.Row():
+            usage_hours = gr.Number(label="⏱️ Usage Hours", value=0, minimum=0)
+            idle_hours = gr.Number(label="🕒 Idle Hours", value=0, minimum=0)
+
+        with gr.Row():
+            movement_frequency = gr.Number(label="📈 Movement Frequency", value=0, minimum=0)
+            cost_per_hour = gr.Number(label="💰 Cost per Hour", value=0, minimum=0)
+
+        with gr.Row():
+            last_maintenance = gr.Textbox(label="🛠️ Last Maintenance Date (YYYY-MM-DD)", placeholder="Optional")
+
+        gr.Markdown("---")
+
+        with gr.Row():
+            submit_button = gr.Button("🚀 Submit", variant="primary")
+            output = gr.JSON(label="📄 Salesforce Record Creation Result")
+            report_file_output = gr.File(label="📃 Download PDF Report")
+
+        submit_button.click(
+            fn=gradio_upload_process,
+            inputs=[
+                equipment_dropdown, project_dropdown,
+                usage_hours, idle_hours,
+                movement_frequency, cost_per_hour,
+                last_maintenance, ai_suggestion_dropdown
+            ],
+            outputs=[output, report_file_output]
+        )
+
+    app.css = """
+        .gradio-container {
+            background-color: #000000 !important;
+            padding: 20px;
+            color: #ffffff !important;
+        }
+        .gr-button-primary {
+            background-color: #1e90ff !important;
+            color: white !important;
+        }
+        .gr-button-primary:hover {
+            background-color: #0d6efd !important;
+        }
+        .gr-markdown {
+            font-size: 18px;
+            font-weight: 600;
+            color: #ffffff !important;
+        }
+        label {
+            font-weight: 500;
+            color: #ffffff !important;
+        }
+        input, textarea, select {
+            background-color: #1c1c1c !important;
+            color: #ffffff !important;
+            border: 1px solid #444 !important;
+        }
+    """
 
-# Run the application
 if __name__ == "__main__":
-    # Create static directory if it doesn't exist
-    Path("static/reports").mkdir(parents=True, exist_ok=True)
-    
-    # Launch with ngrok if enabled
-    if os.getenv("USE_NGROK", "False").lower() == "true":
-        from pyngrok import ngrok
-        public_url = ngrok.connect(7860).public_url
-        logger.info(f"Ngrok tunnel created: {public_url}")
-        BASE_URL = public_url
-    
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=os.getenv("GRADIO_SHARE", "False").lower() == "true"
-    )
+    app.launch()