geek-cafe-saas-sdk 0.6.0__py3-none-any.whl

geek_cafe_saas_sdk/domains/analytics/models/website_analytics_summary.py

@@ -0,0 +1,220 @@
+from boto3_assist.dynamodb.dynamodb_index import DynamoDBIndex, DynamoDBKey
+from boto3_assist.utilities.string_utility import StringUtility
+import datetime as dt
+from typing import Dict, Any
+from geek_cafe_saas_sdk.models.base_model import BaseModel
+
+
+class WebsiteAnalyticsSummary(BaseModel):
+    """
+    Model for storing aggregated website analytics data.
+    
+    This model stores hourly/daily summaries of analytics data for efficient querying.
+    Aggregated by an EventBridge scheduled job via the tally service.
+    """
+    
+    def __init__(self):
+        super().__init__()
+        self._route: str | None = None  # URL route this summary is for
+        self._slug: str | None = None  # Slug for the page
+        self._analytics_type: str = "general"  # Type of analytics summarized
+        self._period_start_ts: float | None = None  # Start of aggregation period
+        self._period_end_ts: float | None = None  # End of aggregation period
+        self._period_type: str = "hourly"  # hourly, daily, weekly, monthly
+        
+        # Aggregated metrics
+        self._total_events: int = 0  # Total number of events in period
+        self._unique_sessions: int = 0  # Number of unique sessions
+        self._unique_users: int = 0  # Number of unique users
+        
+        # Aggregated data - flexible storage for computed metrics
+        self._metrics: Dict[str, Any] = {}
+        
+        # Additional metadata
+        self._content: Dict[str, Any] = {}
+        
+        self._setup_indexes()
+
+    def _setup_indexes(self):
+        # Primary index: summary by ID
+        primary: DynamoDBIndex = DynamoDBIndex()
+        primary.name = "primary"
+        primary.partition_key.attribute_name = "pk"
+        primary.partition_key.value = lambda: DynamoDBKey.build_key(
+            ("analytics-summary", self.id)
+        )
+        primary.sort_key.attribute_name = "sk"
+        primary.sort_key.value = lambda: DynamoDBKey.build_key(("analytics-summary", self.id))
+        self.indexes.add_primary(primary)
+        
+        ## GSI: 1
+        # GSI: all analytics summaries sorted by period start
+        gsi: DynamoDBIndex = DynamoDBIndex()
+        gsi.name = "gsi1"
+        gsi.partition_key.attribute_name = f"{gsi.name}_pk"
+        gsi.partition_key.value = lambda: DynamoDBKey.build_key(("analytics-summary", "all"))
+        gsi.sort_key.attribute_name = f"{gsi.name}_sk"
+        gsi.sort_key.value = lambda: DynamoDBKey.build_key(
+            ("period", self.period_start_ts)
+        )
+        self.indexes.add_secondary(gsi)
+
+        ## GSI: 2
+        # GSI: summaries by route/slug for page-specific queries
+        gsi: DynamoDBIndex = DynamoDBIndex()
+        gsi.name = "gsi2"
+        gsi.partition_key.attribute_name = f"{gsi.name}_pk"
+        gsi.partition_key.value = lambda: DynamoDBKey.build_key(
+            ("route", self.route or self.slug)
+        )
+        gsi.sort_key.attribute_name = f"{gsi.name}_sk"
+        gsi.sort_key.value = lambda: DynamoDBKey.build_key(
+            ("period", self.period_start_ts)
+        )
+        self.indexes.add_secondary(gsi)
+
+        ## GSI: 3
+        # GSI: summaries by tenant sorted by period
+        gsi: DynamoDBIndex = DynamoDBIndex()
+        gsi.name = "gsi3"
+        gsi.partition_key.attribute_name = f"{gsi.name}_pk"
+        gsi.partition_key.value = lambda: DynamoDBKey.build_key(("tenant", self.tenant_id))
+        gsi.sort_key.attribute_name = f"{gsi.name}_sk"
+        gsi.sort_key.value = lambda: DynamoDBKey.build_key(
+            ("model", "analytics-summary"), ("period", self.period_start_ts)
+        )
+        self.indexes.add_secondary(gsi)
+
+        ## GSI: 4
+        # GSI: summaries by type and period
+        gsi: DynamoDBIndex = DynamoDBIndex()
+        gsi.name = "gsi4"
+        gsi.partition_key.attribute_name = f"{gsi.name}_pk"
+        gsi.partition_key.value = lambda: DynamoDBKey.build_key(
+            ("analytics-type", self.analytics_type)
+        )
+        gsi.sort_key.attribute_name = f"{gsi.name}_sk"
+        gsi.sort_key.value = lambda: DynamoDBKey.build_key(
+            ("period", self.period_start_ts)
+        )
+        self.indexes.add_secondary(gsi)
+
+        ## GSI: 5
+        # GSI: summaries by tenant, type, and period for filtered queries
+        gsi: DynamoDBIndex = DynamoDBIndex()
+        gsi.name = "gsi5"
+        gsi.partition_key.attribute_name = f"{gsi.name}_pk"
+        gsi.partition_key.value = lambda: DynamoDBKey.build_key(
+            ("tenant", self.tenant_id), ("type", self.analytics_type)
+        )
+        gsi.sort_key.attribute_name = f"{gsi.name}_sk"
+        gsi.sort_key.value = lambda: DynamoDBKey.build_key(
+            ("period", self.period_start_ts)
+        )
+        self.indexes.add_secondary(gsi)
+
+    @property
+    def route(self) -> str | None:
+        return self._route
+
+    @route.setter
+    def route(self, value: str | None):
+        self._route = value
+    
+    @property
+    def slug(self) -> str | None:
+        return self._slug
+
+    @slug.setter
+    def slug(self, value: str | None):
+        self._slug = value
+    
+    @property
+    def analytics_type(self) -> str:
+        return self._analytics_type
+
+    @analytics_type.setter
+    def analytics_type(self, value: str):
+        self._analytics_type = value
+    
+    @property
+    def period_start_ts(self) -> float | None:
+        return self._period_start_ts
+
+    @period_start_ts.setter
+    def period_start_ts(self, value: float | None):
+        self._period_start_ts = value
+    
+    @property
+    def period_end_ts(self) -> float | None:
+        return self._period_end_ts
+
+    @period_end_ts.setter
+    def period_end_ts(self, value: float | None):
+        self._period_end_ts = value
+    
+    @property
+    def period_type(self) -> str:
+        return self._period_type
+
+    @period_type.setter
+    def period_type(self, value: str):
+        self._period_type = value
+    
+    @property
+    def total_events(self) -> int:
+        return self._total_events
+
+    @total_events.setter
+    def total_events(self, value: int):
+        self._total_events = value
+    
+    @property
+    def unique_sessions(self) -> int:
+        return self._unique_sessions
+
+    @unique_sessions.setter
+    def unique_sessions(self, value: int):
+        self._unique_sessions = value
+    
+    @property
+    def unique_users(self) -> int:
+        return self._unique_users
+
+    @unique_users.setter
+    def unique_users(self, value: int):
+        self._unique_users = value
+    
+    @property
+    def metrics(self) -> Dict[str, Any]:
+        """Get metrics (boto3-assist v0.30.0+ auto-converts Decimals to float)."""
+        return self._metrics
+
+    @metrics.setter
+    def metrics(self, value: Dict[str, Any]):
+        """Set metrics."""
+        self._metrics = value if value is not None else {}
+    
+    @property
+    def content(self) -> Dict[str, Any]:
+        return self._content
+
+    @content.setter
+    def content(self, value: Dict[str, Any]):
+        self._content = value
+    
+    # Helper methods
+    def get_metric(self, key: str, default: Any = None) -> Any:
+        """Get a specific metric value."""
+        return self.metrics.get(key, default)
+    
+    def set_metric(self, key: str, value: Any):
+        """Set a specific metric value."""
+        self.metrics[key] = value
+    
+    def calculate_average(self, metric_key: str) -> float:
+        """Calculate average for a metric stored as a list."""
+        values = self.metrics.get(metric_key, [])
+        if not values or not isinstance(values, list):
+            return 0.0
+        return sum(values) / len(values)

