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

geek_cafe_saas_sdk/domains/voting/handlers/votes/create/app.py

@@ -0,0 +1,128 @@
+"""
+Lambda handler for creating votes.
+
+REFACTORED VERSION using Factory Pattern.
+Reduces code and centralizes auth strategy configuration.
+
+The handler type is determined by environment variables:
+- AUTH_TYPE=secure (default) - API Gateway authorizer
+- AUTH_TYPE=api_key - x-api-key header validation
+- AUTH_TYPE=public - No authentication
+"""
+
+from typing import Dict, Any
+from geek_cafe_saas_sdk.lambda_handlers import create_handler
+from geek_cafe_saas_sdk.domains.voting.services import VoteService
+from geek_cafe_saas_sdk.utilities.response import error_response
+
+# ⚡ Initialize handler at module level for Lambda warm starts
+# Factory automatically selects handler based on AUTH_TYPE env var:
+#   - secure (default): API Gateway authorizer (Cognito/Lambda)
+#   - api_key: Validates x-api-key header
+#   - public: No authentication required
+#
+# This automatically handles:
+# - Authentication (based on AUTH_TYPE)
+# - Request body parsing
+# - Case conversion (camelCase → snake_case)
+# - Service pooling (connection reuse)
+# - User context extraction
+# - CORS headers (apply_cors=True by default)
+# - Error handling (apply_error_handling=True by default)
+handler = create_handler(
+    service_class=VoteService,
+    require_body=True,
+    convert_case=True
+)
+
+def lambda_handler(event: Dict[str, Any], context: Any, injected_service=None) -> Dict[str, Any]:
+    """
+    Create or update a vote.
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional VoteService for testing (Moto)
+
+    Expected request body:
+    {
+        "userId": "user_id",
+        "targetId": "health-meter-ui-choice",
+        "choiceId": "gauge" | "traffic_light",
+        "voteType": "single_choice",
+        "availableChoices": ["gauge", "traffic_light"],
+        "content": {
+            "description": "User preference for health meter display type",
+            "metadata": {...}
+        }
+    }
+    """
+    return handler.execute(event, context, create_vote, injected_service)
+
+
+def create_vote(
+    event: Dict[str, Any],
+    service: VoteService,
+    user_context: Dict[str, str]
+) -> Any:
+    """
+    Business logic for creating a vote.
+    
+    All boilerplate has been handled by the wrapper:
+    ✅ API key validation
+    ✅ Body parsing and case conversion
+    ✅ Service initialization
+    ✅ User context extraction
+    
+    Focus purely on business logic here.
+    
+    Args:
+        event: Enhanced event with parsed_body containing snake_case data
+        service: VoteService instance (pooled for warm starts)
+        user_context: Extracted user info (user_id, tenant_id, etc.)
+    
+    Returns:
+        ServiceResult that will be formatted into Lambda response
+    """
+    # Get parsed and converted body (camelCase → snake_case already done)
+    payload = event["parsed_body"]
+    
+    # Validate required fields
+    target_id = payload.get("target_id")
+    if not target_id:
+        return error_response("target_id is required", 400)
+    
+    choice_id = payload.get("choice_id")
+    if not choice_id:
+        return error_response("choice_id is required", 400)
+    
+    vote_type = payload.get("vote_type", "single_choice")
+    available_choices = payload.get("available_choices", [])
+    content = payload.get("content", {})
+    
+    # Validate choice_id is in available_choices if provided
+    if available_choices and choice_id not in available_choices:
+        return error_response(
+            f"choice_id '{choice_id}' must be one of: {available_choices}", 400
+        )
+    
+    # Get user info from context
+    tenant_id = user_context.get("tenant_id", "anonymous")
+    # we will get the logged in user if there is one, or a sudo user id sent by the client
+    user_id = user_context.get("user_id") or payload.get("user_id", "anonymous")
+    
+    # Create the vote based on type
+    if vote_type == "single_choice":
+        result = service.create_single_choice_vote(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            target_id=target_id,
+            choice_id=choice_id,
+            available_choices=available_choices if available_choices else None,
+            content=content if content else None,
+        )
+    else:
+        return error_response(f"Unsupported vote_type: {vote_type}", 400)
+    
+    # Return ServiceResult - handler will automatically format to Lambda response
+    return result

geek_cafe_saas_sdk/domains/voting/handlers/votes/delete/app.py

