Update app.py

app.py

@@ -10,10 +10,24 @@ import os
 import io
 import time
 import asyncio
+from simple_salesforce import Salesforce
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
+# Salesforce configuration
+try:
+    sf = Salesforce(
+        username='multi-devicelabopsdashboard@sathkrutha.com',
+        password='Team@1234',
+        security_token=os.getenv('SF_SECURITY_TOKEN', ''),
+        domain='login'
+    )
+    logging.info("Salesforce connection established")
+except Exception as e:
+    logging.error(f"Failed to connect to Salesforce: {str(e)}")
+    sf = None
+
 # Try to import reportlab
 try:
     from reportlab.lib.pagesizes import letter
@@ -26,6 +40,166 @@ except ImportError:
     logging.warning("reportlab module not found. PDF generation disabled.")
     reportlab_available = False
 
+# Cache picklist values at startup
+def get_picklist_values(field_name):
+    if sf is None:
+        return []
+    try:
+        obj_desc = sf.SmartLog__c.describe()
+        for field in obj_desc['fields']:
+            if field['name'] == field_name:
+                return [value['value'] for value in field['picklistValues'] if value['active']]
+        return []
+    except Exception as e:
+        logging.error(f"Failed to fetch picklist values for {field_name}: {str(e)}")
+        return []
+
+status_values = get_picklist_values('Status__c') or ["Active", "Inactive", "Pending"]
+log_type_values = get_picklist_values('Log_Type__c') or ["Smart Log", "Cell Analysis", "UV Verification"]
+logging.info(f"Valid Status__c values: {status_values}")
+logging.info(f"Valid Log_Type__c values: {log_type_values}")
+
+# Map invalid picklist values
+picklist_mapping = {
+    'Status__c': {
+        'normal': 'Active',
+        'error': 'Inactive',
+        'warning': 'Pending',
+        'ok': 'Active',
+        'failed': 'Inactive'
+    },
+    'Log_Type__c': {
+        'maint': 'Smart Log',
+        'error': 'Cell Analysis',
+        'ops': 'UV Verification',
+        'maintenance': 'Smart Log',
+        'cell': 'Cell Analysis',
+        'uv': 'UV Verification',
+        'weight log': 'Smart Log'
+    }
+}
+
+# Cache folder ID for Salesforce reports
+def get_folder_id(folder_name):
+    if sf is None:
+        return None
+    try:
+        query = f"SELECT Id FROM Folder WHERE Name = '{folder_name}' AND Type = 'Report'"
+        result = sf.query(query)
+        if result['totalSize'] > 0:
+            folder_id = result['records'][0]['Id']
+            logging.info(f"Found folder ID for '{folder_name}': {folder_id}")
+            return folder_id
+        else:
+            logging.error(f"Folder '{folder_name}' not found in Salesforce.")
+            return None
+    except Exception as e:
+        logging.error(f"Failed to fetch folder ID for '{folder_name}': {str(e)}")
+        return None
+
+LABOPS_REPORTS_FOLDER_ID = get_folder_id('LabOps Reports')
+
+# Salesforce report creation
+def create_salesforce_reports(df):
+    if sf is None or not LABOPS_REPORTS_FOLDER_ID:
+        logging.error("Cannot create Salesforce reports: No connection or folder ID")
+        return
+    try:
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        reports = [
+            {
+                "reportMetadata": {
+                    "name": f"SmartLog_Usage_Report_{timestamp}",
+                    "developerName": f"SmartLog_Usage_Report_{timestamp}",
+                    "reportType": {"type": "CustomEntity", "value": "SmartLog__c"},
+                    "reportFormat": "TABULAR",
+                    "reportBooleanFilter": None,
+                    "reportFilters": [],
+                    "detailColumns": ["SmartLog__c.Device_Id__c", "SmartLog__c.Usage_Hours__c"],
+                    "folderId": LABOPS_REPORTS_FOLDER_ID
+                }
+            },
+            {
+                "reportMetadata": {
+                    "name": f"SmartLog_AMC_Reminders_{timestamp}",
+                    "developerName": f"SmartLog_AMC_Reminders_{timestamp}",
+                    "reportType": {"type": "CustomEntity", "value": "SmartLog__c"},
+                    "reportFormat": "TABULAR",
+                    "reportBooleanFilter": None,
+                    "reportFilters": [],
+                    "detailColumns": ["SmartLog__c.Device_Id__c", "SmartLog__c.AMC_Date__c"],
+                    "folderId": LABOPS_REPORTS_FOLDER_ID
+                }
+            }
+        ]
+        for report in reports:
+            sf.restful('analytics/reports', method='POST', json=report)
+        logging.info("Salesforce reports created successfully")
+    except Exception as e:
+        logging.error(f"Failed to create Salesforce reports: {str(e)}")
+
+# Save to Salesforce
+def save_to_salesforce(df, reminders_df):
+    if sf is None:
+        logging.error("No Salesforce connection available")
+        return
+    try:
+        logging.info("Starting Salesforce save operation")
+        current_date = datetime.now()
+        next_30_days = current_date + timedelta(days=30)
+        records = []
+        reminder_device_ids = set(reminders_df['device_id']) if not reminders_df.empty else set()
+        logging.info(f"Processing {len(df)} records for Salesforce")
+
+        for idx, row in df.iterrows():
+            status = str(row['status']).lower()
+            log_type = str(row['log_type']).lower()
+            status_mapped = picklist_mapping['Status__c'].get(status, status_values[0] if status_values else 'Active')
+            log_type_mapped = picklist_mapping['Log_Type__c'].get(log_type, log_type_values[0] if log_type_values else 'Smart Log')
+            
+            if not status_mapped or not log_type_mapped:
+                logging.warning(f"Skipping record {idx}: Invalid status ({status}) or log_type ({log_type})")
+                continue
+
+            amc_date_str = None
+            if pd.notna(row['amc_date']):
+                try:
+                    amc_date = pd.to_datetime(row['amc_date']).strftime('%Y-%m-%d')
+                    amc_date_str = amc_date
+                    amc_date_dt = datetime.strptime(amc_date, '%Y-%m-%d')
+                    if status_mapped == "Active" and current_date.date() <= amc_date_dt.date() <= next_30_days.date():
+                        logging.info(f"AMC Reminder for Device ID {row['device_id']}: {amc_date}")
+                except Exception as e:
+                    logging.warning(f"Invalid AMC date for Device ID {row['device_id']}: {str(e)}")
+
+            record = {
+                'Device_Id__c': str(row['device_id'])[:50],
+                'Log_Type__c': log_type_mapped,
+                'Status__c': status_mapped,
+                'Timestamp__c': row['timestamp'].isoformat() if pd.notna(row['timestamp']) else None,
+                'Usage_Hours__c': float(row['usage_hours']) if pd.notna(row['usage_hours']) else 0.0,
+                'Downtime__c': float(row['downtime']) if pd.notna(row['downtime']) else 0.0,
+                'AMC_Date__c': amc_date_str
+            }
+            records.append(record)
+
+        if records:
+            batch_size = 100
+            for i in range(0, len(records), batch_size):
+                batch = records[i:i + batch_size]
+                try:
+                    result = sf.bulk.SmartLog__c.insert(batch)
+                    logging.info(f"Saved {len(batch)} records to Salesforce in batch {i//batch_size + 1}")
+                    for res in result:
+                        if not res['success']:
+                            logging.error(f"Failed to save record: {res['errors']}")
+                except Exception as e:
+                    logging.error(f"Failed to save batch {i//batch_size + 1}: {str(e)}")
+        else:
+            logging.warning("No records to save to Salesforce")
+    except Exception as e:
+        logging.error(f"Failed to save to Salesforce: {str(e)}")
+
 # Summarize logs
 def summarize_logs(df):
     try:
@@ -398,6 +572,10 @@ async def process_logs(file_obj, lab_site_filter, equipment_type_filter, date_ra
         anomaly_alerts_chart = create_anomaly_alerts_chart(anomalies_df)
         device_cards = generate_device_cards(filtered_df)
 
+        # Save to Salesforce after all other processing
+        save_to_salesforce(filtered_df, reminders_df)
+        create_salesforce_reports(filtered_df)
+
         elapsed_time = time.time() - start_time
         logging.info(f"Processing completed in {elapsed_time:.2f} seconds")
         if elapsed_time > 3: