Initial commit

application/use_cases/generate_reports_use_case.py

@@ -0,0 +1,548 @@
+"""
+Generate Reports Use Case - Erstellt detaillierte Berichte
+"""
+
+import logging
+import json
+import csv
+from io import StringIO
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timedelta
+import uuid
+
+from domain.services.analytics_service import IAnalyticsService
+from domain.value_objects.report import (
+    Report, ReportType, Metric, PlatformStats, 
+    TimeSeriesData, MetricType
+)
+
+logger = logging.getLogger("generate_reports_use_case")
+
+
+class GenerateReportsUseCase:
+    """
+    Use Case für Report-Generierung.
+    Erstellt tägliche/wöchentliche Reports mit Erfolgsstatistiken,
+    Performance-Metriken und Fehler-Zusammenfassungen.
+    """
+    
+    def __init__(self, analytics_service: IAnalyticsService):
+        self.analytics_service = analytics_service
+        self.report_templates = {
+            ReportType.DAILY: self._generate_daily_report,
+            ReportType.WEEKLY: self._generate_weekly_report,
+            ReportType.MONTHLY: self._generate_monthly_report,
+            ReportType.CUSTOM: self._generate_custom_report,
+            ReportType.REAL_TIME: self._generate_realtime_report
+        }
+        
+    def execute(self, 
+                report_type: ReportType,
+                start_date: Optional[datetime] = None,
+                end_date: Optional[datetime] = None,
+                platforms: Optional[List[str]] = None,
+                include_charts: bool = True) -> Report:
+        """
+        Generiert einen Report.
+        
+        Args:
+            report_type: Typ des Reports
+            start_date: Startdatum (optional für vordefinierte Typen)
+            end_date: Enddatum (optional für vordefinierte Typen)
+            platforms: Filter für spezifische Plattformen
+            include_charts: Ob Zeitreihen-Daten inkludiert werden sollen
+            
+        Returns:
+            Generierter Report
+        """
+        # Bestimme Zeitrahmen basierend auf Report-Typ
+        if not start_date or not end_date:
+            start_date, end_date = self._determine_timeframe(report_type)
+        
+        # Generiere Report mit entsprechendem Template
+        generator = self.report_templates.get(report_type, self._generate_custom_report)
+        report = generator(start_date, end_date, platforms, include_charts)
+        
+        # Logge Report-Generierung
+        logger.info(f"Generated {report_type.value} report: {report.report_id} "
+                   f"({report.total_accounts_created} accounts, "
+                   f"{report.overall_success_rate:.1%} success rate)")
+        
+        return report
+    
+    def _determine_timeframe(self, report_type: ReportType) -> tuple[datetime, datetime]:
+        """Bestimmt Zeitrahmen basierend auf Report-Typ"""
+        end_date = datetime.now()
+        
+        if report_type == ReportType.DAILY:
+            start_date = end_date - timedelta(days=1)
+        elif report_type == ReportType.WEEKLY:
+            start_date = end_date - timedelta(weeks=1)
+        elif report_type == ReportType.MONTHLY:
+            start_date = end_date - timedelta(days=30)
+        elif report_type == ReportType.REAL_TIME:
+            start_date = end_date - timedelta(hours=1)
+        else:
+            start_date = end_date - timedelta(days=7)  # Default
+        
+        return start_date, end_date
+    
+    def _generate_daily_report(self, 
+                             start: datetime,
+                             end: datetime,
+                             platforms: Optional[List[str]],
+                             include_charts: bool) -> Report:
+        """Generiert täglichen Report"""
+        # Hole Basis-Report
+        base_report = self.analytics_service.generate_report(
+            ReportType.DAILY, start, end, platforms
+        )
+        
+        # Erweitere mit täglichen Insights
+        insights = [
+            self._generate_daily_summary(base_report),
+            self._generate_peak_time_insight(base_report),
+            self._generate_error_trend_insight(base_report)
+        ]
+        
+        # Füge Empfehlungen hinzu
+        recommendations = self._generate_daily_recommendations(base_report)
+        
+        # Erstelle finalen Report
+        return Report(
+            report_id=base_report.report_id,
+            report_type=ReportType.DAILY,
+            start_date=start,
+            end_date=end,
+            generated_at=datetime.now(),
+            total_accounts_created=base_report.total_accounts_created,
+            total_attempts=base_report.total_attempts,
+            overall_success_rate=base_report.overall_success_rate,
+            avg_creation_time=base_report.avg_creation_time,
+            metrics=base_report.metrics,
+            platform_stats=base_report.platform_stats,
+            error_summaries=base_report.error_summaries,
+            success_rate_timeline=base_report.success_rate_timeline,
+            creation_rate_timeline=base_report.creation_rate_timeline,
+            error_rate_timeline=base_report.error_rate_timeline,
+            insights=insights,
+            recommendations=recommendations
+        )
+    
+    def _generate_weekly_report(self, 
+                              start: datetime,
+                              end: datetime,
+                              platforms: Optional[List[str]],
+                              include_charts: bool) -> Report:
+        """Generiert wöchentlichen Report"""
+        base_report = self.analytics_service.generate_report(
+            ReportType.WEEKLY, start, end, platforms
+        )
+        
+        # Wöchentliche Trends
+        insights = [
+            self._generate_weekly_trend(base_report),
+            self._generate_platform_comparison(base_report),
+            self._generate_success_pattern_insight(base_report)
+        ]
+        
+        recommendations = self._generate_weekly_recommendations(base_report)
+        
+        return Report(
+            report_id=base_report.report_id,
+            report_type=ReportType.WEEKLY,
+            start_date=start,
+            end_date=end,
+            generated_at=datetime.now(),
+            total_accounts_created=base_report.total_accounts_created,
+            total_attempts=base_report.total_attempts,
+            overall_success_rate=base_report.overall_success_rate,
+            avg_creation_time=base_report.avg_creation_time,
+            metrics=base_report.metrics,
+            platform_stats=base_report.platform_stats,
+            error_summaries=base_report.error_summaries,
+            success_rate_timeline=base_report.success_rate_timeline,
+            creation_rate_timeline=base_report.creation_rate_timeline,
+            error_rate_timeline=base_report.error_rate_timeline,
+            insights=insights,
+            recommendations=recommendations
+        )
+    
+    def _generate_monthly_report(self, 
+                               start: datetime,
+                               end: datetime,
+                               platforms: Optional[List[str]],
+                               include_charts: bool) -> Report:
+        """Generiert monatlichen Report"""
+        base_report = self.analytics_service.generate_report(
+            ReportType.MONTHLY, start, end, platforms
+        )
+        
+        # Monatliche Zusammenfassung
+        insights = [
+            self._generate_monthly_summary(base_report),
+            self._generate_growth_analysis(base_report),
+            self._generate_efficiency_insight(base_report)
+        ]
+        
+        recommendations = self._generate_strategic_recommendations(base_report)
+        
+        return Report(
+            report_id=base_report.report_id,
+            report_type=ReportType.MONTHLY,
+            start_date=start,
+            end_date=end,
+            generated_at=datetime.now(),
+            total_accounts_created=base_report.total_accounts_created,
+            total_attempts=base_report.total_attempts,
+            overall_success_rate=base_report.overall_success_rate,
+            avg_creation_time=base_report.avg_creation_time,
+            metrics=base_report.metrics,
+            platform_stats=base_report.platform_stats,
+            error_summaries=base_report.error_summaries,
+            success_rate_timeline=base_report.success_rate_timeline,
+            creation_rate_timeline=base_report.creation_rate_timeline,
+            error_rate_timeline=base_report.error_rate_timeline,
+            insights=insights,
+            recommendations=recommendations
+        )
+    
+    def _generate_custom_report(self, 
+                              start: datetime,
+                              end: datetime,
+                              platforms: Optional[List[str]],
+                              include_charts: bool) -> Report:
+        """Generiert benutzerdefinierten Report"""
+        return self.analytics_service.generate_report(
+            ReportType.CUSTOM, start, end, platforms
+        )
+    
+    def _generate_realtime_report(self, 
+                                start: datetime,
+                                end: datetime,
+                                platforms: Optional[List[str]],
+                                include_charts: bool) -> Report:
+        """Generiert Echtzeit-Report"""
+        # Hole aktuelle Metriken
+        realtime_metrics = self.analytics_service.get_real_time_metrics()
+        
+        # Konvertiere zu Report-Format
+        metrics = [
+            Metric(
+                name="active_sessions",
+                value=realtime_metrics.get('active_sessions', 0),
+                unit="count",
+                trend=0.0
+            ),
+            Metric(
+                name="accounts_last_hour",
+                value=realtime_metrics.get('accounts_last_hour', 0),
+                unit="count",
+                trend=realtime_metrics.get('hourly_trend', 0.0)
+            ),
+            Metric(
+                name="current_success_rate",
+                value=realtime_metrics.get('success_rate_last_hour', 0.0),
+                unit="percentage",
+                trend=realtime_metrics.get('success_trend', 0.0)
+            )
+        ]
+        
+        return Report(
+            report_id=str(uuid.uuid4()),
+            report_type=ReportType.REAL_TIME,
+            start_date=start,
+            end_date=end,
+            generated_at=datetime.now(),
+            total_accounts_created=realtime_metrics.get('accounts_last_hour', 0),
+            total_attempts=realtime_metrics.get('attempts_last_hour', 0),
+            overall_success_rate=realtime_metrics.get('success_rate_last_hour', 0.0),
+            avg_creation_time=realtime_metrics.get('avg_creation_time', 0.0),
+            metrics=metrics,
+            platform_stats=[],
+            error_summaries=[],
+            insights=[
+                f"Aktuell {realtime_metrics.get('active_sessions', 0)} aktive Sessions",
+                f"Erfolgsrate letzte Stunde: {realtime_metrics.get('success_rate_last_hour', 0):.1%}"
+            ],
+            recommendations=[]
+        )
+    
+    def _generate_daily_summary(self, report: Report) -> str:
+        """Generiert tägliche Zusammenfassung"""
+        if report.overall_success_rate >= 0.9:
+            performance = "ausgezeichnet"
+        elif report.overall_success_rate >= 0.7:
+            performance = "gut"
+        elif report.overall_success_rate >= 0.5:
+            performance = "durchschnittlich"
+        else:
+            performance = "verbesserungswürdig"
+        
+        return (f"Tagesleistung war {performance} mit "
+                f"{report.total_accounts_created} erstellten Accounts "
+                f"({report.overall_success_rate:.1%} Erfolgsrate)")
+    
+    def _generate_peak_time_insight(self, report: Report) -> str:
+        """Generiert Insight über Peak-Zeiten"""
+        if report.creation_rate_timeline:
+            peak_hour = max(zip(report.creation_rate_timeline.timestamps,
+                               report.creation_rate_timeline.values),
+                           key=lambda x: x[1])
+            return f"Höchste Aktivität um {peak_hour[0].strftime('%H:%M')} Uhr"
+        return "Keine ausgeprägten Peak-Zeiten erkennbar"
+    
+    def _generate_error_trend_insight(self, report: Report) -> str:
+        """Generiert Insight über Fehler-Trends"""
+        if report.error_rate_timeline:
+            trend = report.error_rate_timeline.get_trend()
+            if trend > 10:
+                return "⚠️ Fehlerrate steigt - Intervention empfohlen"
+            elif trend < -10:
+                return "✅ Fehlerrate sinkt - positive Entwicklung"
+            else:
+                return "Fehlerrate stabil"
+        return "Keine Fehler-Trend-Daten verfügbar"
+    
+    def _generate_daily_recommendations(self, report: Report) -> List[str]:
+        """Generiert tägliche Empfehlungen"""
+        recommendations = []
+        
+        if report.overall_success_rate < 0.7:
+            recommendations.append(
+                "Erfolgsrate unter 70% - prüfen Sie Rate Limits und Proxy-Qualität"
+            )
+        
+        if report.avg_creation_time > 120:
+            recommendations.append(
+                "Durchschnittliche Erstellungszeit über 2 Minuten - "
+                "Performance-Optimierung empfohlen"
+            )
+        
+        # Platform-spezifische Empfehlungen
+        for platform_stat in report.platform_stats:
+            if platform_stat.success_rate < 0.5:
+                recommendations.append(
+                    f"{platform_stat.platform}: Niedrige Erfolgsrate - "
+                    f"spezifische Anpassungen erforderlich"
+                )
+        
+        if not recommendations:
+            recommendations.append("Keine dringenden Maßnahmen erforderlich")
+        
+        return recommendations
+    
+    def _generate_weekly_trend(self, report: Report) -> str:
+        """Generiert wöchentlichen Trend"""
+        trend_direction = "stabil"
+        if report.success_rate_timeline:
+            trend = report.success_rate_timeline.get_trend()
+            if trend > 5:
+                trend_direction = "steigend"
+            elif trend < -5:
+                trend_direction = "fallend"
+        
+        return f"Wöchentlicher Trend: {trend_direction} ({report.accounts_per_day:.1f} Accounts/Tag)"
+    
+    def _generate_platform_comparison(self, report: Report) -> str:
+        """Vergleicht Platform-Performance"""
+        if not report.platform_stats:
+            return "Keine Platform-Daten verfügbar"
+        
+        best_platform = max(report.platform_stats, key=lambda p: p.success_rate)
+        worst_platform = min(report.platform_stats, key=lambda p: p.success_rate)
+        
+        return (f"Beste Performance: {best_platform.platform} ({best_platform.success_rate:.1%}), "
+                f"Schlechteste: {worst_platform.platform} ({worst_platform.success_rate:.1%})")
+    
+    def _generate_success_pattern_insight(self, report: Report) -> str:
+        """Analysiert Erfolgsmuster"""
+        success_metric = report.get_metric(MetricType.SUCCESS_RATE)
+        if success_metric and success_metric.trend > 0:
+            return f"Erfolgsrate verbessert sich um {success_metric.trend:.1f}%"
+        return "Erfolgsrate zeigt keine klare Tendenz"
+    
+    def _generate_weekly_recommendations(self, report: Report) -> List[str]:
+        """Generiert wöchentliche Empfehlungen"""
+        recommendations = []
+        
+        # Trend-basierte Empfehlungen
+        if report.success_rate_timeline:
+            trend = report.success_rate_timeline.get_trend()
+            if trend < -10:
+                recommendations.append(
+                    "Negativer Trend erkannt - analysieren Sie Änderungen der letzten Woche"
+                )
+        
+        # Effizienz-Empfehlungen
+        if report.total_attempts > report.total_accounts_created * 2:
+            recommendations.append(
+                "Hohe Retry-Rate - verbessern Sie Fehlerbehandlung"
+            )
+        
+        return recommendations
+    
+    def _generate_monthly_summary(self, report: Report) -> str:
+        """Generiert monatliche Zusammenfassung"""
+        total_value = report.total_accounts_created
+        daily_avg = report.accounts_per_day
+        
+        return (f"Monat: {total_value} Accounts erstellt "
+                f"(Ø {daily_avg:.1f}/Tag, {report.overall_success_rate:.1%} Erfolg)")
+    
+    def _generate_growth_analysis(self, report: Report) -> str:
+        """Analysiert Wachstum"""
+        # Vereinfacht - würde historische Daten vergleichen
+        return "Wachstumsanalyse: Vergleich mit Vormonat ausstehend"
+    
+    def _generate_efficiency_insight(self, report: Report) -> str:
+        """Analysiert Effizienz"""
+        efficiency = report.total_accounts_created / report.total_attempts if report.total_attempts > 0 else 0
+        return f"Effizienz: {efficiency:.1%} der Versuche erfolgreich"
+    
+    def _generate_strategic_recommendations(self, report: Report) -> List[str]:
+        """Generiert strategische Empfehlungen"""
+        return [
+            "Monatliche Review der Error-Patterns durchführen",
+            "Proxy-Pool-Qualität evaluieren",
+            "Fingerprint-Rotation-Strategie anpassen"
+        ]
+    
+    def export_report(self, 
+                     report: Report,
+                     format: str = 'json',
+                     include_sensitive: bool = False) -> bytes:
+        """
+        Exportiert Report in verschiedenen Formaten.
+        
+        Args:
+            report: Zu exportierender Report
+            format: Export-Format ('json', 'csv', 'html')
+            include_sensitive: Ob sensitive Daten inkludiert werden sollen
+            
+        Returns:
+            Report als Bytes
+        """
+        if format == 'json':
+            return self._export_json(report, include_sensitive)
+        elif format == 'csv':
+            return self._export_csv(report)
+        elif format == 'html':
+            return self._export_html(report)
+        else:
+            raise ValueError(f"Unsupported format: {format}")
+    
+    def _export_json(self, report: Report, include_sensitive: bool) -> bytes:
+        """Exportiert als JSON"""
+        data = report.to_dict()
+        
+        # Entferne sensitive Daten wenn gewünscht
+        if not include_sensitive:
+            # Entferne Account-spezifische Daten
+            for platform_stat in data.get('platform_stats', []):
+                if 'account_details' in platform_stat:
+                    del platform_stat['account_details']
+        
+        return json.dumps(data, indent=2).encode('utf-8')
+    
+    def _export_csv(self, report: Report) -> bytes:
+        """Exportiert als CSV"""
+        output = StringIO()
+        writer = csv.writer(output)
+        
+        # Header
+        writer.writerow(['Metric', 'Value', 'Unit', 'Trend'])
+        
+        # Metrics
+        for metric in report.metrics:
+            writer.writerow([metric.name, metric.value, metric.unit, metric.trend])
+        
+        # Platform Stats
+        writer.writerow([])
+        writer.writerow(['Platform', 'Attempts', 'Success', 'Success Rate', 'Avg Duration'])
+        
+        for stat in report.platform_stats:
+            writer.writerow([
+                stat.platform,
+                stat.total_attempts,
+                stat.successful_accounts,
+                f"{stat.success_rate:.1%}",
+                f"{stat.avg_duration_seconds:.1f}s"
+            ])
+        
+        return output.getvalue().encode('utf-8')
+    
+    def _export_html(self, report: Report) -> bytes:
+        """Exportiert als HTML"""
+        html = f"""
+        <html>
+        <head>
+            <title>Report {report.report_id}</title>
+            <style>
+                body {{ font-family: Arial, sans-serif; margin: 20px; }}
+                h1 {{ color: #333; }}
+                .metric {{ margin: 10px 0; }}
+                .success {{ color: green; }}
+                .warning {{ color: orange; }}
+                .error {{ color: red; }}
+                table {{ border-collapse: collapse; width: 100%; }}
+                th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}
+                th {{ background-color: #f2f2f2; }}
+            </style>
+        </head>
+        <body>
+            <h1>{report.report_type.value.title()} Report</h1>
+            <p>Period: {report.start_date.strftime('%Y-%m-%d')} to {report.end_date.strftime('%Y-%m-%d')}</p>
+            
+            <h2>Summary</h2>
+            <div class="metric">Total Accounts: <strong>{report.total_accounts_created}</strong></div>
+            <div class="metric">Success Rate: <strong class="{'success' if report.overall_success_rate > 0.7 else 'warning'}">{report.overall_success_rate:.1%}</strong></div>
+            <div class="metric">Average Creation Time: <strong>{report.avg_creation_time:.1f}s</strong></div>
+            
+            <h2>Platform Statistics</h2>
+            <table>
+                <tr>
+                    <th>Platform</th>
+                    <th>Attempts</th>
+                    <th>Success</th>
+                    <th>Success Rate</th>
+                </tr>
+        """
+        
+        for stat in report.platform_stats:
+            html += f"""
+                <tr>
+                    <td>{stat.platform}</td>
+                    <td>{stat.total_attempts}</td>
+                    <td>{stat.successful_accounts}</td>
+                    <td class="{'success' if stat.success_rate > 0.7 else 'warning'}">{stat.success_rate:.1%}</td>
+                </tr>
+            """
+        
+        html += """
+            </table>
+            
+            <h2>Insights</h2>
+            <ul>
+        """
+        
+        for insight in report.insights:
+            html += f"<li>{insight}</li>"
+        
+        html += """
+            </ul>
+            
+            <h2>Recommendations</h2>
+            <ul>
+        """
+        
+        for rec in report.recommendations:
+            html += f"<li>{rec}</li>"
+        
+        html += """
+            </ul>
+        </body>
+        </html>
+        """
+        
+        return html.encode('utf-8')