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

geek_cafe_saas_sdk/domains/communities/services/community_service.py

@@ -0,0 +1,479 @@
+# Community Service
+
+from typing import Dict, Any, Optional, List
+from boto3_assist.dynamodb.dynamodb import DynamoDB
+from geek_cafe_saas_sdk.services.database_service import DatabaseService
+from .community_member_service import CommunityMemberService
+from geek_cafe_saas_sdk.core.service_result import ServiceResult
+from geek_cafe_saas_sdk.core.service_errors import ValidationError, NotFoundError, AccessDeniedError
+from geek_cafe_saas_sdk.domains.communities.models import Community
+import datetime as dt
+
+
+class CommunityService(DatabaseService[Community]):
+    """Service for Community database operations."""
+
+    def __init__(self, *, dynamodb: DynamoDB = None, table_name: str = None):
+        super().__init__(dynamodb=dynamodb, table_name=table_name)
+        # Initialize member service with same DB connection
+        self.member_service = CommunityMemberService(dynamodb=dynamodb, table_name=table_name)
+
+    def create(self, tenant_id: str, user_id: str, **kwargs) -> ServiceResult[Community]:
+        """Create a new community."""
+        try:
+            # Validate required fields
+            required_fields = ['name', 'description', 'category']
+            self._validate_required_fields(kwargs, required_fields)
+
+            # Validate community name uniqueness per user
+            if self._community_name_exists_for_user(kwargs['name'], user_id, tenant_id):
+                raise ValidationError("Community name already exists for this user")
+
+            # Validate category
+            if not self._is_valid_category(kwargs['category']):
+                raise ValidationError("Invalid category")
+
+            # Create community instance using map() approach
+            community = Community().map(kwargs)
+            community.owner_id = user_id  # Creator is the owner
+            community.member_count = 1  # Owner is first member
+            community.tenant_id = tenant_id
+            community.user_id = user_id
+            community.created_by_id = user_id
+
+            # Prepare for save (sets ID and timestamps)
+            community.prep_for_save()
+
+            # Save to database
+            save_result = self._save_model(community)
+            
+            if save_result.success:
+                # Add owner as first member (adjacent record)
+                member_result = self.member_service.add_member(
+                    community_id=community.id,
+                    user_id=user_id,
+                    status="active"
+                )
+                
+                if not member_result.success:
+                    # Log warning but don't fail - community is created
+                    pass
+            
+            return save_result
+
+        except Exception as e:
+            return self._handle_service_exception(e, 'create_community', tenant_id=tenant_id, user_id=user_id)
+
+    def get_by_id(self, resource_id: str, tenant_id: str, user_id: str) -> ServiceResult[Community]:
+        """Get community by ID with access control."""
+        try:
+            community = self._get_model_by_id(resource_id, Community)
+
+            if not community:
+                raise NotFoundError(f"Community with ID {resource_id} not found")
+
+            # Check if deleted
+            if community.is_deleted():
+                raise NotFoundError(f"Community with ID {resource_id} not found")
+
+            # Validate tenant access
+            if hasattr(community, 'tenant_id'):
+                self._validate_tenant_access(community.tenant_id, tenant_id)
+
+            return ServiceResult.success_result(community)
+
+        except Exception as e:
+            return self._handle_service_exception(e, 'get_community', resource_id=resource_id, tenant_id=tenant_id)
+
+    def get_communities_by_owner(self, owner_id: str, tenant_id: str, user_id: str,
+                          limit: int = 50) -> ServiceResult[List[Community]]:
+        """Get communities owned by a specific user using GSI1."""
+        try:
+            # Create a temporary community instance to get the GSI key
+            temp_community = Community()
+            temp_community.owner_id = owner_id
+
+            # Query by GSI1 (communities by owner), most recent first
+            result = self._query_by_index(
+                temp_community,
+                "gsi1",
+                ascending=False,  # Most recent first
+                limit=limit
+            )
+
+            if not result.success:
+                return result
+
+            # Filter out deleted communities and validate tenant access
+            active_communities = []
+            for community in result.data:
+                if not community.is_deleted() and community.tenant_id == tenant_id:
+                    active_communities.append(community)
+
+            return ServiceResult.success_result(active_communities)
+
+        except Exception as e:
+            return self._handle_service_exception(e, 'get_communities_by_owner',
+                                               owner_id=owner_id, tenant_id=tenant_id)
+
+    def get_communities_by_member(self, member_id: str, tenant_id: str, user_id: str,
+                           limit: int = 50) -> ServiceResult[List[Community]]:
+        """Get communities where a user is a member."""
+        try:
+            # This is more complex - we'd need a GSI that indexes membership
+            # For now, we'll query all communities and filter client-side
+            # In production, we'd want a GSI for user->communities membership
+
+            all_communities_result = self.get_all_communities(tenant_id, user_id, limit=limit*2)
+
+            if not all_communities_result.success:
+                return all_communities_result
+
+            member_communities = [
+                community for community in all_communities_result.data
+                if community.is_user_member(member_id)
+            ][:limit]
+
+            return ServiceResult.success_result(member_communities)
+
+        except Exception as e:
+            return self._handle_service_exception(e, 'get_communities_by_member',
+                                               member_id=member_id, tenant_id=tenant_id)
+
+    def get_communities_by_privacy(self, privacy: str, tenant_id: str, user_id: str,
+                            limit: int = 50) -> ServiceResult[List[Community]]:
+        """Get communities by privacy level using GSI2."""
+        try:
+            # Create a temporary community instance to get the GSI key
+            temp_community = Community()
+            temp_community.privacy = privacy
+
+            # Query by GSI2 (communities by privacy), most recent first
+            result = self._query_by_index(
+                temp_community,
+                "gsi2",
+                ascending=False,  # Most recent first
+                limit=limit
+            )
+
+            if not result.success:
+                return result
+
+            # Filter out deleted communities and validate tenant access
+            active_communities = []
+            for community in result.data:
+                if not community.is_deleted() and community.tenant_id == tenant_id:
+                    active_communities.append(community)
+
+            return ServiceResult.success_result(active_communities)
+
+        except Exception as e:
+            return self._handle_service_exception(e, 'get_communities_by_privacy',
+                                               privacy=privacy, tenant_id=tenant_id)
+
+    def get_all_communities(self, tenant_id: str, user_id: str, limit: int = 50) -> ServiceResult[List[Community]]:
+        """Get all communities for a tenant using GSI4."""
+        try:
+            # Create a temporary community instance to get the GSI key
+            temp_community = Community()
+            temp_community.tenant_id = tenant_id
+
+            # Query by GSI4 (communities by tenant), most recent first
+            result = self._query_by_index(
+                temp_community,
+                "gsi4",
+                ascending=False,  # Most recent first
+                limit=limit
+            )
+
+            if not result.success:
+                return result
+
+            # Filter out deleted communities
+            active_communities = []
+            for community in result.data:
+                if not community.is_deleted():
+                    active_communities.append(community)
+
+            return ServiceResult.success_result(active_communities)
+
+        except Exception as e:
+            return self._handle_service_exception(e, 'get_all_communities', tenant_id=tenant_id)
+
+    def get_communities_by_category(self, category: str, tenant_id: str, user_id: str,
+                             limit: int = 50) -> ServiceResult[List[Community]]:
+        """Get communities by category using GSI3."""
+        try:
+            # Create a temporary community instance to get the GSI key
+            temp_community = Community()
+            temp_community.category = category
+
+            # Query by GSI3 (communities by category), most recent first
+            result = self._query_by_index(
+                temp_community,
+                "gsi3",
+                ascending=False,  # Most recent first
+                limit=limit
+            )
+
+            if not result.success:
+                return result
+
+            # Filter out deleted communities and validate tenant access
+            active_communities = []
+            for community in result.data:
+                if not community.is_deleted() and community.tenant_id == tenant_id:
+                    active_communities.append(community)
+
+            return ServiceResult.success_result(active_communities)
+
+        except Exception as e:
+            return self._handle_service_exception(e, 'get_communities_by_category',
+                                               category=category, tenant_id=tenant_id)
+
+    def update(self, resource_id: str, tenant_id: str, user_id: str,
+               updates: Dict[str, Any]) -> ServiceResult[Community]:
+        """Update community with access control."""
+        try:
+            # Get existing community
+            community = self._get_model_by_id(resource_id, Community)
+
+            if not community:
+                raise NotFoundError(f"Community with ID {resource_id} not found")
+
+            # Validate tenant access
+            if hasattr(community, 'tenant_id'):
+                self._validate_tenant_access(community.tenant_id, tenant_id)
+
+            # Check permissions (organizers only)
+            if not community.can_user_manage(user_id):
+                raise AccessDeniedError("Access denied: insufficient permissions")
+
+            # Cannot change owner
+            if 'owner_id' in updates:
+                raise ValidationError("Cannot change community owner")
+
+            # Validate category if being updated
+            if 'category' in updates and not self._is_valid_category(updates['category']):
+                raise ValidationError("Invalid category")
+
+            # Validate community name uniqueness if being updated
+            if 'name' in updates:
+                existing_community = self._get_community_by_name_and_owner(updates['name'], community.owner_id, tenant_id)
+                if existing_community and existing_community.id != resource_id:
+                    raise ValidationError("Community name already exists for this user")
+
+            # Apply updates
+            for field, value in updates.items():
+                if hasattr(community, field) and field not in ['id', 'created_utc_ts', 'tenant_id', 'owner_id']:
+                    if field == 'name':
+                        community.name = value
+                    elif field == 'description':
+                        community.description = value
+                    elif field == 'category':
+                        community.category = value
+                    elif field == 'privacy':
+                        community.privacy = value
+                    elif field == 'tags':
+                        community.tags = value
+                    elif field == 'joinApproval':
+                        community.join_approval = value
+                    elif field == 'requiresDues':
+                        community.requires_dues = value
+                    elif field == 'duesMonthly':
+                        community.dues_monthly = value
+                    elif field == 'duesYearly':
+                        community.dues_yearly = value
+                    elif field == 'co_owners':
+                        community.co_owners = value
+                    elif field == 'moderators':
+                        community.moderators = value
+                    elif field == 'members':
+                        community.members = value
+
+            # Update metadata
+            community.updated_by_id = user_id
+            community.prep_for_save()  # Updates timestamp
+
+            # Save updated community
+            return self._save_model(community)
+
+        except Exception as e:
+            return self._handle_service_exception(e, 'update_community', resource_id=resource_id, tenant_id=tenant_id)
+
+    def delete(self, resource_id: str, tenant_id: str, user_id: str) -> ServiceResult[bool]:
+        """Soft delete community with access control."""
+        try:
+            # Get existing community
+            community = self._get_model_by_id(resource_id, Community)
+
+            if not community:
+                raise NotFoundError(f"Community with ID {resource_id} not found")
+
+            # Check if already deleted
+            if community.is_deleted():
+                return ServiceResult.success_result(True)
+
+            # Validate tenant access
+            if hasattr(community, 'tenant_id'):
+                self._validate_tenant_access(community.tenant_id, tenant_id)
+
+            # Check permissions (owner only)
+            if community.owner_id != user_id:
+                raise AccessDeniedError("Access denied: only community owner can delete")
+
+            # Soft delete: set deleted timestamp and metadata
+            community.deleted_utc_ts = dt.datetime.now(dt.UTC).timestamp()
+            community.deleted_by_id = user_id
+            community.prep_for_save()  # Updates timestamp
+
+            # Save the updated community
+            save_result = self._save_model(community)
+            if save_result.success:
+                return ServiceResult.success_result(True)
+            else:
+                return save_result
+
+        except Exception as e:
+            return self._handle_service_exception(e, 'delete_community', resource_id=resource_id, tenant_id=tenant_id)
+
+    # Convenience method for backwards compatibility / clearer naming
+    def list_by_tenant(self, tenant_id: str, user_id: str, limit: int = 50) -> ServiceResult[List[Community]]:
+        """Alias for get_all_communities."""
+        return self.get_all_communities(tenant_id, user_id, limit)
+
+    def _community_name_exists_for_user(self, name: str, user_id: str, tenant_id: str) -> bool:
+        """Check if community name already exists for this user."""
+        try:
+            community = self._get_community_by_name_and_owner(name, user_id, tenant_id)
+            return community is not None
+        except:
+            return False
+
+    def _get_community_by_name_and_owner(self, name: str, owner_id: str, tenant_id: str) -> Optional[Community]:
+        """Get community by name and owner (helper method)."""
+        # This would require a GSI for name+owner
+        # For now, we'll query owner's communities and check names
+        owner_communities_result = self.get_communities_by_owner(owner_id, tenant_id, owner_id, limit=100)
+        if owner_communities_result.success:
+            for community in owner_communities_result.data:
+                if community.name == name:
+                    return community
+        return None
+
+    def _is_valid_category(self, category: str) -> bool:
+        """Validate community category."""
+        # This should come from a predefined list
+        valid_categories = [
+            "sports", "hobby", "professional", "educational",
+            "social", "religious", "political", "charity",
+            "entertainment", "other"
+        ]
+        return category.lower() in valid_categories
+    
+    # Member Management Methods (delegates to CommunityMemberService)
+    
+    def add_member(self, community_id: str, user_id: str, invited_by_id: str = None,
+                   status: str = "active", tenant_id: str = None) -> ServiceResult:
+        """
+        Add a member to the community.
+        
+        Args:
+            community_id: Community ID
+            user_id: User ID to add
+            invited_by_id: Optional ID of user who invited
+            status: Member status (default: active)
+            tenant_id: Tenant ID for access control
+        """
+        try:
+            # Get community to update count
+            if tenant_id:
+                community_result = self.get_by_id(community_id, tenant_id, invited_by_id or user_id)
+                if not community_result.success:
+                    return community_result
+                community = community_result.data
+            
+            # Add member via member service
+            result = self.member_service.add_member(community_id, user_id, invited_by_id, status)
+            
+            # Update cached member count if successful and we have community
+            if result.success and tenant_id and community:
+                community.increment_member_count()
+                self._save_model(community)
+            
+            return result
+            
+        except Exception as e:
+            return self._handle_service_exception(e, 'add_member', community_id=community_id, user_id=user_id)
+    
+    def remove_member(self, community_id: str, user_id: str, tenant_id: str = None) -> ServiceResult:
+        """
+        Remove a member from the community.
+        
+        Args:
+            community_id: Community ID
+            user_id: User ID to remove
+            tenant_id: Optional tenant ID for updating cached count
+        """
+        try:
+            # Remove member via member service
+            result = self.member_service.remove_member(community_id, user_id)
+            
+            # Update cached member count if we have tenant context
+            if result.success and tenant_id:
+                try:
+                    community_result = self.get_by_id(community_id, tenant_id, user_id)
+                    if community_result.success:
+                        community = community_result.data
+                        community.decrement_member_count()
+                        self._save_model(community)
+                except:
+                    pass  # Don't fail removal if count update fails
+            
+            return result
+            
+        except Exception as e:
+            return self._handle_service_exception(e, 'remove_member', community_id=community_id, user_id=user_id)
+    
+    def is_member(self, community_id: str, user_id: str, active_only: bool = True) -> bool:
+        """
+        Check if user is a member of the community.
+        
+        Args:
+            community_id: Community ID
+            user_id: User ID
+            active_only: Only check active members (default: True)
+        """
+        return self.member_service.is_member(community_id, user_id, active_only)
+    
+    def get_members(self, community_id: str, status: str = None, limit: int = 50) -> ServiceResult:
+        """
+        Get members of a community.
+        
+        Args:
+            community_id: Community ID
+            status: Optional status filter
+            limit: Max results
+        """
+        return self.member_service.list_members(community_id, status, limit)
+    
+    def get_member_count_realtime(self, community_id: str, status: str = "active") -> ServiceResult:
+        """
+        Get real-time member count from database.
+        
+        Args:
+            community_id: Community ID
+            status: Status filter (default: active)
+        """
+        return self.member_service.get_member_count(community_id, status)
+    
+    def get_user_communities(self, user_id: str, status: str = "active", limit: int = 50) -> ServiceResult:
+        """
+        Get communities a user is a member of.
+        
+        Args:
+            user_id: User ID
+            status: Member status filter
+            limit: Max results
+        """
+        return self.member_service.list_user_communities(user_id, status, limit)

