Update src/core/services/database_service.py

src/core/services/database_service.py

@@ -2,12 +2,13 @@
 import sqlite3
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Dict, List, Any, Optional
+from typing import Dict, List, Any, Optional, Tuple
 import json
 from datetime import datetime, timedelta
 import random
 from faker import Faker
 import uuid
+import pandas as pd
 import os
 
 class DatabaseService:
@@ -338,4 +339,112 @@ class DatabaseService:
                 'contact_count': contact_count,
                 'interaction_count': interaction_stats['interaction_count'],
                 'avg_sentiment': interaction_stats['avg_sentiment'] or 0.0
-            }
+            }
+            
+    def get_recent_interactions(self, user_id: str = None, limit: int = 10) -> List[Dict]:
+        """Get recent interactions with account and user details"""
+        with self.get_db() as conn:
+            query = """
+                SELECT 
+                    i.*,
+                    a.name as account_name,
+                    u.name as owner_name,
+                    a.industry as account_industry
+                FROM interactions i
+                JOIN accounts a ON i.account_id = a.id
+                JOIN users u ON i.owner_id = u.id
+            """
+            params = []
+            
+            if user_id:
+                query += " WHERE i.owner_id = ?"
+                params.append(user_id)
+                
+            query += " ORDER BY i.created_at DESC LIMIT ?"
+            params.append(limit)
+            
+            cursor = conn.execute(query, params)
+            return [dict(row) for row in cursor.fetchall()]
+            
+    def search_interactions(self, query: str, user_id: Optional[str] = None, limit: int = 10) -> List[Dict]:
+        """Search interactions by content"""
+        with self.get_db() as conn:
+            sql_query = """
+                SELECT 
+                    i.*,
+                    a.name as account_name,
+                    u.name as owner_name
+                FROM interactions i
+                JOIN accounts a ON i.account_id = a.id
+                JOIN users u ON i.owner_id = u.id
+                WHERE (i.transcript LIKE ? OR i.summary LIKE ?)
+            """
+            params = [f"%{query}%", f"%{query}%"]
+            
+            if user_id:
+                sql_query += " AND i.owner_id = ?"
+                params.append(user_id)
+                
+            sql_query += " ORDER BY i.created_at DESC LIMIT ?"
+            params.append(limit)
+            
+            cursor = conn.execute(sql_query, params)
+            return [dict(row) for row in cursor.fetchall()]
+            
+    def get_dashboard_data(self) -> Tuple[Dict, pd.DataFrame, pd.DataFrame]:
+        """Get aggregated data for dashboard"""
+        with self.get_db() as conn:
+            # Get counts
+            counts = {
+                'accounts': conn.execute('SELECT COUNT(*) FROM accounts').fetchone()[0],
+                'contacts': conn.execute('SELECT COUNT(*) FROM contacts').fetchone()[0],
+                'interactions': conn.execute('SELECT COUNT(*) FROM interactions').fetchone()[0]
+            }
+            
+            # Get recent interactions
+            recent_interactions = pd.read_sql("""
+                SELECT 
+                    i.created_at, i.type, 
+                    a.name as account_name,
+                    u.name as owner_name,
+                    i.sentiment_score
+                FROM interactions i
+                JOIN accounts a ON i.account_id = a.id
+                JOIN users u ON i.owner_id = u.id
+                ORDER BY i.created_at DESC
+                LIMIT 10
+            """, conn)
+            
+            # Get account distribution
+            account_distribution = pd.read_sql("""
+                SELECT industry, COUNT(*) as count
+                FROM accounts
+                GROUP BY industry
+            """, conn)
+            
+            return counts, recent_interactions, account_distribution
+            
+    def save_interaction(self, interaction_data: Dict[str, Any]) -> str:
+        """Save a new interaction to the database"""
+        with self.get_db() as conn:
+            cursor = conn.cursor()
+            
+            # Ensure required fields
+            required_fields = ['id', 'type', 'account_id', 'owner_id', 'created_at']
+            for field in required_fields:
+                if field not in interaction_data:
+                    raise ValueError(f"Missing required field: {field}")
+            
+            # Convert any dict/list fields to JSON
+            if 'metadata' in interaction_data and isinstance(interaction_data['metadata'], (dict, list)):
+                interaction_data['metadata'] = json.dumps(interaction_data['metadata'])
+            
+            # Build query dynamically based on provided fields
+            fields = interaction_data.keys()
+            placeholders = ','.join(['?' for _ in fields])
+            query = f"INSERT INTO interactions ({','.join(fields)}) VALUES ({placeholders})"
+            
+            cursor.execute(query, list(interaction_data.values()))
+            conn.commit()
+            
+            return interaction_data['id']