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

geek_cafe_saas_sdk/domains/voting/models/vote_summary.py

@@ -0,0 +1,193 @@
+
+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 VoteSummary(BaseModel):
+    def __init__(self):
+        super().__init__()
+        self._content: Dict[str, Any] = {}
+        self._target_id: str | None = None
+        
+        # Enhanced summary fields
+        self._vote_type: str = "single_choice"  # Type of voting used
+        self._choice_breakdown: Dict[str, int] = {}  # {"A": 150, "B": 100, "C": 50}
+        self._choice_percentages: Dict[str, float] = {}  # {"A": 50.0, "B": 33.3, "C": 16.7}
+        self._choice_averages: Dict[str, float] = {}  # For rating votes: {"A": 4.5, "B": 3.2}
+        self._total_participants: int = 0  # Number of people who voted
+        self._total_selections: int = 0  # For multi-select: total selections made
+        
+        # Legacy fields (for backward compatibility)
+        self._total_up_votes: int = 0
+        self._total_down_votes: int = 0
+        self._total_votes: int = 0
+
+        self._setup_indexes()
+
+    def _setup_indexes(self):
+        primary: DynamoDBIndex = DynamoDBIndex()
+        primary.name = "primary"
+        primary.partition_key.attribute_name = "pk"
+        primary.partition_key.value = lambda: DynamoDBKey.build_key(
+            ("vote-summary", self.id)
+        )
+
+        primary.sort_key.attribute_name = "sk"
+        primary.sort_key.value = lambda: DynamoDBKey.build_key(("vote-summary", self.id))
+        self.indexes.add_primary(primary)
+        
+        ## GSI: 1
+        # GSI: all vote summaries
+        gsi: DynamoDBIndex = DynamoDBIndex()
+        
+        gsi.name = "gsi1"
+        gsi.partition_key.attribute_name = f"{gsi.name}_pk"
+        gsi.partition_key.value = lambda: DynamoDBKey.build_key(("vote-summary", "all"))
+        gsi.sort_key.attribute_name = f"{gsi.name}_sk"
+        gsi.sort_key.value = lambda: DynamoDBKey.build_key(
+           ("ts", self.created_utc_ts)
+        )
+        self.indexes.add_secondary(gsi)
+
+        ## GSI: 2
+        # GSI: vote summary by target_id (for quick lookup by target)
+        gsi: DynamoDBIndex = DynamoDBIndex()
+        
+        gsi.name = "gsi2"
+        gsi.partition_key.attribute_name = f"{gsi.name}_pk"
+        gsi.partition_key.value = lambda: DynamoDBKey.build_key(("target", self.target_id))
+        gsi.sort_key.attribute_name = f"{gsi.name}_sk"
+        gsi.sort_key.value = lambda: DynamoDBKey.build_key(
+           ("model", "vote-summary")
+        )
+        self.indexes.add_secondary(gsi)
+
+        ## GSI: 3
+        # GSI: vote summaries by tenant
+        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", "vote-summary"),("ts", self.created_utc_ts)
+        )
+        self.indexes.add_secondary(gsi)
+
+        
+
+    @property
+    def content(self) -> Dict[str, Any]:
+        """Get content (boto3-assist v0.30.0+ auto-converts Decimals to float)."""
+        return self._content
+
+    @content.setter
+    def content(self, value: Dict[str, Any]):
+        """Set content (store as-is for boto3-assist compatibility)."""
+        self._content = value if value is not None else {}
+    
+    
+    @property
+    def total_up_votes(self) -> int:
+        return self._total_up_votes
+    
+    @total_up_votes.setter
+    def total_up_votes(self, value: int):
+        self._total_up_votes = value
+
+    @property
+    def total_down_votes(self) -> int:
+        return self._total_down_votes
+    
+    @total_down_votes.setter
+    def total_down_votes(self, value: int):
+        self._total_down_votes = value
+    
+    @property
+    def total_votes(self) -> int:
+        return self._total_votes
+    
+    @total_votes.setter
+    def total_votes(self, value: int):
+        self._total_votes = value
+    
+    @property
+    def target_id(self) -> str | None:
+        return self._target_id
+
+    @target_id.setter
+    def target_id(self, value: str | None):
+        self._target_id = value
+    
+    @property
+    def vote_type(self) -> str:
+        return self._vote_type
+
+    @vote_type.setter
+    def vote_type(self, value: str):
+        self._vote_type = value
+    
+    @property
+    def choice_breakdown(self) -> Dict[str, int]:
+        return self._choice_breakdown
+
+    @choice_breakdown.setter
+    def choice_breakdown(self, value: Dict[str, int]):
+        self._choice_breakdown = value
+    
+    @property
+    def choice_percentages(self) -> Dict[str, float]:
+        return self._choice_percentages
+
+    @choice_percentages.setter
+    def choice_percentages(self, value: Dict[str, float]):
+        self._choice_percentages = value
+    
+    @property
+    def choice_averages(self) -> Dict[str, float]:
+        """Average ratings for rating-type votes (boto3-assist v0.30.0+ auto-converts Decimals)."""
+        return self._choice_averages
+
+    @choice_averages.setter
+    def choice_averages(self, value: Dict[str, float]):
+        self._choice_averages = value
+    
+    @property
+    def total_participants(self) -> int:
+        return self._total_participants
+
+    @total_participants.setter
+    def total_participants(self, value: int):
+        self._total_participants = value
+    
+    @property
+    def total_selections(self) -> int:
+        return self._total_selections
+
+    @total_selections.setter
+    def total_selections(self, value: int):
+        self._total_selections = value
+    
+    # Helper methods
+    def calculate_percentages(self):
+        """Calculate percentages from choice breakdown."""
+        if self.total_participants > 0:
+            self.choice_percentages = {
+                choice: (count / self.total_participants * 100)
+                for choice, count in self.choice_breakdown.items()
+            }
+        else:
+            self.choice_percentages = {}
+    
+    def get_winning_choice(self) -> str | None:
+        """Get the choice with the most votes."""
+        if not self.choice_breakdown:
+            return None
+        return max(self.choice_breakdown.items(), key=lambda x: x[1])[0]
+    
+    def get_choice_percentage(self, choice_id: str) -> float:
+        """Get percentage for a specific choice."""
+        return self.choice_percentages.get(choice_id, 0.0)