geek_cafe_saas_sdk/domains/events/handlers/attendees/app.py

@@ -0,0 +1,67 @@
+# src/geek_cafe_saas_sdk/lambda_handlers/events/attendees/app.py
+
+from typing import Dict, Any
+
+from geek_cafe_saas_sdk.domains.events.services.event_attendee_service import EventAttendeeService
+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
+
+attendee_service_pool = ServicePool(EventAttendeeService)
+
+def handler(event: Dict[str, Any], context: object, injected_service=None) -> Dict[str, Any]:
+    """
+    Lambda handler for listing event attendees.
+    
+    Supports filtering by RSVP status and role.
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional EventAttendeeService for testing
+        
+    Query Parameters:
+        event_id: Event ID (required)
+        rsvp_status: Filter by status (accepted, declined, tentative, invited, waitlist)
+        role: Filter by role (organizer, co_host, attendee, speaker, volunteer)
+        limit: Max results (default 100)
+        
+    Examples:
+        /events/attendees?event_id=evt_123
+        /events/attendees?event_id=evt_123&rsvp_status=accepted
+        /events/attendees?event_id=evt_123&role=organizer
+        /events/attendees?event_id=evt_123&rsvp_status=accepted&role=speaker
+    
+    Returns 200 with list of attendees
+    """
+    try:
+        attendee_service = injected_service if injected_service else attendee_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 {}
+
+        # Validate required param
+        event_id = query_params.get('event_id')
+        if not event_id:
+            return error_response("event_id query parameter is required", "VALIDATION_ERROR", 400)
+
+        # Extract optional filters
+        rsvp_status = query_params.get('rsvp_status')
+        role = query_params.get('role')
+        limit = int(query_params.get('limit', 100))
+
+        # Get attendees
+        result = attendee_service.list_by_event(
+            event_id=event_id,
+            tenant_id=tenant_id,
+            rsvp_status=rsvp_status,
+            role=role,
+            limit=limit
+        )
+
+        return service_result_to_response(result)
+
+    except ValueError as e:
+        return error_response(f"Invalid parameter value: {str(e)}", "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/events/handlers/cancel/app.py

@@ -0,0 +1,66 @@
+# src/geek_cafe_saas_sdk/lambda_handlers/events/cancel/app.py
+
+import json
+from typing import Dict, Any
+
+from geek_cafe_saas_sdk.domains.events.services.event_service import EventService
+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
+
+event_service_pool = ServicePool(EventService)
+
+def handler(event: Dict[str, Any], context: object, injected_service=None) -> Dict[str, Any]:
+    """
+    Lambda handler for cancelling an event.
+    
+    Changes status to 'cancelled' with optional reason.
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional EventService for testing
+        
+    Path Parameters:
+        id: Event ID
+        
+    Expected body (optional):
+    {
+        "cancellation_reason": "Weather concerns"
+    }
+        
+    Example:
+        POST /events/{id}/cancel
+    
+    Returns 200 with cancelled event
+    """
+    try:
+        event_service = injected_service if injected_service else event_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("Event ID is required in the path.", "VALIDATION_ERROR", 400)
+
+        # Get optional cancellation reason
+        cancellation_reason = None
+        try:
+            body = LambdaEventUtility.get_body_from_event(event)
+            cancellation_reason = body.get('cancellation_reason')
+        except:
+            pass  # Body is optional
+
+        result = event_service.cancel(
+            resource_id=resource_id,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            cancellation_reason=cancellation_reason
+        )
+
+        return service_result_to_response(result)
+
+    except json.JSONDecodeError:
+        return error_response("Invalid JSON format 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/events/handlers/check_in/app.py

@@ -0,0 +1,60 @@
+# src/geek_cafe_saas_sdk/lambda_handlers/events/check_in/app.py
+
+import json
+from typing import Dict, Any
+
+from geek_cafe_saas_sdk.domains.events.services.event_attendee_service import EventAttendeeService
+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
+
+attendee_service_pool = ServicePool(EventAttendeeService)
+
+def handler(event: Dict[str, Any], context: object, injected_service=None) -> Dict[str, Any]:
+    """
+    Lambda handler for checking in attendees.
+    
+    Allows hosts/organizers to check in attendees at the event.
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional EventAttendeeService for testing
+        
+    Expected body:
+    {
+        "event_id": "evt_123",
+        "attendee_user_id": "user_456"  // User to check in
+    }
+    
+    Returns 200 with updated attendee record (check_in = true)
+    """
+    try:
+        attendee_service = injected_service if injected_service else attendee_service_pool.get()
+        body = LambdaEventUtility.get_body_from_event(event)
+        user_id = LambdaEventUtility.get_authenticated_user_id(event)  # Who is checking them in
+        tenant_id = LambdaEventUtility.get_authenticated_user_tenant_id(event)
+
+        # Validate required fields
+        event_id = body.get('event_id')
+        attendee_user_id = body.get('attendee_user_id')
+
+        if not event_id:
+            return error_response("event_id is required", "VALIDATION_ERROR", 400)
+        if not attendee_user_id:
+            return error_response("attendee_user_id is required", "VALIDATION_ERROR", 400)
+
+        # Check in the attendee
+        result = attendee_service.check_in(
+            event_id=event_id,
+            user_id=attendee_user_id,
+            tenant_id=tenant_id,
+            checked_in_by_user_id=user_id
+        )
+
+        return service_result_to_response(result)
+
+    except json.JSONDecodeError:
+        return error_response("Invalid JSON format in request body.", "VALIDATION_ERROR", 400)
+    except Exception as e:
+        return error_response(f"An unexpected error occurred: {str(e)}", "INTERNAL_ERROR", 500)