@@ -0,0 +1,41 @@
+# src/geek_cafe_saas_sdk/lambda_handlers/votes/delete/app.py
+
+from typing import Dict, Any
+
+from geek_cafe_saas_sdk.services import VoteService
+from geek_cafe_saas_sdk.lambda_handlers import ServicePool
+from geek_cafe_saas_sdk.utilities.response import service_result_to_response, error_response, success_response
+from geek_cafe_saas_sdk.utilities.lambda_event_utility import LambdaEventUtility
+
+vote_service_pool = ServicePool(VoteService)
+
+def handler(event: Dict[str, Any], context: object, injected_service=None) -> Dict[str, Any]:
+    """
+    Lambda handler for deleting a vote by its ID.
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional VoteService for testing
+    """
+    try:
+        vote_service = injected_service if injected_service else vote_service_pool.get()
+        user_id = LambdaEventUtility.get_authenticated_user_id(event)
+        tenant_id = LambdaEventUtility.get_authenticated_user_tenant_id(event)
+        resource_id = LambdaEventUtility.get_value_from_path_parameters(event, 'id')
+
+        if not resource_id:
+            return error_response("Vote ID is required in the path.", "VALIDATION_ERROR", 400)
+
+        result = vote_service.delete(
+            resource_id=resource_id,
+            tenant_id=tenant_id,
+            user_id=user_id
+        )
+
+        if result.success:
+            return success_response(message="Vote deleted successfully", status_code=204)
+        return service_result_to_response(result)
+
+    except Exception as e:
+        return error_response(f"An unexpected error occurred: {str(e)}", "INTERNAL_ERROR", 500)

geek_cafe_saas_sdk/domains/voting/handlers/votes/get/app.py

@@ -0,0 +1,39 @@
+# src/geek_cafe_saas_sdk/lambda_handlers/votes/get/app.py
+
+from typing import Dict, Any
+
+from geek_cafe_saas_sdk.services import VoteService
+from geek_cafe_saas_sdk.lambda_handlers import ServicePool
+from geek_cafe_saas_sdk.utilities.response import service_result_to_response, error_response
+from geek_cafe_saas_sdk.utilities.lambda_event_utility import LambdaEventUtility
+
+vote_service_pool = ServicePool(VoteService)
+
+def handler(event: Dict[str, Any], context: object, injected_service=None) -> Dict[str, Any]:
+    """
+    Lambda handler for retrieving a single vote by its ID.
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional VoteService for testing
+    """
+    try:
+        vote_service = injected_service if injected_service else vote_service_pool.get()
+        user_id = LambdaEventUtility.get_authenticated_user_id(event)
+        tenant_id = LambdaEventUtility.get_authenticated_user_tenant_id(event)
+        resource_id = LambdaEventUtility.get_value_from_path_parameters(event, 'id')
+
+        if not resource_id:
+            return error_response("Vote ID is required in the path.", "VALIDATION_ERROR", 400)
+
+        result = vote_service.get_by_id(
+            resource_id=resource_id,
+            tenant_id=tenant_id,
+            user_id=user_id
+        )
+
+        return service_result_to_response(result)
+
+    except Exception as e:
+        return error_response(f"An unexpected error occurred: {str(e)}", "INTERNAL_ERROR", 500)

geek_cafe_saas_sdk/domains/voting/handlers/votes/list/app.py

@@ -0,0 +1,38 @@
+# src/geek_cafe_saas_sdk/lambda_handlers/votes/list/app.py
+
+from typing import Dict, Any
+
+from geek_cafe_saas_sdk.services import VoteService
+from geek_cafe_saas_sdk.lambda_handlers import ServicePool
+from geek_cafe_saas_sdk.utilities.response import service_result_to_response, error_response
+from geek_cafe_saas_sdk.utilities.lambda_event_utility import LambdaEventUtility
+
+vote_service_pool = ServicePool(VoteService)
+
+def handler(event: Dict[str, Any], context: object, injected_service=None) -> Dict[str, Any]:
+    """
+    Lambda handler for listing votes with optional filters.
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional VoteService for testing
+    """
+    try:
+        vote_service = injected_service if injected_service else vote_service_pool.get()
+        user_id = LambdaEventUtility.get_authenticated_user_id(event)
+        tenant_id = LambdaEventUtility.get_authenticated_user_tenant_id(event)
+        query_params = event.get('queryStringParameters', {}) or {}
+
+        # Check for target_id in query params
+        target_id = query_params.get('target_id')
+        if target_id:
+            result = vote_service.list_by_target(target_id=target_id)
+        else:
+            # Default to listing by user
+            result = vote_service.list_by_user(user_id=user_id)
+
+        return service_result_to_response(result)
+
+    except Exception as e:
+        return error_response(f"An unexpected error occurred: {str(e)}", "INTERNAL_ERROR", 500)

geek_cafe_saas_sdk/domains/voting/handlers/votes/summerize/README.md

