Query Reactions

Retrieve comprehensive reaction data to analyze user engagement, build analytics dashboards, and understand community sentiment. The getReactions method provides detailed information about reactions across all content types with powerful filtering and pagination capabilities.

Architecture Overview

Key Features

Comprehensive Queries

Query reactions across posts, stories, comments, and messages

Advanced Filtering

Filter by reaction type, user, time range, and custom criteria

Real-time Updates

Live reaction data synchronization and automatic updates

Analytics Ready

Built-in aggregation and analytics for engagement insights

Query Parameters

referenceType

Type: ReactionReferenceTypeRequired: YesDescription: Specifies the type of content to query reactions for.Valid Values:

POST - Query reactions for posts
STORY - Query reactions for story content
COMMENT - Query reactions for comments
MESSAGE - Query reactions for messages

referenceId

Type: stringRequired: YesDescription: Unique identifier of the content to query reactions for.Example: "post_123", "comment_456"

reactionName

Type: stringRequired: NoDescription: Optional filter to query only specific reaction types. If omitted, returns all reaction types.Example: "like", "love", "angry"

limit

Type: numberRequired: NoDescription: Maximum number of reactions to return. Default varies by platform.Range: 1-100 (platform dependent)

sortOrder

Type: SortOrderRequired: NoDescription: Sort order for returned reactions.Options: NEWEST_FIRST, OLDEST_FIRST

Reaction Data Model

Each reaction query returns rich data including:

Property	Type	Description
reactionId	`string`	Unique reaction identifier
reactionName	`string`	Type of reaction (e.g., “like”, “love”)
reactorId	`string`	ID of the user who reacted
reactorDisplayName	`string`	Display name of the reactor
createdAt	`DateTime`	When the reaction was created
metadata	`object`	Additional reaction metadata

Implementation

iOS
Android
TypeScript
Flutter

import AmitySDK

class ReactionQueryManager {
    private let reactionRepository: AmityReactionRepository
    
    init(client: Client) {
        self.reactionRepository = AmityReactionRepository(client: client)
    }
    
    func queryReactions(
        referenceType: AmityReactionReferenceType,
        referenceId: String,
        reactionName: String? = nil,
        completion: @escaping (Result<[AmityReaction], Error>) -> Void
    ) {
        let query = reactionRepository.getReactions(
            referenceType: referenceType,
            referenceId: referenceId,
            reactionName: reactionName
        )
        
        query.observe { [weak self] collection, error in
            if let error = error {
                completion(.failure(error))
            } else if let reactions = collection?.object {
                completion(.success(reactions))
            }
        }
    }
}

import com.amity.socialcloud.sdk.AmityClient
import com.amity.socialcloud.sdk.model.social.reaction.*

class ReactionQueryManager(private val client: Client) {
    private val reactionRepository = AmityReactionRepository(client)
    
    fun queryReactions(
        referenceType: AmityReactionReferenceType,
        referenceId: String,
        reactionName: String? = null
    ): Flowable<PagingData<AmityReaction>> {
        return reactionRepository.getReactions(
            referenceType = referenceType,
            referenceId = referenceId,
            reactionName = reactionName
        )
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .doOnNext { pagingData ->
            Log.d("ReactionQuery", "Loaded ${pagingData.size} reactions")
        }
    }
    
    fun queryPostReactions(postId: String): Flowable<PagingData<AmityReaction>> {
        return queryReactions(
            referenceType = AmityReactionReferenceType.POST,
            referenceId = postId
        )
    }
    
    fun queryCommentReactions(commentId: String): Flowable<PagingData<AmityReaction>> {
        return queryReactions(
            referenceType = AmityReactionReferenceType.COMMENT,
            referenceId = commentId
        )
    }
}

import { Client } from '@amityco/ts-sdk';

class ReactionQueryManager {
    constructor(private client: Client) {}
    
    async queryReactions(
        referenceType: ReactionReferenceType,
        referenceId: string,
        options?: {
            reactionName?: string;
            limit?: number;
            sortOrder?: 'asc' | 'desc';
        }
    ): Promise<Amity.Reaction[]> {
        try {
            const reactions = await this.client.getReactions({
                referenceType,
                referenceId,
                reactionName: options?.reactionName,
                limit: options?.limit || 50,
                sortOrder: options?.sortOrder || 'desc'
            });
            
            console.log(`Loaded ${reactions.length} reactions for ${referenceType}:${referenceId}`);
            return reactions;
        } catch (error) {
            console.error('Failed to query reactions:', error);
            throw error;
        }
    }
    
