Merge pull request #29 from vintasoftware/revert-28-revert-24-feat/calendar-groups-and-slots-pt4

feat: add CalendarGroup to Public API (mutations and queries)

Author: hugobessa

calendar_integration/graphql.py

@@ -10,6 +10,9 @@
     BlockedTimeRecurrenceException,
     Calendar,
     CalendarEvent,
+    CalendarEventGroupSelection,
+    CalendarGroup,
+    CalendarGroupSlot,
     CalendarWebhookEvent,
     CalendarWebhookSubscription,
     EventAttendance,
@@ -146,6 +149,10 @@ class CalendarEventGraphQLType:
     external_attendees: list[ExternalAttendeeGraphQLType] = strawberry_django.field()
     resources: list[CalendarGraphQLType] = strawberry_django.field()
 
+    # Calendar group linkage (when booked through a CalendarGroup)
+    calendar_group: "CalendarGroupGraphQLType | None" = strawberry_django.field()
+    group_selections: list["CalendarEventGroupSelectionGraphQLType"] = strawberry_django.field()
+
     # Bundle representations - events that represent this primary event in child calendars
     bundle_representations: list["CalendarEventGraphQLType"] = strawberry_django.field()
 
@@ -308,3 +315,65 @@ class WebhookSubscriptionStatusGraphQLType:
     recent_events_count: int  # events in last 24 hours
     failed_events_count: int  # failed events in last 24 hours
     success_rate: float  # percentage of successful events in last 24 hours
+
+
+# ---------------------------------------------------------------------------
+# CalendarGroup types
+# ---------------------------------------------------------------------------
+@strawberry_django.type(CalendarGroupSlot)
+class CalendarGroupSlotGraphQLType:
+    id: strawberry.auto  # noqa: A003
+    name: strawberry.auto
+    description: strawberry.auto
+    order: strawberry.auto
+    required_count: strawberry.auto
+    created: datetime.datetime
+    modified: datetime.datetime
+
+    calendars: list[CalendarGraphQLType] = strawberry_django.field()
+
+
+@strawberry_django.type(CalendarGroup)
+class CalendarGroupGraphQLType:
+    id: strawberry.auto  # noqa: A003
+    name: strawberry.auto
+    description: strawberry.auto
+    created: datetime.datetime
+    modified: datetime.datetime
+
+    slots: list[CalendarGroupSlotGraphQLType] = strawberry_django.field()
+
+
+@strawberry_django.type(CalendarEventGroupSelection)
+class CalendarEventGroupSelectionGraphQLType:
+    id: strawberry.auto  # noqa: A003
+    created: datetime.datetime
+    modified: datetime.datetime
+
+    slot: CalendarGroupSlotGraphQLType = strawberry_django.field()
+    calendar: CalendarGraphQLType = strawberry_django.field()
+
+
+@strawberry.type
+class CalendarGroupSlotAvailabilityGraphQLType:
+    """How many of a slot's pool calendars are available for a given range."""
+
+    slot_id: int
+    available_calendar_ids: list[int]
+
+
+@strawberry.type
+class CalendarGroupRangeAvailabilityGraphQLType:
+    """Per-slot availability for a single range."""
+
+    start_time: datetime.datetime
+    end_time: datetime.datetime
+    slots: list[CalendarGroupSlotAvailabilityGraphQLType]
+
+
+@strawberry.type
+class BookableSlotProposalGraphQLType:
+    """A concrete time window where every slot in a group is satisfied."""
+
+    start_time: datetime.datetime
+    end_time: datetime.datetime

calendar_integration/mutations.py

@@ -1,18 +1,35 @@
 """GraphQL mutations for calendar integration webhook management."""
 
+import datetime
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Annotated, cast
 
 import strawberry
 from dependency_injector.wiring import Provide, inject
 from graphql import GraphQLError
 
-from calendar_integration.graphql import CalendarWebhookSubscriptionGraphQLType
+from calendar_integration.exceptions import CalendarGroupError
+from calendar_integration.graphql import (
+    CalendarEventGraphQLType,
+    CalendarGroupGraphQLType,
+    CalendarWebhookSubscriptionGraphQLType,
+)
+from calendar_integration.models import CalendarGroup
+from calendar_integration.services.dataclasses import (
+    CalendarGroupEventInputData,
+    CalendarGroupInputData,
+    CalendarGroupSlotInputData,
+    CalendarGroupSlotSelectionInputData,
+    EventAttendanceInputData,
+    EventExternalAttendanceInputData,
+    ExternalAttendeeInputData,
+)
 from calendar_integration.services.webhook_analytics_service import WebhookAnalyticsService
 from organizations.models import Organization
 
 
 if TYPE_CHECKING:
+    from calendar_integration.services.calendar_group_service import CalendarGroupService
     from calendar_integration.services.calendar_service import CalendarService
 
 
@@ -220,3 +237,259 @@ def cleanup_webhook_events(
                 deleted_count=0,
                 error_message=f"Failed to cleanup events: {e!s}",
             )
+
+
+# ---------------------------------------------------------------------------
+# CalendarGroup mutations
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class CalendarGroupMutationDependencies:
+    """Dependencies for CalendarGroup mutations."""
+
+    calendar_group_service: "CalendarGroupService"
+    calendar_service: "CalendarService"
+
+
+@inject
+def get_calendar_group_mutation_dependencies(
+    calendar_group_service: Annotated[
+        "CalendarGroupService | None", Provide["calendar_group_service"]
+    ] = None,
+    calendar_service: Annotated["CalendarService | None", Provide["calendar_service"]] = None,
+) -> CalendarGroupMutationDependencies:
+    required = [calendar_group_service, calendar_service]
+    if any(dep is None for dep in required):
+        raise GraphQLError(
+            f"Missing required dependency {', '.join([str(d) for d in required if d is None])}"
+        )
+    return CalendarGroupMutationDependencies(
+        calendar_group_service=cast("CalendarGroupService", calendar_group_service),
+        calendar_service=cast("CalendarService", calendar_service),
+    )
+
+
+@strawberry.input
+class CalendarGroupSlotInput:
+    name: str
+    calendar_ids: list[int]
+    required_count: int = 1
+    description: str = ""
+    order: int = 0
+
+
+@strawberry.input
+class CalendarGroupInput:
+    organization_id: int
+    name: str
+    description: str = ""
+    slots: list[CalendarGroupSlotInput] = strawberry.field(default_factory=list)
+
+
+@strawberry.input
+class UpdateCalendarGroupInput:
+    organization_id: int
+    group_id: int
+    name: str
+    description: str = ""
+    slots: list[CalendarGroupSlotInput] = strawberry.field(default_factory=list)
+
+
+@strawberry.input
+class DeleteCalendarGroupInput:
+    organization_id: int
+    group_id: int
+
+
+@strawberry.input
+class CalendarGroupSlotSelectionInput:
+    slot_id: int
+    calendar_ids: list[int]
+
+
+@strawberry.input
+class ExternalAttendeeInput:
+    email: str
+    name: str = ""
+    id: int | None = None  # noqa: A003
+
+
+@strawberry.input
+class EventExternalAttendanceInput:
+    external_attendee: ExternalAttendeeInput
+
+
+@strawberry.input
+class EventAttendanceInput:
+    user_id: int
+
+
+@strawberry.input
+class CalendarGroupEventInput:
+    organization_id: int
+    group_id: int
+    title: str
+    description: str
+    start_time: datetime.datetime
+    end_time: datetime.datetime
+    timezone: str
+    slot_selections: list[CalendarGroupSlotSelectionInput]
+    attendances: list[EventAttendanceInput] = strawberry.field(default_factory=list)
+    external_attendances: list[EventExternalAttendanceInput] = strawberry.field(
+        default_factory=list
+    )
+
+
+@strawberry.type
+class CalendarGroupResult:
+    success: bool
+    group: CalendarGroupGraphQLType | None = None
+    error_message: str | None = None
+
+
+@strawberry.type
+class DeleteCalendarGroupResult:
+    success: bool
+    error_message: str | None = None
+
+
+@strawberry.type
+class CalendarGroupEventResult:
+    success: bool
+    event: CalendarEventGraphQLType | None = None
+    error_message: str | None = None
+
+
+def _to_slot_input_data(slots: list[CalendarGroupSlotInput]) -> list[CalendarGroupSlotInputData]:
+    return [
+        CalendarGroupSlotInputData(
+            name=s.name,
+            calendar_ids=list(s.calendar_ids),
+            required_count=s.required_count,
+            description=s.description,
+            order=s.order,
+        )
+        for s in slots
+    ]
+
+
+def _load_organization(organization_id: int) -> Organization | None:
+    try:
+        return Organization.objects.get(id=organization_id)
+    except Organization.DoesNotExist:
+        return None
+
+
+@strawberry.type
+class CalendarGroupMutations:
+    """GraphQL mutations for CalendarGroup CRUD and grouped event booking."""
+
+    @strawberry.mutation
+    def create_calendar_group(
+        self,
+        input: CalendarGroupInput,  # noqa: A002
+    ) -> CalendarGroupResult:
+        organization = _load_organization(input.organization_id)
+        if organization is None:
+            return CalendarGroupResult(success=False, error_message="Organization not found")
+        deps = get_calendar_group_mutation_dependencies()
+        deps.calendar_group_service.initialize(organization=organization)
+        try:
+            group = deps.calendar_group_service.create_group(
+                CalendarGroupInputData(
+                    name=input.name,
+                    description=input.description,
+                    slots=_to_slot_input_data(input.slots),
+                )
+            )
+        except CalendarGroupError as e:
+            return CalendarGroupResult(success=False, error_message=str(e))
+        return CalendarGroupResult(success=True, group=group)  # type: ignore[arg-type]
+
+    @strawberry.mutation
+    def update_calendar_group(
+        self,
+        input: UpdateCalendarGroupInput,  # noqa: A002
+    ) -> CalendarGroupResult:
+        organization = _load_organization(input.organization_id)
+        if organization is None:
+            return CalendarGroupResult(success=False, error_message="Organization not found")
+        deps = get_calendar_group_mutation_dependencies()
+        deps.calendar_group_service.initialize(organization=organization)
+        try:
+            group = deps.calendar_group_service.update_group(
+                group_id=input.group_id,
+                data=CalendarGroupInputData(
+                    name=input.name,
+                    description=input.description,
+                    slots=_to_slot_input_data(input.slots),
+                ),
+            )
+        except CalendarGroup.DoesNotExist:
+            return CalendarGroupResult(success=False, error_message="Group not found")
+        except CalendarGroupError as e:
+            return CalendarGroupResult(success=False, error_message=str(e))
+        return CalendarGroupResult(success=True, group=group)  # type: ignore[arg-type]
+
+    @strawberry.mutation
+    def delete_calendar_group(
+        self,
+        input: DeleteCalendarGroupInput,  # noqa: A002
+    ) -> DeleteCalendarGroupResult:
+        organization = _load_organization(input.organization_id)
+        if organization is None:
+            return DeleteCalendarGroupResult(success=False, error_message="Organization not found")
+        deps = get_calendar_group_mutation_dependencies()
+        deps.calendar_group_service.initialize(organization=organization)
+        try:
+            deps.calendar_group_service.delete_group(group_id=input.group_id)
+        except CalendarGroup.DoesNotExist:
+            return DeleteCalendarGroupResult(success=False, error_message="Group not found")
+        except CalendarGroupError as e:
+            return DeleteCalendarGroupResult(success=False, error_message=str(e))
+        return DeleteCalendarGroupResult(success=True)
+
+    @strawberry.mutation
+    def create_calendar_group_event(
+        self,
+        input: CalendarGroupEventInput,  # noqa: A002
+    ) -> CalendarGroupEventResult:
+        organization = _load_organization(input.organization_id)
+        if organization is None:
+            return CalendarGroupEventResult(success=False, error_message="Organization not found")
+        deps = get_calendar_group_mutation_dependencies()
+        deps.calendar_service.initialize_without_provider(organization=organization)
+        deps.calendar_group_service.initialize(organization=organization)
+        data = CalendarGroupEventInputData(
+            title=input.title,
+            description=input.description,
+            start_time=input.start_time,
+            end_time=input.end_time,
+            timezone=input.timezone,
+            group_id=input.group_id,
+            slot_selections=[
+                CalendarGroupSlotSelectionInputData(
+                    slot_id=s.slot_id, calendar_ids=list(s.calendar_ids)
+                )
+                for s in input.slot_selections
+            ],
+            attendances=[EventAttendanceInputData(user_id=a.user_id) for a in input.attendances],
+            external_attendances=[
+                EventExternalAttendanceInputData(
+                    external_attendee=ExternalAttendeeInputData(
+                        email=e.external_attendee.email,
+                        name=e.external_attendee.name,
+                        id=e.external_attendee.id,
+                    )
+                )
+                for e in input.external_attendances
+            ],
+        )
+        try:
+            event = deps.calendar_group_service.create_grouped_event(data)
+        except CalendarGroup.DoesNotExist:
+            return CalendarGroupEventResult(success=False, error_message="Group not found")
+        except CalendarGroupError as e:
+            return CalendarGroupEventResult(success=False, error_message=str(e))
+        return CalendarGroupEventResult(success=True, event=event)  # type: ignore[arg-type]