Skip to main content

​
Manage Events

Manage event lifecycle including updates, deletions, and queries to discover upcoming and past events across communities and user timelines.

​
Querying Events

​
Get Event by ID

Retrieve a single event using its ID with real-time updates: 
let eventLiveObject = AmityEventRepository.shared.getEvent(id: "event-123")

eventLiveObject.observe { event in
    print("Event: \(event.title)")
    print("Status: \(event.status)")
    print("RSVP Count: \(event.rsvpCount)")
}

​
Query Events by Community

Get all events for a specific community: 
let eventsCollection = AmityEventRepository.shared.getEvents(
    builder: AmityEventQueryBuilder()
        .setOriginType(.community)
        .setOriginId("community-123")
        .setSortBy(.startTime)
        .setOrderBy(.ascending)
)

eventsCollection.observe { events in
    events.forEach { event in
        print("Event: \(event.title) at \(event.startTime)")
    }
}

​
Query Upcoming Events

Filter events by status to get upcoming scheduled events: 
let upcomingEvents = AmityEventRepository.shared.getEvents(
    builder: AmityEventQueryBuilder()
        .setOriginType(.community)
        .setOriginId("community-123")
        .setStatus(.scheduled)
        .setSortBy(.startTime)
        .setOrderBy(.ascending)
)

​
Query User’s Events

Get events where user has RSVP’d: 
let myEvents = AmityEventRepository.shared.getEvents(
    builder: AmityEventQueryBuilder()
        .setUserId("user-123")
        .setOnlyAttendee(true)
        .setSortBy(.startTime)
        .setOrderBy(.ascending)
)

​
Filter by Event Type

Query only virtual or in-person events: 
let virtualEvents = AmityEventRepository.shared.getEvents(
    builder: AmityEventQueryBuilder()
        .setOriginType(.community)
        .setOriginId("community-123")
        .setType(.virtual)
        .setSortBy(.createdAt)
        .setOrderBy(.descending)
)

​
Query Parameters

Type: AmityEventOriginType
Required: No
Values: community | userFilter events by their origin type.
Type: string
Required: No (required if originType is set)Filter events by specific community or user ID.
Type: AmityEventStatus
Required: No
Values: scheduled | live | ended | cancelledFilter events by their current status.
Type: AmityEventType
Required: No
Values: virtual | in_personFilter events by format type.
Type: string
Required: NoFilter events by creator or attendee.
Type: boolean
Required: No
Default: falseWhen true and userId is set, returns only events where user has RSVP’d.
Type: AmityEventSortOption
Required: No
Values: startTime | createdAt
Default: startTimeSort events by start time or creation date.
Type: AmityEventOrderOption
Required: No
Values: ascending | descending
Default: ascendingSort order direction.

​
Updating Events

Update event details (creator or moderator only): 
Task { @MainActor in
    do {
        let updatedEvent = try await AmityEventRepository.shared.updateEvent(
            id: "event-123",
            options: AmityEventUpdateOptions()
                .setTitle("Updated Event Title")
                .setDescription("Updated description with new details")
                .setLocation("New Location, 456 Oak Ave")
                .setStartTime("2025-04-20T15:00:00Z")
        )
        print("Event updated: \(updatedEvent.title)")
    } catch {
        print("Failed to update event: \(error)")
    }
}

​
Update Event Cover Image

// Upload new image
let newImageData = UIImage(named: "new-cover")?.jpegData(compressionQuality: 0.8)
let newImageFile = try await AmityFileRepository.shared.uploadImage(newImageData!)

// Update event with new cover
let updatedEvent = try await AmityEventRepository.shared.updateEvent(
    id: "event-123",
    options: AmityEventUpdateOptions()
        .setCoverImageFileId(newImageFile.fileId)
)

​
Deleting Events

Delete an event (creator or moderator only): 
Task { @MainActor in
    do {
        try await AmityEventRepository.shared.deleteEvent(id: "event-123")
        print("Event deleted successfully")
    } catch {
        print("Failed to delete event: \(error)")
    }
}
Permanent Action: Deleting an event is permanent and cannot be undone. All associated RSVPs and discussions will also be affected.

​
Permission Checks

Before updating or deleting events: 
// Check if user can manage community events
let canManage = await AmityClient.shared.hasPermission(
    .manageCommunityEvents,
    communityId: event.originId
)

// Check if user can delete any event
let canDelete = await AmityClient.shared.hasPermission(
    .deleteEvent
)

// Check if user is event creator
let isCreator = event.userId == AmityClient.shared.currentUserId

​
Common Patterns

​
Display Upcoming Events

// Get and display next 5 upcoming community events
const upcomingEvents = eventRepository.getEvents({
    originType: AmityEventOriginType.COMMUNITY,
    originId: communityId,
    status: AmityEventStatus.SCHEDULED,
    sortBy: AmityEventSortOption.START_TIME,
    orderBy: AmityEventOrderOption.ASCENDING
});

upcomingEvents.on("dataUpdated", (events) => {
    const next5 = events.slice(0, 5);
    displayEvents(next5);
});

​
Event History

// Get past events for archiving
const pastEvents = eventRepository.getEvents({
    originType: AmityEventOriginType.COMMUNITY,
    originId: communityId,
    status: AmityEventStatus.ENDED,
    sortBy: AmityEventSortOption.START_TIME,
    orderBy: AmityEventOrderOption.DESCENDING
});

pastEvents.on("dataUpdated", (events) => {
    displayEventHistory(events);
});

​
My Events Calendar

// Get all user's events (as creator or attendee)
const myEvents = eventRepository.getEvents({
    userId: currentUserId,
    onlyAttendee: true,
    sortBy: AmityEventSortOption.START_TIME,
    orderBy: AmityEventOrderOption.ASCENDING
});

myEvents.on("dataUpdated", (events) => {
    populateCalendar(events);
});

​
Best Practices

Optimize event queries for performance:
  • Use specific filters to reduce result set
  • Implement pagination for large collections
  • Cache frequently accessed events
  • Unsubscribe from live collections when not needed
Handle event updates gracefully:
  • Validate changes before submission
  • Preserve unchanged fields
  • Notify attendees of significant changes
  • Handle concurrent edits appropriately
Always check permissions before actions:
if (isCreator || canManage) {
    // Show edit/delete options
}

​
Error Handling

do {
    try await AmityEventRepository.shared.deleteEvent(id: eventId)
} catch AmityError.permissionDenied {
    showError("You don't have permission to delete this event")
} catch AmityError.notFound {
    showError("Event not found")
} catch {
    showError("Failed to delete event: \(error.localizedDescription)")
}

Create Events

Schedule new events

Event RSVP

Manage event responses

Events Overview

Learn about event concepts