    async getReactionSummary(
        referenceType: ReactionReferenceType,
        referenceId: string
    ): Promise<ReactionSummary> {
        const reactions = await this.queryReactions(referenceType, referenceId);
        
        const summary = {
            totalReactions: reactions.length,
            reactionCounts: this.groupReactionsByType(reactions),
            topReactors: this.getTopReactors(reactions),
            myReactions: this.getMyReactions(reactions)
        };
        
        return summary;
    }
    
    private groupReactionsByType(reactions: Amity.Reaction[]): Record<string, number> {
        return reactions.reduce((acc, reaction) => {
            acc[reaction.reactionName] = (acc[reaction.reactionName] || 0) + 1;
            return acc;
        }, {} as Record<string, number>);
    }
    
    private getTopReactors(reactions: Amity.Reaction[], limit: number = 5): Reactor[] {
        const reactorCounts = reactions.reduce((acc, reaction) => {
            const reactor = acc.find(r => r.userId === reaction.reactorId);
            if (reactor) {
                reactor.reactionCount++;
            } else {
                acc.push({
                    userId: reaction.reactorId,
                    displayName: reaction.reactorDisplayName,
                    reactionCount: 1
                });
            }
            return acc;
        }, [] as Reactor[]);
        
        return reactorCounts
            .sort((a, b) => b.reactionCount - a.reactionCount)
            .slice(0, limit);
    }
    
    private getMyReactions(reactions: Amity.Reaction[]): string[] {
        const currentUserId = this.client.getCurrentUser()?.userId;
        return reactions
            .filter(reaction => reaction.reactorId === currentUserId)
            .map(reaction => reaction.reactionName);
    }
}

interface ReactionSummary {
    totalReactions: number;
    reactionCounts: Record<string, number>;
    topReactors: Reactor[];
    myReactions: string[];
}

interface Reactor {
    userId: string;
    displayName: string;
    reactionCount: number;
}

import 'package:amity_sdk/amity_sdk.dart';

class ReactionQueryManager {
    
    Future<List<AmityReaction>> queryReactions({
        required String referenceType,
        required String referenceId,
        String? reactionName,
        int? limit,
    }) async {
        try {
            // Query reactions based on reference type
            switch (referenceType.toLowerCase()) {
                case 'post':
                    return await _queryPostReactions(referenceId, reactionName, limit);
                case 'comment':
                    return await _queryCommentReactions(referenceId, reactionName, limit);
                case 'story':
                    return await _queryStoryReactions(referenceId, reactionName, limit);
                case 'message':
                    return await _queryMessageReactions(referenceId, reactionName, limit);
                default:
                    throw ArgumentError('Unsupported reference type: $referenceType');
            }
        } catch (error) {
            print('Failed to query reactions: $error');
            rethrow;
        }
    }
    
    Future<List<AmityReaction>> _queryPostReactions(
        String postId, 
        String? reactionName, 
        int? limit
    ) async {
        final query = AmityReactionRepository().getReactions(
            referenceType: AmityReactionReferenceType.POST,
            referenceId: postId,
            reactionName: reactionName,
        );
        
        // Apply limit if specified
        if (limit != null) {
            query.limit(limit);
        }
        
        final snapshot = await query.get();
        return snapshot.data;
    }
    
    Future<List<AmityReaction>> _queryCommentReactions(
        String commentId, 
        String? reactionName, 
        int? limit
    ) async {
        final query = AmityReactionRepository().getReactions(
            referenceType: AmityReactionReferenceType.COMMENT,
            referenceId: commentId,
            reactionName: reactionName,
        );
        
        if (limit != null) {
            query.limit(limit);
        }
        
        final snapshot = await query.get();
        return snapshot.data;
    }
    
    Future<ReactionSummary> getReactionSummary({
        required String referenceType,
        required String referenceId,
    }) async {
        final reactions = await queryReactions(
            referenceType: referenceType,
            referenceId: referenceId,
        );
        
        return _generateSummary(reactions);
    }
    
    ReactionSummary _generateSummary(List<AmityReaction> reactions) {
        final reactionCounts = <String, int>{};
        final uniqueReactors = <String>{};
        
        for (final reaction in reactions) {
            // Count reactions by type
            reactionCounts[reaction.reactionName] = 
                (reactionCounts[reaction.reactionName] ?? 0) + 1;
            
            // Track unique reactors
            uniqueReactors.add(reaction.reactorId);
        }
        
        // Find most popular reaction
        String? mostPopular;
        int maxCount = 0;
        reactionCounts.forEach((reaction, count) {
            if (count > maxCount) {
                maxCount = count;
                mostPopular = reaction;
            }
        });
        
        return ReactionSummary(
            totalReactions: reactions.length,
            uniqueReactors: uniqueReactors.length,
            reactionBreakdown: reactionCounts,
            mostPopularReaction: mostPopular,
        );
    }
}

