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

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

@@ -0,0 +1,93 @@
+# src/geek_cafe_saas_sdk/lambda_handlers/events/create/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
+from geek_cafe_saas_sdk.domains.events.models.event import Event
+
+event_service_pool = ServicePool(EventService)
+
+def handler(event: Dict[str, Any], context: object, injected_service=None) -> Dict[str, Any]:
+    """
+    Lambda handler for creating a new event.
+    
+    Supports both timestamp-based and ISO8601 datetime formats.
+    Automatically creates EventAttendee record for owner as organizer.
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional EventService for testing (Moto)
+        
+    Expected body (all optional except title and start time):
+    {
+        "title": "Python Meetup",
+        "start_utc_ts": 1731717600.0,  // OR use start_datetime
+        "start_datetime": "2025-11-15T18:00:00-08:00",  // Auto-converts to timestamp
+        "end_utc_ts": 1731728400.0,  // OR use end_datetime
+        "end_datetime": "2025-11-15T21:00:00-08:00",
+        "timezone": "America/Los_Angeles",
+        "description": "Monthly Python meetup",
+        "event_type": "meetup",
+        "status": "draft",  // or "published"
+        "visibility": "public",
+        
+        // Location
+        "location_type": "physical",  // physical, virtual, hybrid
+        "location_name": "Tech Hub SF",
+        "location_address": "123 Main St",
+        "location_city": "San Francisco",
+        "location_state": "CA",
+        "location_country": "US",
+        "location_latitude": 37.7749,
+        "location_longitude": -122.4194,
+        "virtual_link": "https://zoom.us/...",
+        
+        // Capacity
+        "max_attendees": 50,
+        "allow_waitlist": true,
+        "requires_approval": false,
+        "allow_guest_plus_one": true,
+        "registration_deadline_utc_ts": 1731600000.0,
+        
+        // Other
+        "group_id": "group_123",
+        "tags": ["python", "networking"],
+        "custom_fields": {"dietary": "text", "experience": "select"}
+    }
+    """
+    try:
+        # Use injected service (testing) or pool (production)
+        event_service = injected_service if injected_service else event_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)
+
+        # Convert ISO8601 datetime strings to timestamps if provided
+        if 'start_datetime' in body and 'start_utc_ts' not in body:
+            body['start_utc_ts'] = Event.datetime_to_utc_ts(body['start_datetime'])
+        if 'end_datetime' in body and 'end_utc_ts' not in body:
+            body['end_utc_ts'] = Event.datetime_to_utc_ts(body['end_datetime'])
+        if 'registration_deadline_datetime' in body and 'registration_deadline_utc_ts' not in body:
+            body['registration_deadline_utc_ts'] = Event.datetime_to_utc_ts(body['registration_deadline_datetime'])
+
+        # Pass all body parameters to the service
+        # Service will auto-create EventAttendee for owner
+        result = event_service.create(
+            tenant_id=tenant_id,
+            user_id=user_id,
+            create_organizer_attendee=True,  # Auto-create attendee record
+            **body
+        )
+
+        return service_result_to_response(result, success_status=201)
+
+    except json.JSONDecodeError:
+        return error_response("Invalid JSON format in request body.", "VALIDATION_ERROR", 400)
+    except Exception as e:
+        # In a production environment, log the exception e
+        return error_response(f"An unexpected error occurred: {str(e)}", "INTERNAL_ERROR", 500)

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

@@ -0,0 +1,42 @@
+# src/geek_cafe_saas_sdk/lambda_handlers/events/delete/app.py
+
+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, success_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 deleting an event by its ID.
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional EventService for testing
+    """
+    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)
+
+        result = event_service.delete(
+            resource_id=resource_id,
+            tenant_id=tenant_id,
+            user_id=user_id
+        )
+
+        if result.success:
+            return success_response(None, status_code=204)
+        else:
+            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/events/handlers/get/app.py

@@ -0,0 +1,39 @@
+# src/geek_cafe_saas_sdk/lambda_handlers/events/get/app.py
+
+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 retrieving a single event by its ID.
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional EventService for testing
+    """
+    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)
+
+        result = event_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/events/handlers/invite/app.py