geek_cafe_saas_sdk/domains/analytics/services/__init__.py

@@ -0,0 +1,11 @@
+# Analytics Domain Services
+
+from .website_analytics_service import WebsiteAnalyticsService
+from .website_analytics_summary_service import WebsiteAnalyticsSummaryService
+from .website_analytics_tally_service import WebsiteAnalyticsTallyService
+
+__all__ = [
+    "WebsiteAnalyticsService",
+    "WebsiteAnalyticsSummaryService",
+    "WebsiteAnalyticsTallyService",
+]

geek_cafe_saas_sdk/domains/analytics/services/website_analytics_service.py

@@ -0,0 +1,232 @@
+# Website Analytics Service
+
+from typing import Dict, Any, List, Optional
+from boto3_assist.dynamodb.dynamodb import DynamoDB
+from geek_cafe_saas_sdk.services.database_service import DatabaseService
+from geek_cafe_saas_sdk.core.service_result import ServiceResult
+from geek_cafe_saas_sdk.core.service_errors import ValidationError, NotFoundError
+from geek_cafe_saas_sdk.domains.analytics.models import WebsiteAnalytics
+
+
+class WebsiteAnalyticsService(DatabaseService[WebsiteAnalytics]):
+    """Service for WebsiteAnalytics database operations."""
+    
+    def __init__(self, *, dynamodb: DynamoDB = None, table_name: str = None):
+        super().__init__(dynamodb=dynamodb, table_name=table_name)
+    
+    def create(self, tenant_id: str, user_id: str, **kwargs) -> ServiceResult[WebsiteAnalytics]:
+        """Create a new analytics record."""
+        try:
+            # Validate required fields
+            required_fields = ['analytics_type']
+            self._validate_required_fields(kwargs, required_fields)
+            
+            # At least one of route or slug should be provided
+            if not kwargs.get('route') and not kwargs.get('slug'):
+                raise ValidationError("Either 'route' or 'slug' must be provided", "route")
+
+            # Create new analytics instance
+            analytics = WebsiteAnalytics()
+            analytics.tenant_id = tenant_id
+            analytics.user_id = user_id
+            analytics.created_by_id = user_id
+            
+            # Set analytics fields
+            analytics.route = kwargs.get('route')
+            analytics.slug = kwargs.get('slug')
+            analytics.analytics_type = kwargs.get('analytics_type', 'general')
+            analytics.data = kwargs.get('data', {})
+            analytics.session_id = kwargs.get('session_id')
+            analytics.user_agent = kwargs.get('user_agent')
+            analytics.ip_address = kwargs.get('ip_address')
+            analytics.referrer = kwargs.get('referrer')
+            
+            # Prepare for save (sets ID and timestamps)
+            analytics.prep_for_save()
+            
+            # Save to database
+            return self._save_model(analytics)
+            
+        except Exception as e:
+            return self._handle_service_exception(e, 'create_analytics', tenant_id=tenant_id, user_id=user_id)
+    
+    # Convenience methods for different analytics types
+    def create_page_view(self, tenant_id: str, user_id: str, route: str, **kwargs) -> ServiceResult[WebsiteAnalytics]:
+        """Create a page view analytics record."""
+        analytics = WebsiteAnalytics()
+        analytics.tenant_id = tenant_id
+        analytics.user_id = user_id
+        analytics.created_by_id = user_id
+        analytics.set_page_view(route, **kwargs)
+        
+        # Set optional fields
+        analytics.session_id = kwargs.get('session_id')
+        analytics.user_agent = kwargs.get('user_agent')
+        analytics.ip_address = kwargs.get('ip_address')
+        analytics.referrer = kwargs.get('referrer')
+        
+        analytics.prep_for_save()
+        return self._save_model(analytics)
+    
+    def create_error_log(self, tenant_id: str, user_id: str, route: str, 
+                        error_message: str, **kwargs) -> ServiceResult[WebsiteAnalytics]:
+        """Create an error analytics record."""
+        analytics = WebsiteAnalytics()
+        analytics.tenant_id = tenant_id
+        analytics.user_id = user_id
+        analytics.created_by_id = user_id
+        analytics.set_error(route, error_message, **kwargs)
+        
+        # Set optional fields
+        analytics.session_id = kwargs.get('session_id')
+        analytics.user_agent = kwargs.get('user_agent')
+        analytics.ip_address = kwargs.get('ip_address')
+        analytics.referrer = kwargs.get('referrer')
+        
+        analytics.prep_for_save()
+        return self._save_model(analytics)
+    
+    def create_performance_log(self, tenant_id: str, user_id: str, route: str, 
+                              **kwargs) -> ServiceResult[WebsiteAnalytics]:
+        """Create a performance analytics record."""
+        analytics = WebsiteAnalytics()
+        analytics.tenant_id = tenant_id
+        analytics.user_id = user_id
+        analytics.created_by_id = user_id
+        analytics.set_performance(route, **kwargs)
+        
+        # Set optional fields
+        analytics.session_id = kwargs.get('session_id')
+        analytics.user_agent = kwargs.get('user_agent')
+        analytics.ip_address = kwargs.get('ip_address')
+        analytics.referrer = kwargs.get('referrer')
+        
+        analytics.prep_for_save()
+        return self._save_model(analytics)
+    
+    def create_custom_event(self, tenant_id: str, user_id: str, route: str,
+                           event_name: str, **kwargs) -> ServiceResult[WebsiteAnalytics]:
+        """Create a custom event analytics record."""
+        analytics = WebsiteAnalytics()
+        analytics.tenant_id = tenant_id
+        analytics.user_id = user_id
+        analytics.created_by_id = user_id
+        analytics.set_custom_event(route, event_name, **kwargs)
+        
+        # Set optional fields
+        analytics.session_id = kwargs.get('session_id')
+        analytics.user_agent = kwargs.get('user_agent')
+        analytics.ip_address = kwargs.get('ip_address')
+        analytics.referrer = kwargs.get('referrer')
+        
+        analytics.prep_for_save()
+        return self._save_model(analytics)
+    
+    def get_by_id(self, resource_id: str, tenant_id: str, user_id: str) -> ServiceResult[WebsiteAnalytics]:
+        """Get analytics record by ID with access control."""
+        try:
+            analytics = self._get_model_by_id(resource_id, WebsiteAnalytics)
+            
+            if not analytics:
+                raise NotFoundError(f"WebsiteAnalytics with ID {resource_id} not found")
+            
+            # Validate tenant access
+            if hasattr(analytics, 'tenant_id'):
+                self._validate_tenant_access(analytics.tenant_id, tenant_id)
+            
+            return ServiceResult.success_result(analytics)
+            
+        except Exception as e:
+            return self._handle_service_exception(e, 'get_analytics', resource_id=resource_id, tenant_id=tenant_id)
+    
+    def update(self, resource_id: str, tenant_id: str, user_id: str, 
+               updates: Dict[str, Any]) -> ServiceResult[WebsiteAnalytics]:
+        """Update analytics record with access control."""
+        try:
+            # Get existing analytics
+            analytics = self._get_model_by_id(resource_id, WebsiteAnalytics)
+            
+            if not analytics:
+                raise NotFoundError(f"WebsiteAnalytics with ID {resource_id} not found")
+            
+            # Validate tenant access
+            if hasattr(analytics, 'tenant_id'):
+                self._validate_tenant_access(analytics.tenant_id, tenant_id)
+            
+            # Apply updates
+            for field, value in updates.items():
+                if hasattr(analytics, field) and field not in ['id', 'created_utc_ts', 'tenant_id']:
+                    setattr(analytics, field, value)
+            
+            # Update metadata
+            analytics.updated_by_id = user_id
+            analytics.prep_for_save()  # Updates timestamp
+            
+            # Save updated analytics
+            return self._save_model(analytics)
+            
+        except Exception as e:
+            return self._handle_service_exception(e, 'update_analytics', resource_id=resource_id, tenant_id=tenant_id)
+    
+    def delete(self, resource_id: str, tenant_id: str, user_id: str) -> ServiceResult[bool]:
+        """Delete analytics record with access control."""
+        try:
+            analytics = self._get_model_by_id(resource_id, WebsiteAnalytics)
+            
+            if not analytics:
+                raise NotFoundError(f"WebsiteAnalytics with ID {resource_id} not found")
+            
+            if hasattr(analytics, 'tenant_id'):
+                self._validate_tenant_access(analytics.tenant_id, tenant_id)
+            
+            return self._delete_model(analytics)
+            
+        except Exception as e:
+            return self._handle_service_exception(e, 'delete_analytics', resource_id=resource_id, tenant_id=tenant_id)
+    
+    def list_by_route(self, route: str, start_key: dict = None, limit: int = None) -> ServiceResult[List[WebsiteAnalytics]]:
+        """List analytics records by route/slug."""
+        try:
+            model = WebsiteAnalytics()
+            model.route = route
+            return self._query_by_index(model, "gsi2", start_key=start_key, limit=limit)
+        except Exception as e:
+            return self._handle_service_exception(e, 'list_analytics_by_route', route=route)
+    
+    def list_by_tenant(self, tenant_id: str, start_key: dict = None, limit: int = None) -> ServiceResult[List[WebsiteAnalytics]]:
+        """List analytics records by tenant."""
+        try:
+            model = WebsiteAnalytics()
+            model.tenant_id = tenant_id
+            return self._query_by_index(model, "gsi3", start_key=start_key, limit=limit)
+        except Exception as e:
+            return self._handle_service_exception(e, 'list_analytics_by_tenant', tenant_id=tenant_id)
+    
+    def list_by_type(self, analytics_type: str, start_key: dict = None, limit: int = None) -> ServiceResult[List[WebsiteAnalytics]]:
+        """List analytics records by type (general, error, performance, custom)."""
+        try:
+            model = WebsiteAnalytics()
+            model.analytics_type = analytics_type
+            return self._query_by_index(model, "gsi4", start_key=start_key, limit=limit)
+        except Exception as e:
+            return self._handle_service_exception(e, 'list_analytics_by_type', analytics_type=analytics_type)
+    
+    def list_by_tenant_and_type(self, tenant_id: str, analytics_type: str, 
+                                start_key: dict = None, limit: int = None) -> ServiceResult[List[WebsiteAnalytics]]:
+        """List analytics records by tenant and type."""
+        try:
+            model = WebsiteAnalytics()
+            model.tenant_id = tenant_id
+            model.analytics_type = analytics_type
+            return self._query_by_index(model, "gsi5", start_key=start_key, limit=limit)
+        except Exception as e:
+            return self._handle_service_exception(e, 'list_analytics_by_tenant_and_type', 
+                                                 tenant_id=tenant_id, analytics_type=analytics_type)
+    
+    def list_all(self, start_key: dict = None, limit: int = None) -> ServiceResult[List[WebsiteAnalytics]]:
+        """List all analytics records."""
+        try:
+            model = WebsiteAnalytics()
+            return self._query_by_index(model, "gsi1", start_key=start_key, limit=limit)
+        except Exception as e:
+            return self._handle_service_exception(e, 'list_all_analytics')