@@ -0,0 +1,3 @@
+# Summarize votes
+
+This lambda handler will summarize votes for a given target id.  You should run this on a schedule (e.g. every hour) to keep the summaries up to date.  Run via event bridge.

geek_cafe_saas_sdk/domains/voting/handlers/votes/update/app.py

@@ -0,0 +1,44 @@
+# src/geek_cafe_saas_sdk/lambda_handlers/votes/update/app.py
+
+import json
+from typing import Dict, Any
+
+from geek_cafe_saas_sdk.services import VoteService
+from geek_cafe_saas_sdk.lambda_handlers import ServicePool
+from geek_cafe_saas_sdk.utilities.response import service_result_to_response, error_response
+from geek_cafe_saas_sdk.utilities.lambda_event_utility import LambdaEventUtility
+
+vote_service_pool = ServicePool(VoteService)
+
+def handler(event: Dict[str, Any], context: object, injected_service=None) -> Dict[str, Any]:
+    """
+    Lambda handler for updating an existing vote.
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional VoteService for testing
+    """
+    try:
+        vote_service = injected_service if injected_service else vote_service_pool.get()
+        body = LambdaEventUtility.get_body_from_event(event)
+        user_id = LambdaEventUtility.get_authenticated_user_id(event)
+        tenant_id = LambdaEventUtility.get_authenticated_user_tenant_id(event)
+        resource_id = LambdaEventUtility.get_value_from_path_parameters(event, 'id')
+
+        if not resource_id:
+            return error_response("Vote ID is required in the path.", "VALIDATION_ERROR", 400)
+
+        result = vote_service.update(
+            resource_id=resource_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            updates=body
+        )
+
+        return service_result_to_response(result)
+
+    except json.JSONDecodeError:
+        return error_response("Invalid JSON in request body.", "VALIDATION_ERROR", 400)
+    except Exception as e:
+        return error_response(f"An unexpected error occurred: {str(e)}", "INTERNAL_ERROR", 500)

geek_cafe_saas_sdk/domains/voting/models/__init__.py

@@ -0,0 +1,9 @@
+# Voting Domain Models
+
+from .vote import Vote
+from .vote_summary import VoteSummary
+
+__all__ = [
+    "Vote",
+    "VoteSummary",
+]

geek_cafe_saas_sdk/domains/voting/models/vote.py

