more refactoring

community/helpers/report_utils.py

@@ -0,0 +1,154 @@
+"""Report generation and formatting utility functions."""
+
+from typing import Dict, List, Any
+import time
+
+
+def generate_activity_report(database_results: Dict[str, List[Dict]]) -> Dict[str, Any]:
+    """Generate an activity report from database results.
+    
+    Args:
+        database_results: Dictionary containing 'active', 'inactive', 'ignored' results
+        
+    Returns:
+        dict: Formatted activity report
+    """
+    report = {}
+    
+    # Process active users
+    active_results = database_results.get("active", [])
+    report["active"] = [row["mxid"] for row in active_results] or ["none"]
+    
+    # Process inactive users  
+    inactive_results = database_results.get("inactive", [])
+    report["inactive"] = [row["mxid"] for row in inactive_results] or ["none"]
+    
+    # Process ignored users
+    ignored_results = database_results.get("ignored", [])
+    report["ignored"] = [row["mxid"] for row in ignored_results] or ["none"]
+    
+    return report
+
+
+def split_doctor_report(report_text: str, max_chunk_size: int = 4000) -> List[str]:
+    """Split a doctor report into chunks that fit within size limits.
+    
+    Args:
+        report_text: The full report text
+        max_chunk_size: Maximum size per chunk
+        
+    Returns:
+        list: List of report chunks
+    """
+    if len(report_text) <= max_chunk_size:
+        return [report_text]
+    
+    # Try to split by sections first
+    sections = _split_by_sections(report_text, max_chunk_size)
+    if sections:
+        return sections
+    
+    # Fall back to character-based splitting
+    chunks = []
+    current_chunk = ""
+    
+    for line in report_text.split('\n'):
+        if len(current_chunk) + len(line) + 1 > max_chunk_size:
+            if current_chunk:
+                chunks.append(current_chunk.strip())
+                current_chunk = line
+            else:
+                # Single line is too long, split it
+                chunks.append(line[:max_chunk_size])
+                current_chunk = line[max_chunk_size:]
+        else:
+            if current_chunk:
+                current_chunk += '\n' + line
+            else:
+                current_chunk = line
+    
+    if current_chunk:
+        chunks.append(current_chunk.strip())
+    
+    return chunks
+
+
+def _split_by_sections(text: str, max_size: int) -> List[str]:
+    """Split text by sections (lines starting with specific patterns).
+    
+    Args:
+        text: The text to split
+        max_size: Maximum size per section
+        
+    Returns:
+        list: List of text sections
+    """
+    section_headers = ["Active users:", "Inactive users:", "Ignored users:"]
+    sections = []
+    current_section = ""
+    
+    lines = text.split('\n')
+    for line in lines:
+        if any(line.startswith(header) for header in section_headers):
+            if current_section and len(current_section) > max_size:
+                # Current section is too big, need to split it further
+                return []
+            if current_section:
+                sections.append(current_section.strip())
+            current_section = line
+        else:
+            if len(current_section) + len(line) + 1 > max_size:
+                # This section would be too big
+                return []
+            if current_section:
+                current_section += '\n' + line
+            else:
+                current_section = line
+    
+    if current_section:
+        sections.append(current_section.strip())
+    
+    return sections if all(len(s) <= max_size for s in sections) else []
+
+
+def format_ban_results(ban_event_map: Dict[str, List[str]]) -> str:
+    """Format ban results for display.
+    
+    Args:
+        ban_event_map: Dictionary containing ban results
+        
+    Returns:
+        str: Formatted ban results
+    """
+    ban_list = ban_event_map.get("ban_list", {})
+    error_list = ban_event_map.get("error_list", {})
+    
+    result_parts = []
+    
+    for user, rooms in ban_list.items():
+        if rooms:
+            result_parts.append(f"Banned {user} from: {', '.join(rooms)}")
+    
+    for user, rooms in error_list.items():
+        if rooms:
+            result_parts.append(f"Failed to ban {user} from: {', '.join(rooms)}")
+    
+    return '\n'.join(result_parts) if result_parts else "No ban operations performed"
+
+
+def format_sync_results(sync_results: Dict[str, List[str]]) -> str:
+    """Format sync results for display.
+    
+    Args:
+        sync_results: Dictionary containing sync results
+        
+    Returns:
+        str: Formatted sync results
+    """
+    added = sync_results.get("added", [])
+    dropped = sync_results.get("dropped", [])
+    
+    added_str = "<br />".join(added) if added else "none"
+    dropped_str = "<br />".join(dropped) if dropped else "none"
+    
+    return f"Added: {added_str}<br /><br />Dropped: {dropped_str}"