geek_cafe_saas_sdk/domains/analytics/services/website_analytics_summary_service.py

@@ -0,0 +1,212 @@
+# Website Analytics Summary Service
+
+from typing import Dict, Any, List, Optional
+from boto3_assist.dynamodb.dynamodb import DynamoDB
+from geek_cafe_saas_sdk.services.database_service import DatabaseService
+from geek_cafe_saas_sdk.core.service_result import ServiceResult
+from geek_cafe_saas_sdk.core.service_errors import ValidationError, NotFoundError
+from geek_cafe_saas_sdk.domains.analytics.models import WebsiteAnalyticsSummary
+
+
+class WebsiteAnalyticsSummaryService(DatabaseService[WebsiteAnalyticsSummary]):
+    """Service for WebsiteAnalyticsSummary database operations."""
+    
+    def __init__(self, *, dynamodb: DynamoDB = None, table_name: str = None):
+        super().__init__(dynamodb=dynamodb, table_name=table_name)
+    
+    def create(self, tenant_id: str, user_id: str, **kwargs) -> ServiceResult[WebsiteAnalyticsSummary]:
+        """Create or update (upsert) an analytics summary."""
+        try:
+            # Validate required fields
+            required_fields = ['analytics_type', 'period_start_ts', 'period_end_ts']
+            self._validate_required_fields(kwargs, required_fields)
+            
+            # At least one of route or slug should be provided
+            if not kwargs.get('route') and not kwargs.get('slug'):
+                raise ValidationError("Either 'route' or 'slug' must be provided", "route")
+
+            # Check if a summary already exists for this route/period
+            existing = self._get_by_route_and_period(
+                kwargs.get('route') or kwargs.get('slug'),
+                kwargs.get('period_start_ts'),
+                kwargs.get('analytics_type')
+            )
+            
+            if existing:
+                # Update the existing summary
+                return self._update_existing_summary(existing, tenant_id, user_id, **kwargs)
+            
+            # Create new summary instance
+            summary = WebsiteAnalyticsSummary()
+            summary.tenant_id = tenant_id
+            summary.user_id = user_id
+            summary.created_by_id = user_id
+            
+            # Set summary fields
+            summary.route = kwargs.get('route')
+            summary.slug = kwargs.get('slug')
+            summary.analytics_type = kwargs.get('analytics_type', 'general')
+            summary.period_start_ts = float(kwargs.get('period_start_ts'))
+            summary.period_end_ts = float(kwargs.get('period_end_ts'))
+            summary.period_type = kwargs.get('period_type', 'hourly')
+            
+            # Set aggregated metrics
+            summary.total_events = int(kwargs.get('total_events', 0) or 0)
+            summary.unique_sessions = int(kwargs.get('unique_sessions', 0) or 0)
+            summary.unique_users = int(kwargs.get('unique_users', 0) or 0)
+            summary.metrics = kwargs.get('metrics', {})
+            summary.content = kwargs.get('content', {})
+            
+            # Prepare for save (sets ID and timestamps)
+            summary.prep_for_save()
+            
+            # Save to database
+            return self._save_model(summary)
+            
+        except Exception as e:
+            return self._handle_service_exception(e, 'create_analytics_summary', tenant_id=tenant_id, user_id=user_id)
+    
+    def _update_existing_summary(self, existing_summary: WebsiteAnalyticsSummary, 
+                                 tenant_id: str, user_id: str, **kwargs) -> ServiceResult[WebsiteAnalyticsSummary]:
+        """Update an existing summary with new data."""
+        # Update fields
+        existing_summary.period_end_ts = float(kwargs.get('period_end_ts', existing_summary.period_end_ts))
+        existing_summary.period_type = kwargs.get('period_type', existing_summary.period_type)
+        
+        # Update aggregated metrics
+        existing_summary.total_events = int(kwargs.get('total_events', existing_summary.total_events) or 0)
+        existing_summary.unique_sessions = int(kwargs.get('unique_sessions', existing_summary.unique_sessions) or 0)
+        existing_summary.unique_users = int(kwargs.get('unique_users', existing_summary.unique_users) or 0)
+        existing_summary.metrics = kwargs.get('metrics', existing_summary.metrics or {})
+        existing_summary.content = kwargs.get('content', existing_summary.content or {})
+        
+        # Update metadata
+        existing_summary.updated_by_id = user_id
+        existing_summary.prep_for_save()  # Updates timestamp
+        
+        # Save updated summary
+        return self._save_model(existing_summary)
+    
+    def _get_by_route_and_period(self, route: str, period_start_ts: float, 
+                                 analytics_type: str) -> WebsiteAnalyticsSummary | None:
+        """Helper: get a summary by route and period via GSI2."""
+        model = WebsiteAnalyticsSummary()
+        model.route = route
+        result = self._query_by_index(model, "gsi2")
+        
+        if result.success and result.data:
+            # Filter by period_start_ts and analytics_type
+            for summary in result.data:
+                if (summary.period_start_ts == period_start_ts and 
+                    summary.analytics_type == analytics_type):
+                    return summary
+        return None
+    
+    def get_by_id(self, resource_id: str, tenant_id: str, user_id: str) -> ServiceResult[WebsiteAnalyticsSummary]:
+        """Get analytics summary by ID with access control."""
+        try:
+            summary = self._get_model_by_id(resource_id, WebsiteAnalyticsSummary)
+            
+            if not summary:
+                raise NotFoundError(f"WebsiteAnalyticsSummary with ID {resource_id} not found")
+            
+            # Validate tenant access
+            if hasattr(summary, 'tenant_id'):
+                self._validate_tenant_access(summary.tenant_id, tenant_id)
+            
+            return ServiceResult.success_result(summary)
+            
+        except Exception as e:
+            return self._handle_service_exception(e, 'get_analytics_summary', resource_id=resource_id, tenant_id=tenant_id)
+    
+    def update(self, resource_id: str, tenant_id: str, user_id: str, 
+               updates: Dict[str, Any]) -> ServiceResult[WebsiteAnalyticsSummary]:
+        """Update analytics summary with access control."""
+        try:
+            # Get existing summary
+            summary = self._get_model_by_id(resource_id, WebsiteAnalyticsSummary)
+            
+            if not summary:
+                raise NotFoundError(f"WebsiteAnalyticsSummary with ID {resource_id} not found")
+            
+            # Validate tenant access
+            if hasattr(summary, 'tenant_id'):
+                self._validate_tenant_access(summary.tenant_id, tenant_id)
+            
+            # Apply updates
+            for field, value in updates.items():
+                if hasattr(summary, field) and field not in ['id', 'created_utc_ts', 'tenant_id']:
+                    setattr(summary, field, value)
+            
+            # Update metadata
+            summary.updated_by_id = user_id
+            summary.prep_for_save()  # Updates timestamp
+            
+            # Save updated summary
+            return self._save_model(summary)
+            
+        except Exception as e:
+            return self._handle_service_exception(e, 'update_analytics_summary', resource_id=resource_id, tenant_id=tenant_id)
+    
+    def delete(self, resource_id: str, tenant_id: str, user_id: str) -> ServiceResult[bool]:
+        """Delete analytics summary with access control."""
+        try:
+            summary = self._get_model_by_id(resource_id, WebsiteAnalyticsSummary)
+            
+            if not summary:
+                raise NotFoundError(f"WebsiteAnalyticsSummary with ID {resource_id} not found")
+            
+            if hasattr(summary, 'tenant_id'):
+                self._validate_tenant_access(summary.tenant_id, tenant_id)
+            
+            return self._delete_model(summary)
+            
+        except Exception as e:
+            return self._handle_service_exception(e, 'delete_analytics_summary', resource_id=resource_id, tenant_id=tenant_id)
+    
+    def list_by_route(self, route: str, start_key: dict = None, limit: int = None) -> ServiceResult[List[WebsiteAnalyticsSummary]]:
+        """List analytics summaries by route/slug."""
+        try:
+            model = WebsiteAnalyticsSummary()
+            model.route = route
+            return self._query_by_index(model, "gsi2", start_key=start_key, limit=limit)
+        except Exception as e:
+            return self._handle_service_exception(e, 'list_summaries_by_route', route=route)
+    
+    def list_by_tenant(self, tenant_id: str, start_key: dict = None, limit: int = None) -> ServiceResult[List[WebsiteAnalyticsSummary]]:
+        """List analytics summaries by tenant."""
+        try:
+            model = WebsiteAnalyticsSummary()
+            model.tenant_id = tenant_id
+            return self._query_by_index(model, "gsi3", start_key=start_key, limit=limit)
+        except Exception as e:
+            return self._handle_service_exception(e, 'list_summaries_by_tenant', tenant_id=tenant_id)
+    
+    def list_by_type(self, analytics_type: str, start_key: dict = None, limit: int = None) -> ServiceResult[List[WebsiteAnalyticsSummary]]:
+        """List analytics summaries by type."""
+        try:
+            model = WebsiteAnalyticsSummary()
+            model.analytics_type = analytics_type
+            return self._query_by_index(model, "gsi4", start_key=start_key, limit=limit)
+        except Exception as e:
+            return self._handle_service_exception(e, 'list_summaries_by_type', analytics_type=analytics_type)
+    
+    def list_by_tenant_and_type(self, tenant_id: str, analytics_type: str,
+                                start_key: dict = None, limit: int = None) -> ServiceResult[List[WebsiteAnalyticsSummary]]:
+        """List analytics summaries by tenant and type."""
+        try:
+            model = WebsiteAnalyticsSummary()
+            model.tenant_id = tenant_id
+            model.analytics_type = analytics_type
+            return self._query_by_index(model, "gsi5", start_key=start_key, limit=limit)
+        except Exception as e:
+            return self._handle_service_exception(e, 'list_summaries_by_tenant_and_type',
+                                                 tenant_id=tenant_id, analytics_type=analytics_type)
+    
+    def list_all(self, start_key: dict = None, limit: int = None) -> ServiceResult[List[WebsiteAnalyticsSummary]]:
+        """List all analytics summaries."""
+        try:
+            model = WebsiteAnalyticsSummary()
+            return self._query_by_index(model, "gsi1", start_key=start_key, limit=limit)
+        except Exception as e:
+            return self._handle_service_exception(e, 'list_all_summaries')