class ReactionSummary {
    final int totalReactions;
    final int uniqueReactors;
    final Map<String, int> reactionBreakdown;
    final String? mostPopularReaction;
    
    const ReactionSummary({
        required this.totalReactions,
        required this.uniqueReactors,
        required this.reactionBreakdown,
        this.mostPopularReaction,
    });
    
    @override
    String toString() {
        return 'ReactionSummary(total: $totalReactions, unique: $uniqueReactors, '
               'popular: $mostPopularReaction, breakdown: $reactionBreakdown)';
    }
}

Reaction Aggregates

Each content item provides built-in reaction aggregate data:

reactionsCount

Type: numberDescription: Total number of reactions on the content, regardless of type.Use Case: Display overall engagement metrics and popularity indicators.

myReactions

Type: string[]Description: Array of reaction names that the current user has added to the content.Use Case: Highlight user’s own reactions in the UI and enable toggling.

reactions

Type: Record<string, number>Description: Map showing count of each reaction type on the content.Example:

{
  "like": 15,
  "love": 8,
  "wow": 3,
  "angry": 1
}

Live Reaction Updates

Real-time Subscriptions
Event-based Updates
Polling Strategy

Subscribe to live reaction updates for real-time UI synchronization:

// TypeScript example for live reaction updates
const subscription = client.subscribeToReactions({
    referenceType: 'POST',
    referenceId: 'post_123'
}, (updatedReactions) => {
    // Update UI with new reaction data
    updateReactionDisplay(updatedReactions);
});

// Clean up subscription
subscription.unsubscribe();

Listen for reaction events and update data accordingly:

// iOS example for reaction events
NotificationCenter.default.addObserver(
    forName: .reactionAdded,
    object: nil,
    queue: .main
) { notification in
    if let reaction = notification.object as? AmityReaction {
        handleNewReaction(reaction)
    }
}

Implement periodic updates for less real-time scenarios:

// Android example for periodic updates
class ReactionPollingManager {
    private val updateInterval = 30_000L // 30 seconds
    
    fun startPolling(referenceType: AmityReactionReferenceType, referenceId: String) {
        Observable.interval(updateInterval, TimeUnit.MILLISECONDS)
            .flatMap { queryReactions(referenceType, referenceId) }
            .subscribe { reactions ->
                updateReactionDisplay(reactions)
            }
    }
}

Analytics & Insights

Engagement Metrics

Track reaction rates, popular content, and user engagement patterns

Sentiment Analysis

Analyze reaction types to understand community sentiment and mood

User Behavior

Identify most active reactors and engagement leaders

Content Performance

Measure which content types and topics generate most reactions

Engagement Analytics Example

interface EngagementAnalytics {
  totalReactions: number;
  uniqueReactors: number;
  averageReactionsPerUser: number;
  reactionDistribution: Record<string, number>;
  engagementRate: number;
  timeBasedMetrics: {
    peakHours: number[];
    dailyAverages: Record<string, number>;
  };
}

const analytics = generateEngagementAnalytics(reactions);

Best Practices

Performance Optimization

Implement pagination for large reaction lists
Use reaction aggregates instead of full queries when possible
Cache frequently accessed reaction data
Implement efficient filtering and sorting on the client side

User Experience

Show loading states during reaction queries
Implement optimistic updates for better responsiveness
Display reaction summaries before detailed lists
Provide filtering options for different reaction types

Data Management

Regularly refresh reaction data for accuracy
Handle real-time updates gracefully
Implement proper error handling and retry logic
Use appropriate data structures for reaction storage

Analytics Integration

Track reaction query patterns for insights
Monitor popular content and engagement trends
Analyze reaction velocity and patterns
Implement A/B testing for reaction features

Error Handling

Common Error Scenarios

Network Failures: Handle offline scenarios and poor connectivity
Invalid References: Non-existent content or invalid IDs
Rate Limiting: Too many queries in a short period
Permission Errors: Insufficient access to reaction data

Error Recovery Strategies

Implement exponential backoff for failed queries
Cache successful results for offline scenarios
Provide fallback UI when queries fail
Show appropriate error messages based on error type

Documentation Index

​Query Reactions

​Architecture Overview

​Key Features

Comprehensive Queries

Advanced Filtering

Real-time Updates

Analytics Ready

​Query Parameters

​Reaction Data Model

​Implementation

​Reaction Aggregates

​Live Reaction Updates

​Analytics & Insights