django-cfg 1.2.15__py3-none-any.whl → 1.2.16__py3-none-any.whl

django_cfg/apps/maintenance/managers/monitoring.py

@@ -0,0 +1,301 @@
+"""
+Custom managers for monitoring models.
+
+Provides enhanced querying capabilities for MonitoringTarget model.
+"""
+
+from django.db import models
+from django.utils import timezone
+from typing import Optional, Dict, Any
+from datetime import timedelta
+
+
+class MonitoringTargetQuerySet(models.QuerySet):
+    """Custom queryset for MonitoringTarget."""
+    
+    def for_user(self, user):
+        """Filter monitoring targets for sites owned by specific user."""
+        return self.filter(site__owner=user)
+    
+    def active(self):
+        """Get active monitoring targets."""
+        return self.filter(is_active=True)
+    
+    def inactive(self):
+        """Get inactive monitoring targets."""
+        return self.filter(is_active=False)
+    
+    def by_check_type(self, check_type: str):
+        """Filter by check type."""
+        return self.filter(check_type=check_type)
+    
+    def http_checks(self):
+        """Get HTTP monitoring targets."""
+        return self.filter(check_type='http')
+    
+    def tcp_checks(self):
+        """Get TCP monitoring targets."""
+        return self.filter(check_type='tcp')
+    
+    def ping_checks(self):
+        """Get ping monitoring targets."""
+        return self.filter(check_type='ping')
+    
+    def healthy(self):
+        """Get targets with healthy status."""
+        return self.filter(last_status='healthy')
+    
+    def unhealthy(self):
+        """Get targets with unhealthy status."""
+        return self.filter(last_status='unhealthy')
+    
+    def unknown_status(self):
+        """Get targets with unknown status."""
+        return self.filter(last_status='unknown')
+    
+    def recently_checked(self, minutes: int = 30):
+        """Get targets checked recently."""
+        cutoff = timezone.now() - timedelta(minutes=minutes)
+        return self.filter(last_check__gte=cutoff)
+    
+    def overdue_check(self, multiplier: float = 2.0):
+        """Get targets that are overdue for a check."""
+        from django.db.models import F
+        from django.utils import timezone
+        
+        # Calculate overdue threshold based on check_interval
+        overdue_threshold = timezone.now() - timedelta(
+            seconds=F('check_interval') * multiplier
+        )
+        
+        return self.filter(
+            is_active=True,
+            last_check__lt=overdue_threshold
+        )
+    
+    def with_failures(self, min_failures: int = 1):
+        """Get targets with consecutive failures."""
+        return self.filter(consecutive_failures__gte=min_failures)
+    
+    def high_failure_rate(self, min_percentage: float = 10.0):
+        """Get targets with high failure rate."""
+        from django.db.models import Case, When, F
+        
+        return self.annotate(
+            failure_rate=Case(
+                When(total_checks=0, then=0),
+                default=F('total_failures') * 100.0 / F('total_checks')
+            )
+        ).filter(failure_rate__gte=min_percentage)
+    
+    def by_environment(self, environment: str):
+        """Filter by site environment."""
+        return self.filter(site__environment=environment)
+    
+    def production(self):
+        """Get monitoring targets for production sites."""
+        return self.filter(site__environment='production')
+    
+    def staging(self):
+        """Get monitoring targets for staging sites."""
+        return self.filter(site__environment='staging')
+    
+    def with_site(self):
+        """Include related site in query."""
+        return self.select_related('site')
+    
+    def with_site_owner(self):
+        """Include site and owner in query."""
+        return self.select_related('site__owner')
+
+
+class MonitoringTargetManager(models.Manager):
+    """Custom manager for MonitoringTarget."""
+    
+    def get_queryset(self):
+        return MonitoringTargetQuerySet(self.model, using=self._db)
+    
+    def for_user(self, user):
+        """Get monitoring targets for specific user."""
+        return self.get_queryset().for_user(user)
+    
+    def active(self):
+        """Get active monitoring targets."""
+        return self.get_queryset().active()
+    
+    def inactive(self):
+        """Get inactive monitoring targets."""
+        return self.get_queryset().inactive()
+    
+    def by_check_type(self, check_type: str):
+        """Get targets by check type."""
+        return self.get_queryset().by_check_type(check_type)
+    
+    def http_checks(self):
+        """Get HTTP monitoring targets."""
+        return self.get_queryset().http_checks()
+    
+    def tcp_checks(self):
+        """Get TCP monitoring targets."""
+        return self.get_queryset().tcp_checks()
+    
+    def ping_checks(self):
+        """Get ping monitoring targets."""
+        return self.get_queryset().ping_checks()
+    
+    def healthy(self):
+        """Get healthy targets."""
+        return self.get_queryset().healthy()
+    
+    def unhealthy(self):
+        """Get unhealthy targets."""
+        return self.get_queryset().unhealthy()
+    
+    def unknown_status(self):
+        """Get targets with unknown status."""
+        return self.get_queryset().unknown_status()
+    
+    def recently_checked(self, minutes: int = 30):
+        """Get recently checked targets."""
+        return self.get_queryset().recently_checked(minutes)
+    
+    def overdue_check(self, multiplier: float = 2.0):
+        """Get overdue targets."""
+        return self.get_queryset().overdue_check(multiplier)
+    
+    def with_failures(self, min_failures: int = 1):
+        """Get targets with failures."""
+        return self.get_queryset().with_failures(min_failures)
+    
+    def high_failure_rate(self, min_percentage: float = 10.0):
+        """Get targets with high failure rate."""
+        return self.get_queryset().high_failure_rate(min_percentage)
+    
+    def by_environment(self, environment: str):
+        """Get targets by environment."""
+        return self.get_queryset().by_environment(environment)
+    
+    def production(self):
+        """Get production monitoring targets."""
+        return self.get_queryset().production()
+    
+    def staging(self):
+        """Get staging monitoring targets."""
+        return self.get_queryset().staging()
+    
+    def with_site(self):
+        """Get targets with site."""
+        return self.get_queryset().with_site()
+    
+    def with_site_owner(self):
+        """Get targets with site and owner."""
+        return self.get_queryset().with_site_owner()
+    
+    def create_target(
+        self,
+        site,
+        check_type: str = 'http',
+        check_interval: int = 300,  # 5 minutes
+        timeout: int = 30,
+        retry_count: int = 3,
+        expected_status_code: Optional[int] = None,
+        expected_response_time: Optional[int] = None,
+        custom_headers: Optional[Dict] = None,
+        **kwargs
+    ):
+        """Create a new monitoring target."""
+        return self.create(
+            site=site,
+            check_type=check_type,
+            check_interval=check_interval,
+            timeout=timeout,
+            retry_count=retry_count,
+            expected_status_code=expected_status_code or (200 if check_type == 'http' else None),
+            expected_response_time=expected_response_time,
+            custom_headers=custom_headers or {},
+            **kwargs
+        )
+    
+    def get_stats_for_user(self, user) -> Dict[str, Any]:
+        """Get monitoring statistics for user."""
+        targets = self.for_user(user)
+        
+        return {
+            'total': targets.count(),
+            'active': targets.active().count(),
+            'inactive': targets.inactive().count(),
+            'healthy': targets.healthy().count(),
+            'unhealthy': targets.unhealthy().count(),
+            'unknown': targets.unknown_status().count(),
+            'http_checks': targets.http_checks().count(),
+            'tcp_checks': targets.tcp_checks().count(),
+            'ping_checks': targets.ping_checks().count(),
+            'production': targets.production().count(),
+            'staging': targets.staging().count(),
+            'recently_checked': targets.recently_checked().count(),
+            'overdue': targets.overdue_check().count(),
+            'with_failures': targets.with_failures().count(),
+            'high_failure_rate': targets.high_failure_rate().count(),
+        }
+    
+    def get_health_summary(self, user) -> Dict[str, Any]:
+        """Get health summary for user's monitoring targets."""
+        targets = self.for_user(user).active()
+        total = targets.count()
+        
+        if total == 0:
+            return {
+                'total_targets': 0,
+                'health_percentage': 0,
+                'unhealthy_count': 0,
+                'overdue_count': 0,
+                'critical_issues': [],
+            }
+        
+        healthy = targets.healthy().count()
+        unhealthy = targets.unhealthy().count()
+        overdue = targets.overdue_check().count()
+        
+        # Get critical issues
+        critical_issues = []
+        
+        # Production sites that are unhealthy
+        prod_unhealthy = targets.production().unhealthy().with_site()
+        for target in prod_unhealthy[:5]:  # Limit to 5
+            critical_issues.append({
+                'type': 'production_unhealthy',
+                'site': target.site.domain,
+                'last_check': target.last_check,
+                'consecutive_failures': target.consecutive_failures,
+            })
+        
+        # Sites with high failure rates
+        high_failure = targets.high_failure_rate(20.0).with_site()
+        for target in high_failure[:3]:  # Limit to 3
+            failure_rate = (target.total_failures / target.total_checks * 100) if target.total_checks > 0 else 0
+            critical_issues.append({
+                'type': 'high_failure_rate',
+                'site': target.site.domain,
+                'failure_rate': round(failure_rate, 1),
+                'total_failures': target.total_failures,
+                'total_checks': target.total_checks,
+            })
+        
+        return {
+            'total_targets': total,
+            'health_percentage': (healthy / total * 100) if total > 0 else 0,
+            'unhealthy_count': unhealthy,
+            'overdue_count': overdue,
+            'critical_issues': critical_issues,
+        }
+    
+    def get_targets_needing_check(self) -> 'MonitoringTargetQuerySet':
+        """Get targets that need to be checked now."""
+        now = timezone.now()
+        
+        return self.active().filter(
+            models.Q(last_check__isnull=True) |
+            models.Q(
+                last_check__lt=now - timedelta(seconds=models.F('check_interval'))
+            )
+        )

