Update src/dashboard_database_manager.py

src/dashboard_database_manager.py

@@ -6,10 +6,9 @@ import json
 import uuid
 import os
 from PIL import Image
-from typing import Dict, Any, Optional, List
 
-class DashboardDatabaseManager:
-    """Enhanced database manager for SmartHeal bot with dashboard integration"""
+class FixedDatabaseManager:
+    """Fixed database operations manager for SmartHeal application with dashboard integration"""
     
     def __init__(self, mysql_config):
         """Initialize database manager with MySQL configuration"""
@@ -87,14 +86,8 @@ class DashboardDatabaseManager:
             if connection and connection.is_connected():
                 connection.close()
     
-    def get_last_insert_id(self, connection, cursor):
-        """Get the last inserted ID"""
-        return cursor.lastrowid
-    
-    def save_questionnaire_response(self, questionnaire_data: Dict[str, Any], user_id: int) -> Optional[int]:
-        """
-        Save questionnaire response to dashboard-compatible tables
-        """
+    def save_questionnaire_response(self, questionnaire_data, user_id):
+        """Save questionnaire response to database"""
         connection = None
         cursor = None
         try:
@@ -102,18 +95,18 @@ class DashboardDatabaseManager:
             if not connection:
                 return None
             cursor = connection.cursor()
-
-            # (1) Create or get patient
+    
+            # Create or get patient
             patient_id = self._create_or_get_patient(cursor, questionnaire_data)
             if not patient_id:
                 raise Exception("Failed to get or create patient")
-
-            # (2) Get or create default questionnaire
+    
+            # Get or create default questionnaire
             questionnaire_id = self._get_or_create_default_questionnaire(cursor)
             if not questionnaire_id:
                 raise Exception("Failed to get or create questionnaire")
-
-            # (3) Prepare response_data JSON
+    
+            # Prepare response data JSON
             response_data = {
                 'patient_info': {
                     'name': questionnaire_data.get('patient_name', ''),
@@ -136,8 +129,8 @@ class DashboardDatabaseManager:
                     'additional_notes': questionnaire_data.get('additional_notes', '')
                 }
             }
-
-            # (4) Insert into questionnaire_responses
+    
+            # Insert into questionnaire_responses
             insert_resp = """
                 INSERT INTO questionnaire_responses
                     (questionnaire_id, patient_id, practitioner_id, response_data, submitted_at)
@@ -151,13 +144,13 @@ class DashboardDatabaseManager:
                 datetime.now()
             ))
             response_id = cursor.lastrowid
-
+    
             connection.commit()
             logging.info(f"✅ Saved questionnaire response ID {response_id}")
             return response_id
-
+    
         except Exception as e:
-            logging.error(f"❌ Error saving questionnaire response: {e}")
+            logging.error(f"❌ Error saving questionnaire: {e}")
             if connection:
                 connection.rollback()
             return None
@@ -167,39 +160,18 @@ class DashboardDatabaseManager:
             if connection:
                 connection.close()
     
-    def _get_or_create_default_questionnaire(self, cursor) -> Optional[int]:
-        """Get or create default questionnaire"""
-        try:
-            # Check if default questionnaire exists
-            cursor.execute("SELECT id FROM questionnaires WHERE name = 'Default Patient Assessment' LIMIT 1")
-            questionnaire_row = cursor.fetchone()
-            
-            if questionnaire_row:
-                return questionnaire_row[0]
-            
-            # Create default questionnaire
-            cursor.execute("""
-                INSERT INTO questionnaires (name, description, created_at) 
-                VALUES ('Default Patient Assessment', 'Standard patient wound assessment form', NOW())
-            """)
-            return cursor.lastrowid
-            
-        except Exception as e:
-            logging.error(f"Error getting/creating questionnaire: {e}")
-            return None
-    
-    def _create_or_get_patient(self, cursor, questionnaire_data: Dict[str, Any]) -> Optional[int]:
+    def _create_or_get_patient(self, cursor, questionnaire_data):
         """Create or get existing patient record"""
         try:
-            # Check if patient exists by name and age
+            # Check if patient exists
             select_query = """
             SELECT id FROM patients 