@@ -0,0 +1,98 @@
+# src/geek_cafe_saas_sdk/lambda_handlers/events/invite/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 inviting user(s) to an event.
+    
+    Supports single and bulk invitations.
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional EventAttendeeService for testing
+        
+    Expected body:
+    {
+        "event_id": "evt_123",
+        "user_id": "user_456",  // For single invite
+        "user_ids": ["user_1", "user_2"],  // For bulk invite
+        "role": "attendee",  // or "co_host", "speaker", "volunteer"
+        "registration_data": {"dietary": "vegetarian"},
+        "registration_notes": "Looking forward to it!"
+    }
+    
+    Returns 201 with invitation record(s)
+    """
+    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)
+        tenant_id = LambdaEventUtility.get_authenticated_user_tenant_id(event)
+
+        # Validate required fields
+        event_id = body.get('event_id')
+        if not event_id:
+            return error_response("event_id is required", "VALIDATION_ERROR", 400)
+
+        # Check for bulk invite
+        if 'user_ids' in body:
+            # Bulk invite
+            user_ids = body.get('user_ids', [])
+            if not user_ids:
+                return error_response("user_ids must be a non-empty list", "VALIDATION_ERROR", 400)
+
+            # Extract optional params
+            kwargs = {}
+            if 'role' in body:
+                kwargs['role'] = body['role']
+            if 'registration_data' in body:
+                kwargs['registration_data'] = body['registration_data']
+            if 'registration_notes' in body:
+                kwargs['registration_notes'] = body['registration_notes']
+
+            result = attendee_service.bulk_invite(
+                event_id=event_id,
+                user_ids=user_ids,
+                tenant_id=tenant_id,
+                invited_by_user_id=user_id,
+                **kwargs
+            )
+        else:
+            # Single invite
+            invitee_user_id = body.get('user_id')
+            if not invitee_user_id:
+                return error_response("user_id or user_ids is required", "VALIDATION_ERROR", 400)
+
+            # Extract optional params
+            kwargs = {}
+            if 'role' in body:
+                kwargs['role'] = body['role']
+            if 'registration_data' in body:
+                kwargs['registration_data'] = body['registration_data']
+            if 'registration_notes' in body:
+                kwargs['registration_notes'] = body['registration_notes']
+
+            result = attendee_service.invite(
+                event_id=event_id,
+                user_id=invitee_user_id,
+                tenant_id=tenant_id,
+                invited_by_user_id=user_id,
+                **kwargs
+            )
+
+        return service_result_to_response(result, success_status=201)
+
+    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/list/app.py

@@ -0,0 +1,125 @@
+# src/geek_cafe_saas_sdk/lambda_handlers/events/list/app.py
+
+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 listing events with location-based and other filters.
+    
+    Supports multiple query patterns:
+    - By city: ?city=San Francisco&state=CA&country=US
+    - By state: ?state=CA&country=US
+    - Nearby: ?latitude=37.7749&longitude=-122.4194&radius=25
+    - By owner: ?owner_id=user_123
+    - By type: ?event_type=meetup&status=published
+    - By group: ?group_id=group_123
+    - Public discovery: ?visibility=public&status=published
+    - All for tenant: (no params)
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional EventService for testing
+        
+    Query Parameters:
+        city: City name
+        state: State/Province/Region
+        country: Country code
+        latitude: Latitude for nearby search
+        longitude: Longitude for nearby search
+        radius: Radius in km (default 25)
+        owner_id: Owner user ID
+        event_type: Event type (meetup, conference, etc.)
+        group_id: Group ID
+        visibility: public, private, members_only
+        status: draft, published, cancelled, completed
+        limit: Max results (default 50)
+    """
+    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)
+        query_params = event.get('queryStringParameters', {}) or {}
+
+        # Extract common parameters
+        limit = int(query_params.get('limit', 50))
+
+        # Route to appropriate service method based on query params
+        if 'latitude' in query_params and 'longitude' in query_params:
+            # Nearby search (geo-location)
+            result = event_service.list_nearby(
+                latitude=float(query_params['latitude']),
+                longitude=float(query_params['longitude']),
+                radius_km=float(query_params.get('radius', 25)),
+                tenant_id=tenant_id,
+                limit=limit
+            )
+        elif 'city' in query_params:
+            # City search
+            result = event_service.list_by_city(
+                city=query_params['city'],
+                state=query_params.get('state'),
+                country=query_params.get('country'),
+                tenant_id=tenant_id,
+                limit=limit
+            )
+        elif 'state' in query_params:
+            # State/region search
+            result = event_service.list_by_state(
+                state=query_params['state'],
+                country=query_params.get('country'),
+                tenant_id=tenant_id,
+                limit=limit
+            )
+        elif 'owner_id' in query_params:
+            # Events by owner
+            result = event_service.list_by_owner(
+                owner_id=query_params['owner_id'],
+                tenant_id=tenant_id,
+                limit=limit
+            )
+        elif 'event_type' in query_params:
+            # Events by type
+            status = query_params.get('status', 'published')
+            result = event_service.list_by_type(
+                event_type=query_params['event_type'],
+                tenant_id=tenant_id,
+                status=status,
+                limit=limit
+            )
+        elif 'group_id' in query_params:
+            # Events by group
+            result = event_service.list_by_group(
+                group_id=query_params['group_id'],
+                tenant_id=tenant_id,
+                limit=limit
+            )
+        elif 'visibility' in query_params:
+            # Public discovery
+            status = query_params.get('status', 'published')
+            result = event_service.list_public_events(
+                tenant_id=tenant_id,
+                visibility=query_params['visibility'],
+                status=status,
+                limit=limit
+            )
+        else:
+            # All events for tenant
+            result = event_service.list_by_tenant(
+                tenant_id=tenant_id,
+                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/publish/app.py

@@ -0,0 +1,49 @@
+# src/geek_cafe_saas_sdk/lambda_handlers/events/publish/app.py
+
+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 publishing a draft event.
+    
+    Changes status from 'draft' to 'published'.
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional EventService for testing
+        
+    Path Parameters:
+        id: Event ID
+        
+    Example:
+        POST /events/{id}/publish
+    
+    Returns 200 with published 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)
+
+        result = event_service.publish(
+            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/events/handlers/rsvp/app.py

@@ -0,0 +1,83 @@
+# src/geek_cafe_saas_sdk/lambda_handlers/events/rsvp/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 updating RSVP status.
+    
+    Allows users to accept, decline, or mark as tentative.
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional EventAttendeeService for testing
+        
+    Expected body:
+    {
+        "event_id": "evt_123",
+        "rsvp_status": "accepted",  // accepted, declined, tentative
+        "plus_one_count": 1,  // Optional
+        "plus_one_names": ["Jane Doe"],  // Optional
+        "registration_data": {"dietary": "vegetarian", "experience": "beginner"},  // Optional
+        "registration_notes": "Excited to attend!"  // Optional
+    }
+    
+    Returns 200 with updated attendee record
+    """
+    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)
+        tenant_id = LambdaEventUtility.get_authenticated_user_tenant_id(event)
+
+        # Validate required fields
+        event_id = body.get('event_id')
+        rsvp_status = body.get('rsvp_status')
+
+        if not event_id:
+            return error_response("event_id is required", "VALIDATION_ERROR", 400)
+        if not rsvp_status:
+            return error_response("rsvp_status is required", "VALIDATION_ERROR", 400)
+        if rsvp_status not in ['accepted', 'declined', 'tentative']:
+            return error_response(
+                "rsvp_status must be one of: accepted, declined, tentative",
+                "VALIDATION_ERROR",
+                400
+            )
+
+        # Extract optional params
+        kwargs = {}
+        if 'plus_one_count' in body:
+            kwargs['plus_one_count'] = int(body['plus_one_count'])
+        if 'plus_one_names' in body:
+            kwargs['plus_one_names'] = body['plus_one_names']
+        if 'registration_data' in body:
+            kwargs['registration_data'] = body['registration_data']
+        if 'registration_notes' in body:
+            kwargs['registration_notes'] = body['registration_notes']
+
+        result = attendee_service.update_rsvp(
+            event_id=event_id,
+            user_id=user_id,
+            tenant_id=tenant_id,
+            rsvp_status=rsvp_status,
+            **kwargs
+        )
+
+        return service_result_to_response(result)
+
+    except json.JSONDecodeError:
+        return error_response("Invalid JSON format in request body.", "VALIDATION_ERROR", 400)
+    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/update/app.py

@@ -0,0 +1,44 @@
+# src/geek_cafe_saas_sdk/lambda_handlers/events/update/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 updating an existing event.
+    
+    Args:
+        event: API Gateway event
+        context: Lambda context
+        injected_service: Optional EventService for testing
+    """
+    try:
+        event_service = injected_service if injected_service else event_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("Event ID is required in the path.", "VALIDATION_ERROR", 400)
+
+        result = event_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 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/models/__init__.py

@@ -0,0 +1,3 @@
+from .event import Event
+from .event_attendee import EventAttendee
+__all__ = ["Event", "EventAttendee"]