django_cfg/apps/maintenance/managers/sites.py

@@ -0,0 +1,335 @@
+"""
+Custom managers for site-related models.
+
+Provides enhanced querying capabilities for CloudflareSite and SiteGroup models.
+"""
+
+from django.db import models
+from django.utils import timezone
+from typing import Optional, Dict, Any, List
+from datetime import timedelta
+
+
+class CloudflareSiteQuerySet(models.QuerySet):
+    """Custom queryset for CloudflareSite."""
+    
+    def for_user(self, user):
+        """Filter sites for specific user."""
+        return self.filter(owner=user)
+    
+    def by_environment(self, environment: str):
+        """Filter by site environment."""
+        return self.filter(environment=environment)
+    
+    def by_status(self, status: str):
+        """Filter by site status."""
+        return self.filter(current_status=status)
+    
+    def by_project(self, project: str):
+        """Filter by project name."""
+        return self.filter(project__icontains=project)
+    
+    def by_domain(self, domain: str):
+        """Filter by domain (exact or contains)."""
+        return self.filter(domain__icontains=domain)
+    
+    def with_tags(self, tags: List[str]):
+        """Filter sites that have any of the specified tags."""
+        from django.contrib.postgres.fields import ArrayField
+        from django.db.models import Q
+        
+        query = Q()
+        for tag in tags:
+            query |= Q(tags__contains=[tag])
+        return self.filter(query)
+    
+    def production(self):
+        """Get production sites."""
+        return self.filter(environment='production')
+    
+    def staging(self):
+        """Get staging sites."""
+        return self.filter(environment='staging')
+    
+    def development(self):
+        """Get development sites."""
+        return self.filter(environment='development')
+    
+    def active(self):
+        """Get active sites."""
+        return self.filter(current_status='active')
+    
+    def in_maintenance(self):
+        """Get sites currently in maintenance."""
+        return self.filter(maintenance_active=True)
+    
+    def offline(self):
+        """Get offline sites."""
+        return self.filter(current_status='offline')
+    
+    def recent(self, days: int = 7):
+        """Get recently created sites."""
+        cutoff = timezone.now() - timedelta(days=days)
+        return self.filter(created_at__gte=cutoff)
+    
+    def recently_maintained(self, days: int = 7):
+        """Get sites that had maintenance recently."""
+        cutoff = timezone.now() - timedelta(days=days)
+        return self.filter(last_maintenance_at__gte=cutoff)
+    
+    def with_monitoring(self):
+        """Get sites that have monitoring configured."""
+        return self.filter(monitoring_target__isnull=False)
+    
+    def without_monitoring(self):
+        """Get sites without monitoring."""
+        return self.filter(monitoring_target__isnull=True)
+    
+    def with_deployments(self):
+        """Include related deployments in query."""
+        return self.prefetch_related('deployments')
+    
+    def with_maintenance_events(self):
+        """Include related maintenance events."""
+        return self.prefetch_related('maintenance_events')
+    
+    def with_full_relations(self):
+        """Include all related objects for detailed views."""
+        return self.select_related('owner').prefetch_related(
+            'deployments', 'maintenance_events', 'monitoring_target'
+        )
+
+
+class CloudflareSiteManager(models.Manager):
+    """Custom manager for CloudflareSite."""
+    
+    def get_queryset(self):
+        return CloudflareSiteQuerySet(self.model, using=self._db)
+    
+    def for_user(self, user):
+        """Get sites for specific user."""
+        return self.get_queryset().for_user(user)
+    
+    def by_environment(self, environment: str):
+        """Get sites by environment."""
+        return self.get_queryset().by_environment(environment)
+    
+    def by_status(self, status: str):
+        """Get sites by status."""
+        return self.get_queryset().by_status(status)
+    
+    def by_project(self, project: str):
+        """Get sites by project."""
+        return self.get_queryset().by_project(project)
+    
+    def by_domain(self, domain: str):
+        """Get sites by domain."""
+        return self.get_queryset().by_domain(domain)
+    
+    def with_tags(self, tags: List[str]):
+        """Get sites with specific tags."""
+        return self.get_queryset().with_tags(tags)
+    
+    def production(self):
+        """Get production sites."""
+        return self.get_queryset().production()
+    
+    def staging(self):
+        """Get staging sites."""
+        return self.get_queryset().staging()
+    
+    def development(self):
+        """Get development sites."""
+        return self.get_queryset().development()
+    
+    def active(self):
+        """Get active sites."""
+        return self.get_queryset().active()
+    
+    def in_maintenance(self):
+        """Get sites in maintenance."""
+        return self.get_queryset().in_maintenance()
+    
+    def offline(self):
+        """Get offline sites."""
+        return self.get_queryset().offline()
+    
+    def recent(self, days: int = 7):
+        """Get recent sites."""
+        return self.get_queryset().recent(days)
+    
+    def recently_maintained(self, days: int = 7):
+        """Get recently maintained sites."""
+        return self.get_queryset().recently_maintained(days)
+    
+    def with_monitoring(self):
+        """Get sites with monitoring."""
+        return self.get_queryset().with_monitoring()
+    
+    def without_monitoring(self):
+        """Get sites without monitoring."""
+        return self.get_queryset().without_monitoring()
+    
+    def with_deployments(self):
+        """Get sites with deployments."""
+        return self.get_queryset().with_deployments()
+    
+    def with_maintenance_events(self):
+        """Get sites with maintenance events."""
+        return self.get_queryset().with_maintenance_events()
+    
+    def with_full_relations(self):
+        """Get sites with all relations."""
+        return self.get_queryset().with_full_relations()
+    
+    def create_site(
+        self,
+        name: str,
+        domain: str,
+        owner,
+        environment: str = 'production',
+        project: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        **kwargs
+    ):
+        """Create a new Cloudflare site."""
+        return self.create(
+            name=name,
+            domain=domain,
+            owner=owner,
+            environment=environment,
+            project=project or '',
+            tags=tags or [],
+            **kwargs
+        )
+    
+    def get_stats_for_user(self, user) -> Dict[str, Any]:
+        """Get site statistics for user."""
+        sites = self.for_user(user)
+        
+        return {
+            'total': sites.count(),
+            'production': sites.production().count(),
+            'staging': sites.staging().count(),
+            'development': sites.development().count(),
+            'active': sites.active().count(),
+            'in_maintenance': sites.in_maintenance().count(),
+            'offline': sites.offline().count(),
+            'with_monitoring': sites.with_monitoring().count(),
+            'recent': sites.recent().count(),
+            'recently_maintained': sites.recently_maintained().count(),
+        }
+    
+    def get_maintenance_summary(self, user) -> Dict[str, Any]:
+        """Get maintenance summary for user's sites."""
+        sites = self.for_user(user)
+        in_maintenance = sites.in_maintenance()
+        
+        return {
+            'total_sites': sites.count(),
+            'in_maintenance': in_maintenance.count(),
+            'maintenance_percentage': (
+                (in_maintenance.count() / sites.count() * 100) 
+                if sites.count() > 0 else 0
+            ),
+            'production_in_maintenance': in_maintenance.production().count(),
+            'staging_in_maintenance': in_maintenance.staging().count(),
+            'recently_maintained': sites.recently_maintained().count(),
+        }
+
+
+class SiteGroupQuerySet(models.QuerySet):
+    """Custom queryset for SiteGroup."""
+    
+    def for_user(self, user):
+        """Filter groups for specific user."""
+        return self.filter(owner=user)
+    
+    def by_environment(self, environment: str):
+        """Filter groups by primary environment of their sites."""
+        return self.filter(sites__environment=environment).distinct()
+    
+    def with_sites(self):
+        """Include related sites in query."""
+        return self.prefetch_related('sites')
+    
+    def with_active_sites(self):
+        """Include only active sites."""
+        return self.prefetch_related(
+            models.Prefetch(
+                'sites',
+                queryset=CloudflareSiteQuerySet(self.model._meta.get_field('sites').related_model).active()
+            )
+        )
+    
+    def recent(self, days: int = 7):
+        """Get recently created groups."""
+        cutoff = timezone.now() - timedelta(days=days)
+        return self.filter(created_at__gte=cutoff)
+
+
+class SiteGroupManager(models.Manager):
+    """Custom manager for SiteGroup."""
+    
+    def get_queryset(self):
+        return SiteGroupQuerySet(self.model, using=self._db)
+    
+    def for_user(self, user):
+        """Get groups for specific user."""
+        return self.get_queryset().for_user(user)
+    
+    def by_environment(self, environment: str):
+        """Get groups by environment."""
+        return self.get_queryset().by_environment(environment)
+    
+    def with_sites(self):
+        """Get groups with sites."""
+        return self.get_queryset().with_sites()
+    
+    def with_active_sites(self):
+        """Get groups with active sites."""
+        return self.get_queryset().with_active_sites()
+    
+    def recent(self, days: int = 7):
+        """Get recent groups."""
+        return self.get_queryset().recent(days)
+    
+    def create_group(
+        self,
+        name: str,
+        owner,
+        description: Optional[str] = None,
+        site_ids: Optional[List[int]] = None,
+        **kwargs
+    ):
+        """Create a new site group."""
+        group = self.create(
+            name=name,
+            owner=owner,
+            description=description or '',
+            **kwargs
+        )
+        
+        if site_ids:
+            # Add sites to the group
+            from ..models import CloudflareSite
+            sites = CloudflareSite.objects.filter(id__in=site_ids, owner=owner)
+            group.sites.add(*sites)
+        
+        return group
+    
+    def get_stats_for_user(self, user) -> Dict[str, Any]:
+        """Get group statistics for user."""
+        groups = self.for_user(user)
+        
+        return {
+            'total': groups.count(),
+            'recent': groups.recent().count(),
+            'total_sites_in_groups': sum(
+                group.sites.count() for group in groups.with_sites()
+            ),
+            'avg_sites_per_group': (
+                sum(group.sites.count() for group in groups.with_sites()) / groups.count()
+                if groups.count() > 0 else 0
+            ),
+        }