-            WHERE name = %s AND age = %s
-            LIMIT 1
+            WHERE name = %s AND age = %s AND gender = %s
             """
             cursor.execute(select_query, (
                 questionnaire_data.get('patient_name', ''),
-                questionnaire_data.get('patient_age', 0)
+                questionnaire_data.get('patient_age', 0),
+                questionnaire_data.get('patient_gender', '')
             ))
             
             existing_patient = cursor.fetchone()
@@ -231,75 +203,112 @@ class DashboardDatabaseManager:
             logging.error(f"Error creating/getting patient: {e}")
             return None
     
-    def save_wound_image(self, questionnaire_response_id: int, image, original_filename: str = None) -> Optional[int]:
-        """Save wound image to filesystem and database"""
+    def _get_or_create_default_questionnaire(self, cursor):
+        """Get or create default questionnaire"""
         try:
-            # Generate unique filename
-            image_id = str(uuid.uuid4())
-            filename = f"wound_{image_id}.jpg"
-            file_path = os.path.join("uploads", filename)
+            # Check if default questionnaire exists
+            cursor.execute("SELECT id FROM questionnaires WHERE name = 'Default Patient Assessment' LIMIT 1")
+            questionnaire_row = cursor.fetchone()
+            
+            if questionnaire_row:
+                return questionnaire_row[0]
+            
+            # Create default questionnaire
+            cursor.execute("""
+                INSERT INTO questionnaires (name, description, created_at) 
+                VALUES ('Default Patient Assessment', 'Standard patient wound assessment form', NOW())
+            """)
+            return cursor.lastrowid
+            
+        except Exception as e:
+            logging.error(f"Error getting/creating questionnaire: {e}")
+            return None
+    
+    def save_wound_image(self, response_id, image, filename):
+        """Save wound image to dataset and database with proper URL"""
+        try:
+            # Generate unique filename with timestamp
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            unique_id = str(uuid.uuid4())[:8]
+            file_extension = os.path.splitext(filename)[1] or '.jpg'
+            unique_filename = f"wound_{timestamp}_{unique_id}{file_extension}"
             
-            # Ensure uploads directory exists
-            os.makedirs("uploads", exist_ok=True)
+            # Create dataset directory structure
+            dataset_dir = os.path.join("dataset", "wound_images")
+            os.makedirs(dataset_dir, exist_ok=True)
+            
+            # Save image to dataset
+            file_path = os.path.join(dataset_dir, unique_filename)
             
-            # Save image to disk
             if hasattr(image, 'save'):
                 image.save(file_path, format='JPEG', quality=95)
-                
-                # Get image dimensions and file size
                 width, height = image.size
                 file_size = os.path.getsize(file_path)
+            else:
+                # Handle numpy array or other formats
+                from PIL import Image as PILImage
+                if hasattr(image, 'shape'):
+                    pil_image = PILImage.fromarray(image)
+                    pil_image.save(file_path, format='JPEG', quality=95)
+                    width, height = pil_image.size
+                    file_size = os.path.getsize(file_path)
+                else:
+                    raise ValueError("Unsupported image format")
+            
+            # Create URL for dashboard access
+            image_url = f"/dataset/wound_images/{unique_filename}"
+            
+            # Save to database
+            query = """
+            INSERT INTO wound_images (
+                questionnaire_response_id, image_url, original_filename, 
+                file_size, image_width, image_height, created_at
+            ) VALUES (%s, %s, %s, %s, %s, %s, %s)
+            """
+            
+            params = (
+                response_id,
+                image_url,
+                filename,
+                file_size,
+                width,
+                height,
+                datetime.now()
+            )
+            
+            connection = self.get_connection()
+            if not connection:
+                return None
+            
+            try:
+                cursor = connection.cursor()
+                cursor.execute(query, params)
+                connection.commit()
+                image_id = cursor.lastrowid
                 
-                # Save to wound_images table
-                query = """
-                INSERT INTO wound_images (
-                    questionnaire_id, image_url, original_filename, file_size, 
-                    image_width, image_height, created_at
-                ) VALUES (%s, %s, %s, %s, %s, %s, %s)
-                """
+                logging.info(f"✅ Image saved to dataset: {file_path}")
+                logging.info(f"✅ Image URL: {image_url}")
+                logging.info(f"✅ Database image ID: {image_id}")
                 
-                params = (
-                    questionnaire_response_id,
-                    file_path,
-                    original_filename or filename,
-                    file_size,
-                    width,
-                    height,
-                    datetime.now()
-                )
+                return image_id
                 
-                result = self.execute_query(query, params)
-                if result:
-                    # Get the inserted ID
-                    connection = self.get_connection()
-                    cursor = connection.cursor()
-                    cursor.execute("SELECT LAST_INSERT_ID()")
-                    image_db_id = cursor.fetchone()[0]
-                    cursor.close()
-                    connection.close()
-                    
-                    logging.info(f"✅ Image saved with ID: {image_db_id}")
-                    return image_db_id
+            finally:
+                cursor.close()
+                connection.close()
                 
         except Exception as e:
             logging.error(f"❌ Error saving wound image: {e}")
-            
-        return None
+            return None
     
-    def save_ai_analysis(self, analysis_data: Dict[str, Any]) -> Optional[int]:
-        """
-        Save AI analysis results to dashboard-compatible ai_analyses table
-        """
+    def save_ai_analysis(self, analysis_data):
+        """Save AI analysis results to database"""
         try:
-            query = """
-            INSERT INTO ai_analyses (
-                questionnaire_id, image_id, analysis_data, summary, recommendations,
-                risk_score, risk_level, wound_type, wound_dimensions, processing_time,
-                model_version, created_at
-            ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
-            """
+            # Extract data from analysis_data
+            response_id = analysis_data.get('questionnaire_id')  # This is actually response_id
+            image_id = analysis_data.get('image_id')
+            visual_results = analysis_data.get('visual_results', {})
             
-            # Calculate risk level based on risk score
+            # Calculate risk level from risk score
             risk_score = analysis_data.get('risk_score', 0)
             if risk_score >= 70:
                 risk_level = 'High'
@@ -308,89 +317,99 @@ class DashboardDatabaseManager:
             else:
                 risk_level = 'Low'
             
-            # Format wound dimensions
-            visual_results = analysis_data.get('visual_results', {})
-            wound_dimensions = f"{visual_results.get('length_cm', 0)}x{visual_results.get('breadth_cm', 0)} cm"
+            # Prepare wound dimensions string
+            length = visual_results.get('length_cm', 0)
+            breadth = visual_results.get('breadth_cm', 0)
+            area = visual_results.get('surface_area_cm2', 0)
+            wound_dimensions = f"{length} × {breadth} cm (Area: {area} cm²)"
+            
+            query = """
+            INSERT INTO ai_analyses (
+                questionnaire_response_id, image_id, analysis_data, summary, 
+                recommendations, risk_score, risk_level, wound_type, 
+                wound_dimensions, processing_time, model_version, created_at
+            ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+            """
             
             params = (
-                analysis_data.get('questionnaire_id'),
-                analysis_data.get('image_id'),
+                response_id,
+                image_id,
                 json.dumps(analysis_data.get('analysis_data', {})),
-                analysis_data.get('summary', ''),
+                analysis_data.get('summary', '')[:1000],  # Limit summary length
                 analysis_data.get('recommendations', ''),
                 risk_score,
                 risk_level,
                 visual_results.get('wound_type', 'Unknown'),
                 wound_dimensions,
-                analysis_data.get('processing_time', 0.0),
+                analysis_data.get('processing_time', 0),
                 analysis_data.get('model_version', 'v1.0'),
                 datetime.now()
             )
             
             result = self.execute_query(query, params)
-            if result:
-                # Get the inserted ID
+            if result is not None:
+                # Get the last inserted ID
                 connection = self.get_connection()
-                cursor = connection.cursor()
-                cursor.execute("SELECT LAST_INSERT_ID()")
-                analysis_id = cursor.fetchone()[0]
-                cursor.close()
-                connection.close()
-                
-                logging.info(f"✅ AI analysis saved with ID: {analysis_id}")
-                return analysis_id
-                
+                if connection:
+                    cursor = connection.cursor()
+                    cursor.execute("SELECT LAST_INSERT_ID()")
+                    analysis_id = cursor.fetchone()[0]
+                    cursor.close()
+                    connection.close()
+                    
+                    logging.info(f"✅ AI analysis saved with ID: {analysis_id}")
+                    return analysis_id
+            
+            return None
+            
         except Exception as e:
             logging.error(f"❌ Error saving AI analysis: {e}")
-            
-        return None
+            return None
     
-    def save_analysis_session(self, session_data: Dict[str, Any]) -> Optional[int]:
-        """
-        Save analysis session data for dashboard analytics
-        """
+    def save_analysis_session(self, session_data):
+        """Save analysis session data"""
         try:
             query = """
             INSERT INTO analysis_sessions (
-                user_id, questionnaire_id, image_id, analysis_id, 
+                user_id, questionnaire_response_id, image_id, analysis_id, 
                 session_duration, created_at
             ) VALUES (%s, %s, %s, %s, %s, %s)
             """
             
             params = (
                 session_data.get('user_id'),
-                session_data.get('questionnaire_id'),
+                session_data.get('questionnaire_id'),  # This is actually response_id
                 session_data.get('image_id'),
                 session_data.get('analysis_id'),
-                session_data.get('session_duration', 0.0),
+                session_data.get('session_duration', 0),
                 datetime.now()
             )
             
             result = self.execute_query(query, params)
-            if result:
+            if result is not None:
                 connection = self.get_connection()
-                cursor = connection.cursor()
-                cursor.execute("SELECT LAST_INSERT_ID()")
-                session_id = cursor.fetchone()[0]
-                cursor.close()
-                connection.close()
-                
-                logging.info(f"✅ Analysis session saved with ID: {session_id}")
-                return session_id
-                
+                if connection:
+                    cursor = connection.cursor()
+                    cursor.execute("SELECT LAST_INSERT_ID()")
+                    session_id = cursor.fetchone()[0]
+                    cursor.close()
+                    connection.close()
+                    
+                    logging.info(f"✅ Analysis session saved with ID: {session_id}")
+                    return session_id
+            
+            return None
+            
         except Exception as e:
             logging.error(f"❌ Error saving analysis session: {e}")
-            
-        return None
+            return None
     
-    def save_bot_interaction(self, interaction_data: Dict[str, Any]) -> Optional[int]:
-        """
-        Save bot interaction data for dashboard analytics
-        """
+    def save_bot_interaction(self, interaction_data):
+        """Save bot interaction data"""
         try:
             query = """
             INSERT INTO bot_interactions (
-                patient_id, practitioner_id, input_text, output_text,
+                patient_id, practitioner_id, input_text, output_text, 
                 wound_image_url, interaction_type, interacted_at
             ) VALUES (%s, %s, %s, %s, %s, %s, %s)
             """
@@ -401,127 +420,105 @@ class DashboardDatabaseManager:
                 interaction_data.get('input_text', ''),
                 interaction_data.get('output_text', ''),
                 interaction_data.get('wound_image_url', ''),
-                interaction_data.get('interaction_type', 'analysis'),
+                interaction_data.get('interaction_type', 'wound_analysis'),
                 datetime.now()
             )
             
             result = self.execute_query(query, params)
-            if result:
+            if result is not None:
                 connection = self.get_connection()
-                cursor = connection.cursor()
-                cursor.execute("SELECT LAST_INSERT_ID()")
-                interaction_id = cursor.fetchone()[0]
-                cursor.close()
-                connection.close()
-                
-                logging.info(f"✅ Bot interaction saved with ID: {interaction_id}")
-                return interaction_id
-                
+                if connection:
+                    cursor = connection.cursor()
+                    cursor.execute("SELECT LAST_INSERT_ID()")
+                    interaction_id = cursor.fetchone()[0]
+                    cursor.close()
+                    connection.close()
+                    
+                    logging.info(f"✅ Bot interaction saved with ID: {interaction_id}")
+                    return interaction_id
+            
+            return None
+            
         except Exception as e:
             logging.error(f"❌ Error saving bot interaction: {e}")
-            
-        return None
+            return None
     
-    def get_analytics_data(self) -> Dict[str, Any]:
-        """
-        Get comprehensive analytics data for dashboard
-        """
+    def get_analytics_data(self):
+        """Get comprehensive analytics data for dashboard"""
         try:
             analytics = {}
             
             # Total analyses
-            total_analyses = self.execute_query_one("SELECT COUNT(*) as count FROM ai_analyses")
-            analytics['total_analyses'] = total_analyses['count'] if total_analyses else 0
+            result = self.execute_query_one("SELECT COUNT(*) as count FROM ai_analyses")
+            analytics['total_analyses'] = result['count'] if result else 0
             
             # Average processing time
-            avg_time = self.execute_query_one("SELECT AVG(processing_time) as avg_time FROM ai_analyses WHERE processing_time IS NOT NULL")
-            analytics['avg_processing_time'] = round(avg_time['avg_time'], 2) if avg_time and avg_time['avg_time'] else 0
+            result = self.execute_query_one("""
+                SELECT AVG(processing_time) as avg_time FROM ai_analyses 
+                WHERE processing_time IS NOT NULL
+            """)
+            analytics['avg_processing_time'] = round(result['avg_time'], 2) if result and result['avg_time'] else 0
             
             # High risk count
-            high_risk = self.execute_query_one("SELECT COUNT(*) as count FROM ai_analyses WHERE risk_level = 'High'")
-            analytics['high_risk_count'] = high_risk['count'] if high_risk else 0
+            result = self.execute_query_one("""
+                SELECT COUNT(*) as count FROM ai_analyses 
+                WHERE risk_level = 'High'
+            """)
+            analytics['high_risk_count'] = result['count'] if result else 0
             
             # Average risk score
-            avg_risk = self.execute_query_one("SELECT AVG(risk_score) as avg_risk FROM ai_analyses WHERE risk_score IS NOT NULL")
-            analytics['avg_risk_score'] = round(avg_risk['avg_risk'], 1) if avg_risk and avg_risk['avg_risk'] else 0
-            
-            # Risk level distribution
-            risk_distribution = self.execute_query("""
-                SELECT risk_level, COUNT(*) as count 
-                FROM ai_analyses 
-                GROUP BY risk_level
-            """, fetch=True)
-            
-            analytics['risk_level_distribution'] = {}
-            if risk_distribution:
-                for row in risk_distribution:
-                    analytics['risk_level_distribution'][row['risk_level']] = row['count']
-            
-            # Recent analyses
-            recent_analyses = self.execute_query("""
-                SELECT * FROM ai_analyses 
-                ORDER BY created_at DESC 
-                LIMIT 10
-            """, fetch=True)
-            analytics['recent_analyses'] = recent_analyses or []
-            
-            # Model performance
-            model_performance = self.execute_query("""
-                SELECT 
-                    model_version,
-                    COUNT(*) as count,
-                    AVG(processing_time) as avg_processing_time,
-                    AVG(risk_score) as avg_risk_score
-                FROM ai_analyses 
-                WHERE model_version IS NOT NULL
-                GROUP BY model_version
-            """, fetch=True)
-            analytics['model_performance'] = model_performance or []
-            
-            # Today's analyses
-            today_analyses = self.execute_query_one("""
-                SELECT COUNT(*) as count 
-                FROM ai_analyses 
+            result = self.execute_query_one("""
+                SELECT AVG(risk_score) as avg_risk FROM ai_analyses 
+                WHERE risk_score IS NOT NULL
+            """)
+            analytics['avg_risk_score'] = round(result['avg_risk'], 1) if result and result['avg_risk'] else 0
+            
+            # Analyses today
+            result = self.execute_query_one("""
+                SELECT COUNT(*) as count FROM ai_analyses 
                 WHERE DATE(created_at) = CURDATE()
             """)
-            analytics['analyses_today'] = today_analyses['count'] if today_analyses else 0
+            analytics['analyses_today'] = result['count'] if result else 0
             
-            # This week's analyses
-            week_analyses = self.execute_query_one("""
-                SELECT COUNT(*) as count 
-                FROM ai_analyses 
+            # Analyses this week
+            result = self.execute_query_one("""
+                SELECT COUNT(*) as count FROM ai_analyses 
                 WHERE YEARWEEK(created_at) = YEARWEEK(NOW())
             """)
-            analytics['analyses_this_week'] = week_analyses['count'] if week_analyses else 0
+            analytics['analyses_this_week'] = result['count'] if result else 0
             
-            # Unique questionnaires
-            unique_questionnaires = self.execute_query_one("""
-                SELECT COUNT(DISTINCT questionnaire_id) as count 
-                FROM ai_analyses
+            # Unique questionnaire responses
+            result = self.execute_query_one("""
+                SELECT COUNT(DISTINCT questionnaire_response_id) as count FROM ai_analyses
             """)
-            analytics['unique_questionnaires'] = unique_questionnaires['count'] if unique_questionnaires else 0
+            analytics['unique_questionnaires'] = result['count'] if result else 0
             
             # Analyses with images
-            with_images = self.execute_query_one("""
-                SELECT COUNT(*) as count 
-                FROM ai_analyses 
+            result = self.execute_query_one("""
+                SELECT COUNT(*) as count FROM ai_analyses 
                 WHERE image_id IS NOT NULL
             """)
-            analytics['analyses_with_images'] = with_images['count'] if with_images else 0
+            analytics['analyses_with_images'] = result['count'] if result else 0
             
             return analytics
             
         except Exception as e:
-            logging.error(f"❌ Error getting analytics data: {e}")
+            logging.error(f"Error getting analytics data: {e}")
             return {}
     
-    def get_interaction_history(self, limit: int = 50) -> List[Dict[str, Any]]:
-        """
-        Get bot interaction history for dashboard
-        """
+    def get_interaction_history(self, limit=50):
+        """Get bot interaction history"""
         try:
             query = """
-            SELECT bi.*, p.name as patient_name, u.name as practitioner_name
+            SELECT 
+                bi.id,
+                bi.input_text,
+                bi.output_text,
+                bi.wound_image_url,
+                bi.interaction_type,
+                bi.interacted_at,
+                p.name as patient_name,
+                u.name as practitioner_name
             FROM bot_interactions bi
             LEFT JOIN patients p ON bi.patient_id = p.id
             LEFT JOIN users u ON bi.practitioner_id = u.id
@@ -529,43 +526,38 @@ class DashboardDatabaseManager:
             LIMIT %s
             """
             
-            interactions = self.execute_query(query, (limit,), fetch=True)
-            return interactions or []
+            results = self.execute_query(query, (limit,), fetch=True)
+            return results or []
             
         except Exception as e:
-            logging.error(f"❌ Error getting interaction history: {e}")
+            logging.error(f"Error getting interaction history: {e}")
             return []
     
-    def get_session_analytics(self) -> Dict[str, Any]:
-        """
-        Get session analytics for dashboard
-        """
+    def get_session_analytics(self):
+        """Get session analytics data"""
         try:
             analytics = {}
             
             # Total sessions
-            total_sessions = self.execute_query_one("SELECT COUNT(*) as count FROM analysis_sessions")
-            analytics['total_sessions'] = total_sessions['count'] if total_sessions else 0
+            result = self.execute_query_one("SELECT COUNT(*) as count FROM analysis_sessions")
+            analytics['total_sessions'] = result['count'] if result else 0
             
             # Average session duration
-            avg_duration = self.execute_query_one("""
-                SELECT AVG(session_duration) as avg_duration 
-                FROM analysis_sessions 
+            result = self.execute_query_one("""
+                SELECT AVG(session_duration) as avg_duration FROM analysis_sessions 
                 WHERE session_duration IS NOT NULL
             """)
-            analytics['avg_session_duration'] = round(avg_duration['avg_duration'], 2) if avg_duration and avg_duration['avg_duration'] else 0
+            analytics['avg_session_duration'] = round(result['avg_duration'], 2) if result and result['avg_duration'] else 0
             
             # Sessions today
-            today_sessions = self.execute_query_one("""
-                SELECT COUNT(*) as count 
-                FROM analysis_sessions 
+            result = self.execute_query_one("""
+                SELECT COUNT(*) as count FROM analysis_sessions 
                 WHERE DATE(created_at) = CURDATE()
             """)
-            analytics['sessions_today'] = today_sessions['count'] if today_sessions else 0
+            analytics['sessions_today'] = result['count'] if result else 0
             
             return analytics
             
         except Exception as e:
-            logging.error(f"❌ Error getting session analytics: {e}")
-            return {}
-
+            logging.error(f"Error getting session analytics: {e}")
+            return {}