Fix PostgreSQL compatibility in get_comprehensive_analysis_data

- Replace complex CTE with separate simple queries
- Eliminate potential window function conflicts
- Split data retrieval into basic process data and interactions
- Combine results in Python for better PostgreSQL compatibility
- Maintain same functionality with improved database compatibility
- Should resolve aggregate function calls cannot contain window function calls error

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

utils/database.py

@@ -530,75 +530,70 @@ def get_comprehensive_analysis_data():
     """Retorna dados completos para análise com IA"""
     with get_db_connection() as conn:
         with conn.cursor(cursor_factory=RealDictCursor) as cur:
-            # Dados gerais dos processos
+            # Primeira query: dados básicos dos processos
             cur.execute("""
-                WITH checklist_progress AS (
-                    SELECT 
-                        c.id,
-                        c.numero_processo,
-                        c.created_at,
-                        COUNT(ci.id) as total_items,
-                        COUNT(CASE WHEN cis.is_checked THEN 1 END) as completed_items,
-                        CASE 
-                            WHEN COUNT(ci.id) > 0 THEN 
-                                ROUND((COUNT(CASE WHEN cis.is_checked THEN 1 END)::decimal / COUNT(ci.id)) * 100, 1)
-                            ELSE 0 
-                        END as progress_percentage
-                    FROM checklists c
-                    LEFT JOIN checklist_items ci ON c.id = ci.checklist_id
-                    LEFT JOIN current_item_states cis ON ci.id = cis.item_id
-                    WHERE c.numero_processo IS NOT NULL
-                    GROUP BY c.id, c.numero_processo, c.created_at
-                ),
-                process_stats AS (
-                    SELECT 
-                        cp.numero_processo,
-                        COUNT(cp.id) as total_checklists,
-                        MIN(cp.created_at) as process_start_date,
-                        MAX(cp.created_at) as latest_checklist_date,
-                        SUM(cp.total_items) as total_items,
-                        SUM(cp.completed_items) as completed_items,
-                        ROUND(AVG(cp.progress_percentage), 1) as avg_progress_percentage,
-                        COUNT(ii.id) as total_interactions,
-                        MIN(ii.timestamp) as first_interaction,
-                        MAX(ii.timestamp) as last_interaction,
-                        CURRENT_DATE - MIN(cp.created_at)::date as days_elapsed,
-                        (MIN(cp.created_at) + INTERVAL '180 days')::date - CURRENT_DATE as days_remaining_to_deadline
-                    FROM checklist_progress cp
-                    LEFT JOIN item_interactions ii ON cp.id = ii.checklist_id
-                    GROUP BY cp.numero_processo
-                )
                 SELECT 
-                    numero_processo,
-                    total_checklists,
-                    process_start_date,
-                    latest_checklist_date,
-                    total_items,
-                    completed_items,
-                    avg_progress_percentage,
-                    total_interactions,
-                    first_interaction,
-                    last_interaction,
-                    days_elapsed,
-                    days_remaining_to_deadline,
-                    CASE 
-                        WHEN avg_progress_percentage = 100 THEN 'CONCLUIDO'
-                        WHEN days_remaining_to_deadline < 0 THEN 'ATRASADO'
-                        WHEN days_remaining_to_deadline < 30 THEN 'EM_RISCO'
-                        ELSE 'NO_PRAZO'
-                    END as status_prazo,
+                    c.numero_processo,
+                    COUNT(DISTINCT c.id) as total_checklists,
+                    MIN(c.created_at) as process_start_date,
+                    MAX(c.created_at) as latest_checklist_date,
+                    COUNT(ci.id) as total_items,
+                    COUNT(CASE WHEN cis.is_checked THEN 1 END) as completed_items,
                     CASE 
-                        WHEN days_elapsed > 0 AND avg_progress_percentage > 0 THEN
-                            ROUND((avg_progress_percentage / days_elapsed) * (100 - avg_progress_percentage), 0)
-                        ELSE NULL
-                    END as projected_days_to_complete
-                FROM process_stats
+                        WHEN COUNT(ci.id) > 0 THEN 
+                            ROUND((COUNT(CASE WHEN cis.is_checked THEN 1 END)::decimal / COUNT(ci.id)) * 100, 1)
+                        ELSE 0 
+                    END as avg_progress_percentage,
+                    CURRENT_DATE - MIN(c.created_at)::date as days_elapsed,
+                    (MIN(c.created_at) + INTERVAL '180 days')::date - CURRENT_DATE as days_remaining_to_deadline
+                FROM checklists c
+                LEFT JOIN checklist_items ci ON c.id = ci.checklist_id
+                LEFT JOIN current_item_states cis ON ci.id = cis.item_id
+                WHERE c.numero_processo IS NOT NULL
+                GROUP BY c.numero_processo
                 ORDER BY days_remaining_to_deadline ASC
             """)
             
-            process_data = cur.fetchall()
+            basic_process_data = cur.fetchall()
+            
+            # Segunda query: dados de interações por processo
+            process_data = []
+            for process in basic_process_data:
+                cur.execute("""
+                    SELECT 
+                        COUNT(ii.id) as total_interactions,
+                        MIN(ii.timestamp) as first_interaction,
+                        MAX(ii.timestamp) as last_interaction
+                    FROM checklists c
+                    LEFT JOIN item_interactions ii ON c.id = ii.checklist_id
+                    WHERE c.numero_processo = %s
+                """, (process['numero_processo'],))
+                
+                interaction_data = cur.fetchone()
+                
+                # Combinar dados
+                combined_process = dict(process)
+                combined_process.update(interaction_data)
+                
+                # Adicionar campos calculados
+                combined_process['status_prazo'] = (
+                    'CONCLUIDO' if combined_process['avg_progress_percentage'] == 100 
+                    else 'ATRASADO' if combined_process['days_remaining_to_deadline'] < 0
+                    else 'EM_RISCO' if combined_process['days_remaining_to_deadline'] < 30
+                    else 'NO_PRAZO'
+                )
+                
+                if combined_process['days_elapsed'] > 0 and combined_process['avg_progress_percentage'] > 0:
+                    combined_process['projected_days_to_complete'] = round(
+                        (combined_process['avg_progress_percentage'] / combined_process['days_elapsed']) * 
+                        (100 - combined_process['avg_progress_percentage'])
+                    )
+                else:
+                    combined_process['projected_days_to_complete'] = None
+                
+                process_data.append(combined_process)
             
-            # Estatísticas globais
+            # Estatísticas globais - query simples
             cur.execute("""
                 SELECT 
                     COUNT(DISTINCT c.id) as total_checklists_global,