@@ -0,0 +1,231 @@
+
+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 Vote(BaseModel):
+    def __init__(self):
+        super().__init__()
+        self._content: Dict[str, Any] = {}
+        self._target_id: str | None = None
+        
+        # Enhanced voting system fields
+        self._vote_type: str = "single_choice"  # single_choice, multi_select, ranking, rating
+        self._choices: Dict[str, Any] = {}  # Flexible choice storage
+        self._max_selections: int | None = None  # For multi_select limits
+        
+        # Legacy fields (for backward compatibility)
+        self._up_vote: int = 0
+        self._down_vote: 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", self.id)
+        )
+
+        primary.sort_key.attribute_name = "sk"
+        primary.sort_key.value = lambda: DynamoDBKey.build_key(("vote", self.id))
+        self.indexes.add_primary(primary)
+        
+        ## GSI: 1
+        # GSI: all votes
+        gsi: DynamoDBIndex = DynamoDBIndex()
+        
+        gsi.name = "gsi1"
+        gsi.partition_key.attribute_name = f"{gsi.name}_pk"
+        gsi.partition_key.value = lambda: DynamoDBKey.build_key(("vote", "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: all votes by user, sorted by created ts
+        gsi: DynamoDBIndex = DynamoDBIndex()
+        
+        gsi.name = "gsi2"
+        gsi.partition_key.attribute_name = f"{gsi.name}_pk"
+        gsi.partition_key.value = lambda: DynamoDBKey.build_key(("user", self.user_id))
+        gsi.sort_key.attribute_name = f"{gsi.name}_sk"
+        gsi.sort_key.value = lambda: DynamoDBKey.build_key(
+           ("model", "vote"),("ts", self.created_utc_ts)
+        )
+        self.indexes.add_secondary(gsi)
+
+        ## GSI: 3
+        # GSI: all votes by tenant, sorted by created ts
+        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"),("ts", self.created_utc_ts)
+        )
+        self.indexes.add_secondary(gsi)
+
+        ## GSI: 4
+        # GSI: enforce uniqueness helper - all votes by user+target (one per target per user)
+        gsi: DynamoDBIndex = DynamoDBIndex()
+        
+        gsi.name = "gsi4"
+        gsi.partition_key.attribute_name = f"{gsi.name}_pk"
+        gsi.partition_key.value = lambda: DynamoDBKey.build_key(("user", self.user_id))
+        gsi.sort_key.attribute_name = f"{gsi.name}_sk"
+        gsi.sort_key.value = lambda: DynamoDBKey.build_key(
+           ("target", self.target_id)
+        )
+        self.indexes.add_secondary(gsi)
+
+        ## GSI: 5
+        # GSI: all votes for a target
+        gsi: DynamoDBIndex = DynamoDBIndex()
+        
+        gsi.name = "gsi5"
+        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(
+           ("ts", self.created_utc_ts)
+        )
+        self.indexes.add_secondary(gsi)
+
+    @property
+    def content(self) -> Dict[str, Any]:
+        return self._content
+
+    @content.setter
+    def content(self, value: Dict[str, Any]):
+        self._content = value
+    
+    @property
+    def up_vote(self) -> int:
+        return self._up_vote
+    
+    @up_vote.setter
+    def up_vote(self, value: int):
+        self._up_vote = value
+    
+    @property
+    def down_vote(self) -> int:
+        return self._down_vote
+    
+    @down_vote.setter
+    def down_vote(self, value: int):
+        self._down_vote = 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 choices(self) -> Dict[str, Any]:
+        return self._choices
+
+    @choices.setter
+    def choices(self, value: Dict[str, Any]):
+        self._choices = value
+    
+    @property
+    def max_selections(self) -> int | None:
+        return self._max_selections
+
+    @max_selections.setter
+    def max_selections(self, value: int | None):
+        self._max_selections = value
+    
+    # Helper methods for different voting patterns
+    def set_single_choice(self, choice_id: str, available_choices: list[str] = None):
+        """Set a single choice vote (A/B test, single selection)."""
+        self.vote_type = "single_choice"
+        self.choices = {choice_id: {"selected": True, "value": 1}}
+        
+        # Set legacy fields for backward compatibility
+        if available_choices and len(available_choices) >= 2:
+            self.up_vote = 1 if choice_id == available_choices[0] else 0
+            self.down_vote = 1 if choice_id == available_choices[1] else 0
+        else:
+            self.up_vote = 1
+            self.down_vote = 0
+    
+    def set_multi_select(self, selected_choices: list[str], available_choices: list[str] = None, max_selections: int = None):
+        """Set multiple choice selections."""
+        self.vote_type = "multi_select"
+        self.max_selections = max_selections
+        
+        # Build choices dict
+        if available_choices:
+            self.choices = {
+                choice: {"selected": choice in selected_choices, "value": 1 if choice in selected_choices else 0}
+                for choice in available_choices
+            }
+        else:
+            self.choices = {choice: {"selected": True, "value": 1} for choice in selected_choices}
+        
+        # Set legacy fields
+        self.up_vote = len(selected_choices)
+        self.down_vote = 0
+    
+    def set_ranking(self, ranked_choices: list[str]):
+        """Set ranked choices (1st, 2nd, 3rd preference)."""
+        self.vote_type = "ranking"
+        self.choices = {
+            choice: {"rank": idx + 1, "value": len(ranked_choices) - idx}
+            for idx, choice in enumerate(ranked_choices)
+        }
+        
+        # Set legacy fields
+        self.up_vote = len(ranked_choices)
+        self.down_vote = 0
+    
+    def set_rating(self, ratings: Dict[str, float]):
+        """Set rating votes (1-5 stars per option)."""
+        self.vote_type = "rating"
+        self.choices = {
+            choice: {"rating": rating, "value": rating}
+            for choice, rating in ratings.items()
+        }
+        
+        # Set legacy fields (average rating)
+        avg_rating = sum(ratings.values()) / len(ratings) if ratings else 0
+        self.up_vote = int(avg_rating)
+        self.down_vote = 0
+    
+    def get_selected_choices(self) -> list[str]:
+        """Get list of selected choices for any vote type."""
+        if self.vote_type == "single_choice":
+            return [choice for choice, data in self.choices.items() if data.get("selected")]
+        elif self.vote_type == "multi_select":
+            return [choice for choice, data in self.choices.items() if data.get("selected")]
+        elif self.vote_type == "ranking":
+            # Return choices sorted by rank
+            ranked = sorted(self.choices.items(), key=lambda x: x[1].get("rank", 999))
+            return [choice for choice, _ in ranked]
+        elif self.vote_type == "rating":
+            return list(self.choices.keys())
+        return []
+    
+    def get_choice_value(self, choice_id: str) -> Any:
+        """Get the value for a specific choice."""
+        return self.choices.get(choice_id, {}).get("value", 0)