Update app.py

app.py

@@ -1,166 +1,165 @@
-import gradio as gr
+from flask import Flask, request, jsonify
+import requests
 import pandas as pd
-import plotly.express as px
-from weasyprint import HTML
-import datetime
+import numpy as np
+from sklearn.ensemble import IsolationForest
+from datetime import datetime, timedelta
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
+from reportlab.lib.styles import getSampleStyleSheet
+import io
+import base64
 import os
 
-# Cache data loading with detailed error handling
-def load_data():
+app = Flask(__name__)
+
+# Salesforce credentials (use environment variables in production)
+SF_USERNAME = os.getenv('SF_USERNAME', 'YOUR_USERNAME')
+SF_PASSWORD = os.getenv('SF_PASSWORD', 'YOUR_PASSWORD_WITH_TOKEN')
+SF_AUTH_URL = 'https://login.salesforce.com/services/oauth2/token'
+
+# Get Salesforce access token
+def get_sf_access_token():
     try:
-        required_files = [
-            "data/smartlog.csv",
-            "data/cell_analysis.csv",
-            "data/weight_log.csv",
-            "data/uv_verification.csv",
-            "data/equipment.csv"
-        ]
-        missing_files = [file for file in required_files if not os.path.exists(file)]
-        if missing_files:
-            return None, f"Missing files: {', '.join(missing_files)}"
-        
-        # Load logs with error handling for each file
-        log_files = [
-            "data/smartlog.csv",
-            "data/cell_analysis.csv",
-            "data/weight_log.csv",
-            "data/uv_verification.csv"
+        response = requests.post(SF_AUTH_URL, data={
+            'grant_type': 'password',
+            'username': SF_USERNAME,
+            'password': SF_PASSWORD
+        })
+        response.raise_for_status()
+        return response.json()['access_token'], response.json()['instance_url']
+    except Exception as e:
+        print(f"Error getting Salesforce token: {e}")
+        return None, None
+
+# Anomaly detection using Isolation Forest
+def detect_anomalies(log_data):
+    try:
+        df = pd.DataFrame(log_data)
+        if df.empty:
+            return []
+        df['Timestamp__c'] = pd.to_datetime(df['Timestamp__c'])
+        df['Timestamp_numeric'] = df['Timestamp__c'].apply(lambda x: x.timestamp())
+        features = df[['Usage__c', 'Timestamp_numeric']]
+        model = IsolationForest(contamination=0.1, random_state=42)
+        model.fit(features)
+        df['is_anomaly'] = model.predict(features) == -1
+        return df[['Id', 'is_anomaly']].to_dict('records')
+    except Exception as e:
+        print(f"Error in anomaly detection: {e}")
+        return []
+
+# Dashboard data endpoint
+@app.route('/api/dashboard', methods=['GET'])
+def get_dashboard_data():
+    lab = request.args.get('lab', '')
+    equipment_type = request.args.get('equipmentType', '')
+    date_range = request.args.get('dateRange', '7')
+
+    access_token, instance_url = get_sf_access_token()
+    if not access_token:
+        return jsonify({'error': 'Failed to authenticate with Salesforce'}), 500
+
+    # Fetch devices
+    soql = 'SELECT Id, Name, Status__c, Usage__c, Last_Log_Timestamp__c, Lab__c, Type FROM Equipment__c WHERE '
+    if lab:
+        soql += f"Lab__c = '{lab}' AND "
+    if equipment_type:
+        soql += f"Type = '{equipment_type}' AND "
+    soql += f"Last_Log_Timestamp__c = LAST_N_DAYS:{date_range} LIMIT 100"
+
+    try:
+        response = requests.get(f'{instance_url}/services/data/v52.0/query?q={soql}', headers={'Authorization': f'Bearer {access_token}'})
+        response.raise_for_status()
+        devices = response.json()['records']
+
+        # Fetch logs for anomaly detection
+        log_soql = 'SELECT Id, Usage__c, Timestamp__c, Equipment__c FROM SmartLog__c WHERE '
+        if lab:
+            log_soql += f"Equipment__r.Lab__c = '{lab}' AND "
+        if equipment_type:
+            log_soql += f"Equipment__r.Type = '{equipment_type}' AND "
+        log_soql += f"Timestamp__c = LAST_N_DAYS:{date_range}"
+
+        log_response = requests.get(f'{instance_url}/services/data/v52.0/query?q={log_soql}', headers={'Authorization': f'Bearer {access_token}'})
+        log_response.raise_for_status()
+        logs = log_response.json()['records']
+
+        # Detect anomalies
+        anomalies = detect_anomalies(logs)
+        anomaly_map = {a['Id']: a['is_anomaly'] for a in anomalies}
+        devices_with_anomalies = [
+            {**d, 'isAnomaly': any(l['Equipment__c'] == d['Id'] and anomaly_map.get(l['Id'], False) for l in logs)}
+            for d in devices
         ]
-        logs_list = []
-        for file in log_files:
-            try:
-                df = pd.read_csv(file)
-                if not all(col in df.columns for col in ["device_id", "timestamp", "status", "metrics"]):
-                    return None, f"Invalid columns in {file}. Expected: device_id, timestamp, status, metrics"
-                logs_list.append(df)
-            except Exception as e:
-                return None, f"Error reading {file}: {str(e)}"
-        
-        logs = pd.concat(logs_list, ignore_index=True)
-        logs["timestamp"] = pd.to_datetime(logs["timestamp"], errors='coerce')
-        if logs["timestamp"].isna().any():
-            return None, "Error parsing timestamps in logs"
-
-        # Load equipment data
-        equipment = pd.read_csv("data/equipment.csv")
-        if not all(col in equipment.columns for col in ["device_id", "type", "lab_id", "amc_expiry"]):
-            return None, "Invalid columns in equipment.csv. Expected: device_id, type, lab_id, amc_expiry"
-        equipment["amc_expiry"] = pd.to_datetime(equipment["amc_expiry"], errors='coerce')
-        if equipment["amc_expiry"].isna().any():
-            return None, "Error parsing amc_expiry in equipment.csv"
-
-        return logs, equipment
+
+        # Fetch chart data (daily log trends)
+        chart_soql = f"SELECT CALENDAR_DATE(Timestamp__c) logDate, COUNT(Id) logCount FROM SmartLog__c WHERE Timestamp__c = LAST_N_DAYS:{date_range} GROUP BY CALENDAR_DATE(Timestamp__c)"
+        chart_response = requests.get(f'{instance_url}/services/data/v52.0/query?q={chart_soql}', headers={'Authorization': f'Bearer {access_token}'})
+        chart_response.raise_for_status()
+        chart_data = chart_response.json()['records']
+        labels = [str(r['logDate']) for r in chart_data]
+        data = [r['logCount'] for r in chart_data]
+
+        # Calculate weekly uptime %
+        uptime_soql = f"SELECT Equipment__c, COUNT(Id) upCount FROM SmartLog__c WHERE Status__c = 'Active' AND Timestamp__c = LAST_N_DAYS:{date_range} GROUP BY Equipment__c"
+        uptime_response = requests.get(f'{instance_url}/services/data/v52.0/query?q={uptime_soql}', headers={'Authorization': f'Bearer {access_token}'})
+        uptime_response.raise_for_status()
+        uptime_data = uptime_response.json()['records']
+        total_logs = sum(r['logCount'] for r in chart_data)
+        uptime = sum(r['upCount'] for r in uptime_data) / total_logs * 100 if total_logs > 0 else 0
+
+        return jsonify({
+            'devices': devices_with_anomalies,
+            'chartData': {
+                'dailyTrends': {'labels': labels, 'data': data},
+                'weeklyUptime': round(uptime, 2)
+            }
+        })
     except Exception as e:
-        return None, f"Unexpected error: {str(e)}"
-
-# Generate PDF report
-def generate_pdf_report(data):
-    os.makedirs("reports", exist_ok=True)
-    html = f"""
-    <h1>LabOps Dashboard Report</h1>
-    <h2>Filtered Data</h2>
-    {data.to_html()}
-    """
-    filename = f"reports/report_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
-    HTML(string=html).write_pdf(filename)
-    return filename
-
-# Main dashboard function
-def render_dashboard(lab, device_type, date_start, date_end):
-    logs, equipment = load_data()
-    
-    if logs is None:
-        return f"<div style='color: red;'>Error: {equipment}</div>", None, None, f"Data loading failed: {equipment}", None, f"Error: {equipment}"
-
-    # Apply filters
-    filtered_logs = logs
-    if lab != "All":
-        device_ids = equipment[equipment["lab_id"] == lab]["device_id"]
-        filtered_logs = filtered_logs[filtered_logs["device_id"].isin(device_ids)]
-    if device_type != "All":
-        device_ids = equipment[equipment["type"] == device_type]["device_id"]
-        filtered_logs = filtered_logs[filtered_logs["device_id"].isin(device_ids)]
-    filtered_logs = filtered_logs[
-        (filtered_logs["timestamp"].dt.date >= pd.to_datetime(date_start).date()) &
-        (filtered_logs["timestamp"].dt.date <= pd.to_datetime(date_end).date())
-    ]
-
-    # Device Cards (FR-002)
-    device_cards = ""
-    for device_id in filtered_logs["device_id"].unique():
-        device_data = filtered_logs[filtered_logs["device_id"] == device_id]
-        if not device_data.empty:
-            status = device_data["status"].iloc[-1]
-            color = "green" if status == "UP" else "red"
-            device_cards += f"""
-                <div style='border: 1px solid {color}; padding: 10px; margin: 10px; border-radius: 5px;'>
-                    <h3>Device: {device_id}</h3>
-                    <p>Status: <span style='color: {color};'>{status}</span></p>
-                    <p>Last Log: {device_data['timestamp'].iloc[-1]}</p>
-                    <p>Usage Count: {len(device_data)}</p>
-                </div>
-            """
-
-    # Charts (FR-003)
-    downtime = filtered_logs[filtered_logs["status"] == "DOWN"].groupby("device_id").size().reset_index(name="downtime_count")
-    downtime_fig = px.bar(downtime, x="device_id", y="downtime_count", title="Downtime Events by Device")
-
-    usage = filtered_logs.groupby([filtered_logs["timestamp"].dt.date, "device_id"])["metrics"].mean().reset_index()
-    usage_fig = px.line(usage, x="timestamp", y="metrics", color="device_id", title="Daily Usage Metrics")
-
-    # AMC Reminders (FR-004)
-    today = datetime.datetime.now().date()
-    two_weeks = today + datetime.timedelta(days=14)
-    amc_alerts = equipment[equipment["amc_expiry"].dt.date <= two_weeks]
-    amc_text = amc_alerts[['device_id', 'type', 'lab_id', 'amc_expiry']].to_string() if not amc_alerts.empty else "No AMC expirations within 2 weeks."
-
-    # PDF Export (FR-004)
-    report_file = generate_pdf_report(filtered_logs)
-
-    return device_cards, downtime_fig, usage_fig, amc_text, report_file, "Data loaded successfully"
-
-# Load data for dropdowns with fallback
-logs, equipment_or_error = load_data()
-if logs is None:
-    lab_choices = ["All"]
-    device_type_choices = ["All"]
-    initial_error = f"Error loading data: {equipment_or_error}"
-else:
-    lab_choices = ["All"] + list(equipment_or_error["lab_id"].unique())
-    device_type_choices = ["All"] + list(equipment_or_error["type"].unique())
-    initial_error = "Data loaded successfully"
-
-# Gradio interface
-with gr.Blocks(css=".gradio-container {max-width: 100%;}") as demo:
-    gr.Markdown("# LabOps Dashboard")
-    
-    # Filters
-    with gr.Row():
-        lab = gr.Dropdown(choices=lab_choices, label="Select Lab", value="All")
-        device_type = gr.Dropdown(choices=device_type_choices, label="Device Type", value="All")
-    with gr.Row():
-        date_start = gr.DateTime(label="Start Date", value=logs["timestamp"].min() if logs is not None else "2025-05-30")
-        date_end = gr.DateTime(label="End Date", value=logs["timestamp"].max() if logs is not None else "2025-05-30")
-    
-    refresh_btn = gr.Button("Refresh")
-    
-    # Outputs
-    device_cards = gr.HTML(label="Device Status")
-    downtime_plot = gr.Plot(label="Downtime Trends")
-    usage_plot = gr.Plot(label="Usage Trends")
-    amc_reminders = gr.Textbox(label="AMC Expiry Reminders")
-    report_download = gr.File(label="Download Report")
-    debug_info = gr.Textbox(label="Debug Info", value=initial_error)
-
-    # Bind inputs to outputs
-    input_components = [lab, device_type, date_start, date_end]
-    outputs = [device_cards, downtime_plot, usage_plot, amc_reminders, report_download, debug_info]
-    
-    # Bind change events for input components
-    for input_component in input_components:
-        input_component.change(fn=render_dashboard, inputs=[lab, device_type, date_start, date_end], outputs=outputs)
-    
-    # Bind click event for refresh button
-    refresh_btn.click(fn=render_dashboard, inputs=[lab, device_type, date_start, date_end], outputs=outputs)
-
-demo.launch()
+        print(f"Error fetching dashboard data: {e}")
+        return jsonify({'error': 'Failed to fetch data'}), 500
+
+# PDF generation endpoint
+@app.route('/api/generate-pdf', methods=['POST'])
+def generate_pdf():
+    dashboard_data = request.json.get('dashboardData', [])
+    try:
+        output = io.BytesIO()
+        doc = SimpleDocTemplate(output, pagesize=letter)
+        styles = getSampleStyleSheet()
+        elements = [Paragraph("LabOps Monthly Report", styles['Title']), Spacer(1, 12)]
+
+        for device in dashboard_data:
+            text = f"Device: {device['Name']}<br/>Health: {device['Status__c']}<br/>Usage: {device['Usage__c']}<br/>Last Log: {device['Last_Log_Timestamp__c']}<br/>Anomaly: {'Yes' if device['isAnomaly'] else 'No'}"
+            elements.append(Paragraph(text, styles['Normal']))
+            elements.append(Spacer(1, 12))
+
+        doc.build(elements)
+        pdf_base64 = base64.b64encode(output.getvalue()).decode('utf-8')
+        output.close()
+        return jsonify({'pdf': pdf_base64})
+    except Exception as e:
+        print(f"Error generating PDF: {e}")
+        return jsonify({'error': 'Failed to generate PDF'}), 500
+
+# AMC expiry checker
+@app.route('/api/check-amc', methods=['POST'])
+def check_amc_expiry():
+    access_token, instance_url = get_sf_access_token()
+    if not access_token:
+        return jsonify({'error': 'Failed to authenticate with Salesforce'}), 500
+
+    try:
+        expiry_date = (datetime.now() + timedelta(days=14)).strftime('%Y-%m-%d')
+        soql = f"SELECT Id, Name, AMC_Expiry_Date__c, Lab__c FROM Equipment__c WHERE AMC_Expiry_Date__c <= {expiry_date}"
+        response = requests.get(f'{instance_url}/services/data/v52.0/query?q={soql}', headers={'Authorization': f'Bearer {access_token}'})
+        response.raise_for_status()
+        equipment = response.json()['records']
+        return jsonify({'status': 'Success', 'expiringAMCs': equipment})
+    except Exception as e:
+        print(f"Error checking AMC: {e}")
+        return jsonify({'error': 'Failed to check AMC expiries'}), 500
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=8080)