Initial commit

application/use_cases/export_accounts_use_case.py

@@ -0,0 +1,187 @@
+"""
+Export Accounts Use Case - Exportiert Account-Daten in verschiedene Formate
+"""
+
+import logging
+import csv
+import json
+from io import StringIO
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+logger = logging.getLogger("export_accounts_use_case")
+
+
+class ExportAccountsUseCase:
+    """
+    Use Case für Account-Export.
+    Exportiert Account-Daten in verschiedene Formate (CSV, JSON).
+    """
+    
+    def __init__(self, db_manager):
+        self.db_manager = db_manager
+        
+    def execute(self, 
+                platform: Optional[str] = None,
+                format: str = 'csv',
+                include_passwords: bool = True) -> bytes:
+        """
+        Exportiert Account-Daten.
+        
+        Args:
+            platform: Filter für spezifische Plattform (None = alle)
+            format: Export-Format ('csv' oder 'json')
+            include_passwords: Ob Passwörter inkludiert werden sollen
+            
+        Returns:
+            Exportierte Daten als Bytes
+        """
+        # Hole Account-Daten
+        if platform and platform.lower() not in ["all", ""]:
+            accounts = self.db_manager.get_accounts_by_platform(platform.lower())
+        else:
+            accounts = self.db_manager.get_all_accounts()
+            
+        if not accounts:
+            logger.warning(f"Keine Accounts gefunden für Export (platform: {platform})")
+            return b""
+        
+        # Exportiere basierend auf Format
+        if format.lower() == 'csv':
+            result = self._export_csv(accounts, include_passwords)
+        elif format.lower() == 'json':
+            result = self._export_json(accounts, include_passwords)
+        else:
+            raise ValueError(f"Unsupported format: {format}")
+            
+        logger.info(f"Exported {len(accounts)} accounts as {format}")
+        return result
+    
+    def _export_csv(self, accounts: List[Dict[str, Any]], include_passwords: bool) -> bytes:
+        """
+        Exportiert Accounts als CSV.
+        
+        Args:
+            accounts: Liste der Account-Daten
+            include_passwords: Ob Passwörter inkludiert werden sollen
+            
+        Returns:
+            CSV-Daten als Bytes
+        """
+        output = StringIO()
+        
+        # Definiere Header basierend auf Passwort-Einstellung
+        headers = [
+            'Plattform',
+            'Benutzername',
+            'E-Mail',
+            'Handynummer',
+            'Name',
+            'Geburtstag',
+            'Erstellt am'
+        ]
+        
+        if include_passwords:
+            headers.insert(2, 'Passwort')
+        
+        writer = csv.DictWriter(output, fieldnames=headers)
+        writer.writeheader()
+        
+        # Schreibe Account-Daten
+        for account in accounts:
+            row = {
+                'Plattform': account.get('platform', ''),
+                'Benutzername': account.get('username', ''),
+                'E-Mail': account.get('email', ''),
+                'Handynummer': account.get('phone', ''),
+                'Name': account.get('full_name', ''),
+                'Geburtstag': account.get('birthday', ''),
+                'Erstellt am': account.get('created_at', '')
+            }
+            
+            if include_passwords:
+                row['Passwort'] = account.get('password', '')
+            
+            writer.writerow(row)
+        
+        return output.getvalue().encode('utf-8-sig')  # UTF-8 mit BOM für Excel
+    
+    def _export_json(self, accounts: List[Dict[str, Any]], include_passwords: bool) -> bytes:
+        """
+        Exportiert Accounts als JSON.
+        
+        Args:
+            accounts: Liste der Account-Daten
+            include_passwords: Ob Passwörter inkludiert werden sollen
+            
+        Returns:
+            JSON-Daten als Bytes
+        """
+        export_data = {
+            'export_date': datetime.now().isoformat(),
+            'account_count': len(accounts),
+            'accounts': []
+        }
+        
+        for account in accounts:
+            account_data = {
+                'platform': account.get('platform', ''),
+                'username': account.get('username', ''),
+                'email': account.get('email', ''),
+                'phone': account.get('phone', ''),
+                'full_name': account.get('full_name', ''),
+                'birthday': account.get('birthday', ''),
+                'created_at': account.get('created_at', '')
+            }
+            
+            if include_passwords:
+                account_data['password'] = account.get('password', '')
+            
+            export_data['accounts'].append(account_data)
+        
+        return json.dumps(export_data, ensure_ascii=False, indent=2).encode('utf-8')
+    
+    def execute_with_accounts(self,
+                            accounts: List[Dict[str, Any]],
+                            format: str = 'csv',
+                            include_passwords: bool = True) -> bytes:
+        """
+        Exportiert spezifische Account-Daten.
+        
+        Args:
+            accounts: Liste der zu exportierenden Accounts
+            format: Export-Format ('csv' oder 'json')
+            include_passwords: Ob Passwörter inkludiert werden sollen
+            
+        Returns:
+            Exportierte Daten als Bytes
+        """
+        if not accounts:
+            logger.warning("Keine Accounts zum Export übergeben")
+            return b""
+        
+        # Exportiere basierend auf Format
+        if format.lower() == 'csv':
+            result = self._export_csv(accounts, include_passwords)
+        elif format.lower() == 'json':
+            result = self._export_json(accounts, include_passwords)
+        else:
+            raise ValueError(f"Unsupported format: {format}")
+            
+        logger.info(f"Exported {len(accounts)} specific accounts as {format}")
+        return result
+    
+    def get_export_filename(self, platform: Optional[str], format: str) -> str:
+        """
+        Generiert einen passenden Dateinamen für den Export.
+        
+        Args:
+            platform: Plattform-Filter
+            format: Export-Format
+            
+        Returns:
+            Vorgeschlagener Dateiname
+        """
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        platform_str = platform.lower() if platform else 'alle'
+        return f"accounts_{platform_str}_{timestamp}.{format}"