Create app.py

app.py

@@ -0,0 +1,188 @@
+from flask import Flask, request, jsonify
+import requests
+import pandas as pd
+import numpy as np
+from sklearn.ensemble import IsolationForest
+from datetime import datetime, timedelta
+import smtplib
+from email.mime.text import MIMEText
+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
+
+app = Flask(__name__)
+
+# Salesforce credentials (use environment variables in production)
+SF_CLIENT_ID = os.getenv('SF_CLIENT_ID', 'YOUR_CLIENT_ID')
+SF_CLIENT_SECRET = os.getenv('SF_CLIENT_SECRET', 'YOUR_CLIENT_SECRET')
+SF_USERNAME = os.getenv('SF_USERNAME', 'YOUR_USERNAME')
+SF_PASSWORD = os.getenv('SF_PASSWORD', 'YOUR_PASSWORD+SECURITY_TOKEN')
+SF_AUTH_URL = 'https://login.salesforce.com/services/oauth2/token'
+
+# Email configuration
+EMAIL_ADDRESS = os.getenv('EMAIL_ADDRESS', 'your_email@example.com')
+EMAIL_PASSWORD = os.getenv('EMAIL_PASSWORD', 'your_password')
+SMTP_SERVER = 'smtp.gmail.com'
+SMTP_PORT = 587
+
+# Get Salesforce access token
+def get_sf_access_token():
+    try:
+        response = requests.post(SF_AUTH_URL, data={
+            'grant_type': 'password',
+            'client_id': SF_CLIENT_ID,
+            'client_secret': SF_CLIENT_SECRET,
+            '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
+        ]
+
+        # 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:
+        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']
+
+        for equip in equipment:
+            msg = MIMEText(f"AMC for {equip['Name']} (Lab: {equip['Lab__c']}) expires on {equip['AMC_Expiry_Date__c']}")
+            msg['Subject'] = 'AMC Expiry Reminder'
+            msg['From'] = EMAIL_ADDRESS
+            msg['To'] = 'lab_manager@example.com'
+            with smtplib.SMTP(SMTP_SERVER, SMTP_PORT) as server:
+                server.starttls()
+                server.login(EMAIL_ADDRESS, EMAIL_PASSWORD)
+                server.send_message(msg)
+
+        return jsonify({'status': 'Notifications sent', 'count': len(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)