feat: Enhance document processing and analysis features

- Added support for processing DOCX files and extracting content.
- Updated database schema to include a combined 'issues_and_recommendations' field.
- Improved error handling during document uploads and analysis.
- Modified the analysis display to show issues and recommendations in a structured format.
- Adjusted API call parameters for better performance and error management.

src/services/database.py

@@ -16,16 +16,70 @@ class Database:
             with sqlite3.connect(self.db_path) as conn:
                 cursor = conn.cursor()
                 
-                # Create analysis table
-                cursor.execute('''
-                    CREATE TABLE IF NOT EXISTS analysis (
-                        document_id TEXT PRIMARY KEY,
-                        summary TEXT,
-                        issues TEXT,
-                        recommendations TEXT,
-                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                    )
-                ''')
+                # Check if we need to migrate the old schema
+                cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='analysis'")
+                table_exists = cursor.fetchone() is not None
+                
+                if table_exists:
+                    # Check if we need to migrate
+                    cursor.execute("PRAGMA table_info(analysis)")
+                    columns = [column[1] for column in cursor.fetchall()]
+                    
+                    if 'issues_and_recommendations' not in columns:
+                        # Backup old data
+                        cursor.execute("SELECT document_id, summary, issues, recommendations FROM analysis")
+                        old_data = cursor.fetchall()
+                        
+                        # Drop the old table
+                        cursor.execute("DROP TABLE analysis")
+                        
+                        # Create the new table
+                        cursor.execute('''
+                            CREATE TABLE analysis (
+                                document_id TEXT PRIMARY KEY,
+                                summary TEXT,
+                                issues_and_recommendations TEXT,
+                                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                            )
+                        ''')
+                        
+                        # Migrate old data to new format
+                        for row in old_data:
+                            doc_id, summary, issues, recommendations = row
+                            try:
+                                old_issues = json.loads(issues) if issues else []
+                                old_recommendations = json.loads(recommendations) if recommendations else []
+                                
+                                # Combine issues and recommendations
+                                issues_and_recommendations = []
+                                for i in range(max(len(old_issues), len(old_recommendations))):
+                                    issue = old_issues[i]['issue'] if i < len(old_issues) else "Unknown Issue"
+                                    recommendation = old_recommendations[i] if i < len(old_recommendations) else "No recommendation provided"
+                                    issues_and_recommendations.append({
+                                        "issue": issue,
+                                        "recommendation": recommendation
+                                    })
+                                
+                                cursor.execute('''
+                                    INSERT INTO analysis (document_id, summary, issues_and_recommendations)
+                                    VALUES (?, ?, ?)
+                                ''', (
+                                    doc_id,
+                                    summary,
+                                    json.dumps(issues_and_recommendations)
+                                ))
+                            except Exception as e:
+                                logging.error(f"Error migrating data for document {doc_id}: {str(e)}")
+                else:
+                    # Create the new table if it doesn't exist
+                    cursor.execute('''
+                        CREATE TABLE IF NOT EXISTS analysis (
+                            document_id TEXT PRIMARY KEY,
+                            summary TEXT,
+                            issues_and_recommendations TEXT,
+                            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                        )
+                    ''')
                 
                 # Create metadata table
                 cursor.execute('''
@@ -49,13 +103,12 @@ class Database:
             with sqlite3.connect(self.db_path) as conn:
                 cursor = conn.cursor()
                 cursor.execute('''
-                    INSERT OR REPLACE INTO analysis (document_id, summary, issues, recommendations)
-                    VALUES (?, ?, ?, ?)
+                    INSERT OR REPLACE INTO analysis (document_id, summary, issues_and_recommendations)
+                    VALUES (?, ?, ?)
                 ''', (
                     document_id,
                     analysis['summary'],
-                    json.dumps(analysis['issues']),
-                    json.dumps(analysis['recommendations'])
+                    json.dumps(analysis['issues_and_recommendations'])
                 ))
                 conn.commit()
         except Exception as e:
@@ -67,7 +120,7 @@ class Database:
         try:
             with sqlite3.connect(self.db_path) as conn:
                 cursor = conn.cursor()
-                cursor.execute('SELECT summary, issues, recommendations FROM analysis WHERE document_id = ?', (document_id,))
+                cursor.execute('SELECT summary, issues_and_recommendations FROM analysis WHERE document_id = ?', (document_id,))
                 result = cursor.fetchone()
                 
                 if not result:
@@ -76,8 +129,7 @@ class Database:
                 return {
                     'document_id': document_id,
                     'summary': result[0],
-                    'issues': json.loads(result[1]),
-                    'recommendations': json.loads(result[2])
+                    'issues_and_recommendations': json.loads(result[1])
                 }
         except Exception as e:
             logging.error(f"Error retrieving analysis for document {document_id}: {str(e)}")