Skip to main content

Documentation Index

Fetch the complete documentation index at: https://learn.social.plus/llms.txt

Use this file to discover all available pages before exploring further.

​
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 eventObject = AmityEventRepository.shared.getEvent(id: "event-123")

eventObject.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 options = AmityEventQueryOptions(
    originType: .community,
    originId: "community-123",
    sortBy: .startTime,
    orderBy: .ascending
)

let eventsCollection = AmityEventRepository.shared.getEvents(options: options)

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 options = AmityEventQueryOptions(
    originType: .community,
    originId: "community-123",
    status: .scheduled,
    sortBy: .startTime,
    orderBy: .ascending
)

let upcomingEvents = AmityEventRepository.shared.getEvents(options: options)

​
Query User’s Events

Get events where user has RSVP’d: 
let options = AmityEventQueryOptions(
    userId: "user-123",
    onlyAttendee: true,
    sortBy: .startTime,
    orderBy: .ascending
)

let myEvents = AmityEventRepository.shared.getEvents(options: options)

​
Filter by Event Type

Query only virtual or in-person events: 
let options = AmityEventQueryOptions(
    originType: .community,
    originId: "community-123",
    type: .virtual,
    sortBy: .createdAt,
    orderBy: .descending
)

let virtualEvents = AmityEventRepository.shared.getEvents(options: options)

​
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 options = AmityEventUpdateOptions(
            title: "Updated Event Title",
            description: "Updated description with new details",
            location: "New Location, 456 Oak Ave",
            startTime: Date()
        )
        
        let updatedEvent = try await AmityEventRepository.shared.updateEvent(
            id: "event-123",
            options: options
        )
        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 options = AmityEventUpdateOptions(
    coverImageFileId: newImageFile.fileId
)

let updatedEvent = try await AmityEventRepository.shared.updateEvent(
    id: "event-123",
    options: options
)

​
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

import { EventRepository, AmityEventOriginType, AmityEventStatus, AmityEventSortOption, AmityEventOrderOption } from '@amityco/ts-sdk';

// Get and display next 5 upcoming community events
const unsubscribe = EventRepository.getEvents(
    {
        originType: AmityEventOriginType.Community,
        originId: communityId,
        status: AmityEventStatus.Scheduled,
        sortBy: AmityEventSortOption.StartTime,
        orderBy: AmityEventOrderOption.Ascending
    },
    ({ data: events, loading, error }) => {
        if (events) {
            const next5 = events.slice(0, 5);
            displayEvents(next5);
        }
    }
);

​
Event History

import { EventRepository, AmityEventOriginType, AmityEventStatus, AmityEventSortOption, AmityEventOrderOption } from '@amityco/ts-sdk';

// Get past events for archiving
const unsubscribe = EventRepository.getEvents(
    {
        originType: AmityEventOriginType.Community,
        originId: communityId,
        status: AmityEventStatus.Ended,
        sortBy: AmityEventSortOption.StartTime,
        orderBy: AmityEventOrderOption.Descending
    },
    ({ data: events, loading, error }) => {
        if (events) {
            displayEventHistory(events);
        }
    }
);

​
My Events Calendar

import { EventRepository, AmityEventSortOption, AmityEventOrderOption } from '@amityco/ts-sdk';

// Get all user's events (as creator or attendee)
const unsubscribe = EventRepository.getEvents(
    {
        userId: currentUserId,
        onlyAttendee: true,
        sortBy: AmityEventSortOption.StartTime,
        orderBy: AmityEventOrderOption.Ascending
    },
    ({ data: events, loading, error }) => {
        if (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