geek_cafe_saas_sdk/domains/voting/services/__init__.py

@@ -0,0 +1,11 @@
+# Voting Domain Services
+
+from .vote_service import VoteService
+from .vote_summary_service import VoteSummaryService
+from .vote_tally_service import VoteTallyService
+
+__all__ = [
+    "VoteService",
+    "VoteSummaryService",
+    "VoteTallyService",
+]

geek_cafe_saas_sdk/domains/voting/services/vote_service.py

@@ -0,0 +1,264 @@
+# Vote Service
+
+from typing import Dict, Any
+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.voting.models import Vote
+
+
+class VoteService(DatabaseService[Vote]):
+    """Service for Vote 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[Vote]:
+        """Create or update (upsert) a vote for a target by a user."""
+        try:
+            # Validate required fields
+            required_fields = ['target_id']
+            self._validate_required_fields(kwargs, required_fields)
+
+            # First check if a vote already exists for this user+target
+            existing = self._get_by_user_and_target(user_id, kwargs.get('target_id'))
+            if existing:
+                # Update the existing vote with new data
+                return self._update_existing_vote(existing, tenant_id, user_id, **kwargs)
+            
+            # Create new vote instance
+            vote = Vote()
+            vote.tenant_id = tenant_id
+            vote.user_id = user_id
+            vote.target_id = kwargs.get('target_id')
+            vote.created_by_id = user_id
+            
+            # Set vote data based on type
+            self._set_vote_data(vote, **kwargs)
+            
+            # Prepare for save (sets ID and timestamps)
+            vote.prep_for_save()
+            
+            # Save to database
+            return self._save_model(vote)
+            
+        except Exception as e:
+            return self._handle_service_exception(e, 'create_vote', tenant_id=tenant_id, user_id=user_id)
+
+    def _update_existing_vote(self, existing_vote: Vote, tenant_id: str, user_id: str, **kwargs) -> ServiceResult[Vote]:
+        """Update an existing vote with new data."""
+        # Set new vote data
+        self._set_vote_data(existing_vote, **kwargs)
+        
+        # Update metadata
+        existing_vote.updated_by_id = user_id
+        existing_vote.prep_for_save()  # Updates timestamp
+        
+        # Save updated vote
+        return self._save_model(existing_vote)
+
+    def _set_vote_data(self, vote: Vote, **kwargs):
+        """Set vote data based on the voting pattern."""
+        # Check if this is a legacy binary vote (has up_vote or down_vote but no vote_type)
+        has_legacy_fields = 'up_vote' in kwargs or 'down_vote' in kwargs
+        has_vote_type = 'vote_type' in kwargs
+        
+        if has_legacy_fields and not has_vote_type:
+            # This is a legacy binary vote
+            vote.vote_type = 'legacy'
+            vote.up_vote = int(kwargs.get('up_vote', 0) or 0)
+            vote.down_vote = int(kwargs.get('down_vote', 0) or 0)
+            vote.choices = kwargs.get('choices', {})
+            vote.content = kwargs.get('content', {})
+            return
+        
+        # Enhanced voting patterns
+        vote_type = kwargs.get('vote_type', 'single_choice')
+        vote.vote_type = vote_type
+        vote.content = kwargs.get('content', {})
+        
+        if vote_type == 'single_choice':
+            choice_id = kwargs.get('choice_id') or kwargs.get('selected_choice')
+            available_choices = kwargs.get('available_choices', [])
+            if choice_id:
+                vote.set_single_choice(choice_id, available_choices)
+        
+        elif vote_type == 'multi_select':
+            selected_choices = kwargs.get('selected_choices', [])
+            available_choices = kwargs.get('available_choices', [])
+            max_selections = kwargs.get('max_selections')
+            vote.set_multi_select(selected_choices, available_choices, max_selections)
+        
+        elif vote_type == 'ranking':
+            ranked_choices = kwargs.get('ranked_choices', [])
+            vote.set_ranking(ranked_choices)
+        
+        elif vote_type == 'rating':
+            ratings = kwargs.get('ratings', {})
+            vote.set_rating(ratings)
+        
+        elif vote_type == 'legacy':
+            # Explicit legacy support
+            vote.up_vote = int(kwargs.get('up_vote', 0) or 0)
+            vote.down_vote = int(kwargs.get('down_vote', 0) or 0)
+            vote.choices = kwargs.get('choices', {})
+        
+        else:
+            # Default to single choice if unknown type
+            vote.up_vote = int(kwargs.get('up_vote', 0) or 0)
+            vote.down_vote = int(kwargs.get('down_vote', 0) or 0)
+            vote.choices = kwargs.get('choices', {})
+
+    # Enhanced creation methods for specific vote types
+    def create_single_choice_vote(self, tenant_id: str, user_id: str, target_id: str, 
+                                 choice_id: str, available_choices: list[str] = None, 
+                                 content: Dict[str, Any] = None) -> ServiceResult[Vote]:
+        """Create a single choice vote (A/B/C/D test)."""
+        return self.create(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            target_id=target_id,
+            vote_type='single_choice',
+            choice_id=choice_id,
+            available_choices=available_choices or [],
+            content=content or {}
+        )
+
+    def create_multi_select_vote(self, tenant_id: str, user_id: str, target_id: str,
+                                selected_choices: list[str], available_choices: list[str] = None,
+                                max_selections: int = None, content: Dict[str, Any] = None) -> ServiceResult[Vote]:
+        """Create a multi-select vote."""
+        return self.create(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            target_id=target_id,
+            vote_type='multi_select',
+            selected_choices=selected_choices,
+            available_choices=available_choices or [],
+            max_selections=max_selections,
+            content=content or {}
+        )
+
+    def create_ranking_vote(self, tenant_id: str, user_id: str, target_id: str,
+                           ranked_choices: list[str], content: Dict[str, Any] = None) -> ServiceResult[Vote]:
+        """Create a ranking vote."""
+        return self.create(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            target_id=target_id,
+            vote_type='ranking',
+            ranked_choices=ranked_choices,
+            content=content or {}
+        )
+
+    def create_rating_vote(self, tenant_id: str, user_id: str, target_id: str,
+                          ratings: Dict[str, float], content: Dict[str, Any] = None) -> ServiceResult[Vote]:
+        """Create a rating vote."""
+        return self.create(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            target_id=target_id,
+            vote_type='rating',
+            ratings=ratings,
+            content=content or {}
+        )
+
+    def _get_by_user_and_target(self, user_id: str, target_id: str) -> Vote | None:
+        """Helper: get a vote by user and target via GSI4."""
+        model = Vote()
+        model.user_id = user_id
+        model.target_id = target_id
+        result = self._query_by_index(model, "gsi4")
+        if result.success and result.data:
+            return result.data[0]
+        return None
+    
+    def get_by_id(self, resource_id: str, tenant_id: str, user_id: str) -> ServiceResult[Vote]:
+        """Get vote by ID with access control."""
+        try:
+            vote = self._get_model_by_id(resource_id, Vote)
+            
+            if not vote:
+                raise NotFoundError(f"Vote with ID {resource_id} not found")
+            
+            # Validate tenant access
+            if hasattr(vote, 'tenant_id'):
+                self._validate_tenant_access(vote.tenant_id, tenant_id)
+            
+            return ServiceResult.success_result(vote)
+            
+        except Exception as e:
+            return self._handle_service_exception(e, 'get_vote', 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[Vote]:
+        """Update vote with access control."""
+        try:
+            # Get existing vote
+            vote = self._get_model_by_id(resource_id, Vote)
+            
+            if not vote:
+                raise NotFoundError(f"Vote with ID {resource_id} not found")
+            
+            # Validate tenant access
+            if hasattr(vote, 'tenant_id'):
+                self._validate_tenant_access(vote.tenant_id, tenant_id)
+            
+            # Apply updates
+            for field, value in updates.items():
+                if hasattr(vote, field) and field not in ['id', 'created_utc_ts', 'tenant_id']:
+                    setattr(vote, field, value)
+            
+            # Update metadata
+            vote.updated_by_id = user_id
+            vote.prep_for_save()  # Updates timestamp
+            
+            # Save updated vote
+            return self._save_model(vote)
+            
+        except Exception as e:
+            return self._handle_service_exception(e, 'update_vote', resource_id=resource_id, tenant_id=tenant_id)
+    
+    def delete(self, resource_id: str, tenant_id: str, user_id: str) -> ServiceResult[bool]:
+        """Delete vote with access control."""
+        try:
+            vote = self._get_model_by_id(resource_id, Vote)
+            
+            if not vote:
+                raise NotFoundError(f"Vote with ID {resource_id} not found")
+            
+            if hasattr(vote, 'tenant_id'):
+                self._validate_tenant_access(vote.tenant_id, tenant_id)
+            
+            return self._delete_model(vote)
+            
+        except Exception as e:
+            return self._handle_service_exception(e, 'delete_vote', resource_id=resource_id, tenant_id=tenant_id)
+    
+    def list_by_user(self, user_id: str, ascending: bool = False) -> ServiceResult[list[Vote]]:
+        """List votes by user."""
+        try:
+            model = Vote()
+            model.user_id = user_id
+            return self._query_by_index(model, "gsi2", ascending=ascending)
+        except Exception as e:
+            return self._handle_service_exception(e, 'list_votes', user_id=user_id)
+
+    def list_by_tenant(self, tenant_id: str) -> ServiceResult[list[Vote]]:
+        """List votes by tenant."""
+        try:
+            model = Vote()
+            model.tenant_id = tenant_id
+            return self._query_by_index(model, "gsi3")
+        except Exception as e:
+            return self._handle_service_exception(e, 'list_votes', tenant_id=tenant_id)
+
+    def list_by_target(self, target_id: str, *, start_key: dict = None, limit: int = None) -> ServiceResult[list[Vote]]:
+        """List votes by target with optional pagination."""
+        try:
+            model = Vote()
+            model.target_id = target_id
+            return self._query_by_index(model, "gsi5", start_key=start_key, limit=limit)
+        except Exception as e:
+            return self._handle_service_exception(e, 'list_votes', target_id=target_id)

geek_cafe_saas_sdk/domains/voting/services/vote_summary_service.py

@@ -0,0 +1,198 @@
+# Vote Summary Service
+
+from typing import Dict, Any
+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.voting.models import VoteSummary
+
+
+class VoteSummaryService(DatabaseService[VoteSummary]):
+    """Service for VoteSummary 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[VoteSummary]:
+        """Create or update (upsert) a vote summary for a target."""
+        try:
+            # Validate required fields
+            required_fields = ['target_id']
+            self._validate_required_fields(kwargs, required_fields)
+
+            # First check if a summary already exists for this target
+            existing = self._get_by_target_id(kwargs.get('target_id'))
+            if existing:
+                # Update the existing summary with all new data
+                return self._update_existing_summary(existing, tenant_id, user_id, **kwargs)
+            
+            # Create new vote summary instance
+            summary = VoteSummary()
+            summary.tenant_id = tenant_id
+            summary.user_id = user_id
+            summary.target_id = kwargs.get('target_id')
+            summary.created_by_id = user_id
+            
+            # Set enhanced fields
+            summary.vote_type = kwargs.get('vote_type', 'single_choice')
+            summary.choice_breakdown = kwargs.get('choice_breakdown', {})
+            summary.choice_percentages = kwargs.get('choice_percentages', {})
+            summary.choice_averages = kwargs.get('choice_averages', {})  # For rating votes
+            summary.total_participants = int(kwargs.get('total_participants', 0) or 0)
+            summary.total_selections = int(kwargs.get('total_selections', 0) or 0)
+            
+            # Set legacy fields for backward compatibility
+            summary.total_up_votes = int(kwargs.get('total_up_votes', 0) or 0)
+            summary.total_down_votes = int(kwargs.get('total_down_votes', 0) or 0)
+            summary.total_votes = int(kwargs.get('total_votes', 0) or 0)
+            
+            # Set content
+            summary.content = kwargs.get('content', {})
+            
+            # Calculate percentages if not provided
+            if not summary.choice_percentages and summary.choice_breakdown:
+                summary.calculate_percentages()
+            
+            # 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_vote_summary', tenant_id=tenant_id, user_id=user_id)
+
+    def _update_existing_summary(self, existing_summary: VoteSummary, tenant_id: str, user_id: str, **kwargs) -> ServiceResult[VoteSummary]:
+        """Update an existing summary with new data."""
+        # Update enhanced fields
+        existing_summary.vote_type = kwargs.get('vote_type', existing_summary.vote_type)
+        existing_summary.choice_breakdown = kwargs.get('choice_breakdown', existing_summary.choice_breakdown)
+        existing_summary.choice_percentages = kwargs.get('choice_percentages', existing_summary.choice_percentages)
+        existing_summary.choice_averages = kwargs.get('choice_averages', existing_summary.choice_averages)
+        existing_summary.total_participants = int(kwargs.get('total_participants', existing_summary.total_participants) or 0)
+        existing_summary.total_selections = int(kwargs.get('total_selections', existing_summary.total_selections) or 0)
+        
+        # Update legacy fields
+        existing_summary.total_up_votes = int(kwargs.get('total_up_votes', existing_summary.total_up_votes) or 0)
+        existing_summary.total_down_votes = int(kwargs.get('total_down_votes', existing_summary.total_down_votes) or 0)
+        existing_summary.total_votes = int(kwargs.get('total_votes', existing_summary.total_votes) or 0)
+        
+        # Update content
+        existing_summary.content = kwargs.get('content', existing_summary.content or {})
+        
+        # Recalculate percentages if needed
+        if not existing_summary.choice_percentages and existing_summary.choice_breakdown:
+            existing_summary.calculate_percentages()
+        
+        # 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_target_id(self, target_id: str) -> VoteSummary | None:
+        """Helper: get a vote summary by target_id via GSI2."""
+        model = VoteSummary()
+        model.target_id = target_id
+        result = self._query_by_index(model, "gsi2")
+        if result.success and result.data:
+            return result.data[0]
+        return None
+    
+    def get_by_id(self, resource_id: str, tenant_id: str, user_id: str) -> ServiceResult[VoteSummary]:
+        """Get vote summary by ID with access control."""
+        try:
+            summary = self._get_model_by_id(resource_id, VoteSummary)
+            
+            if not summary:
+                raise NotFoundError(f"VoteSummary 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_vote_summary', resource_id=resource_id, tenant_id=tenant_id)
+
+    def get_by_target_id(self, target_id: str, tenant_id: str, user_id: str) -> ServiceResult[VoteSummary]:
+        """Get vote summary by target_id with access control."""
+        try:
+            summary = self._get_by_target_id(target_id)
+            
+            if not summary:
+                raise NotFoundError(f"VoteSummary for target {target_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_vote_summary_by_target', target_id=target_id, tenant_id=tenant_id)
+    
+    def update(self, resource_id: str, tenant_id: str, user_id: str, 
+               updates: Dict[str, Any]) -> ServiceResult[VoteSummary]:
+        """Update vote summary with access control."""
+        try:
+            # Get existing summary
+            summary = self._get_model_by_id(resource_id, VoteSummary)
+            
+            if not summary:
+                raise NotFoundError(f"VoteSummary 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_vote_summary', resource_id=resource_id, tenant_id=tenant_id)
+    
+    def delete(self, resource_id: str, tenant_id: str, user_id: str) -> ServiceResult[bool]:
+        """Delete vote summary with access control."""
+        try:
+            summary = self._get_model_by_id(resource_id, VoteSummary)
+            
+            if not summary:
+                raise NotFoundError(f"VoteSummary 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_vote_summary', resource_id=resource_id, tenant_id=tenant_id)
+    
+    def list_by_tenant(self, tenant_id: str) -> ServiceResult[list[VoteSummary]]:
+        """List vote summaries by tenant."""
+        try:
+            model = VoteSummary()
+            model.tenant_id = tenant_id
+            return self._query_by_index(model, "gsi3")
+        except Exception as e:
+            return self._handle_service_exception(e, 'list_vote_summaries', tenant_id=tenant_id)
+
+    def list_all(self) -> ServiceResult[list[VoteSummary]]:
+        """List all vote summaries."""
+        try:
+            model = VoteSummary()
+            return self._query_by_index(model, "gsi1")
+        except Exception as e:
+            return self._handle_service_exception(e, 'list_all_vote_summaries')