Get Comment Reaction Data

Retrieve comprehensive reaction data for comments including user reactions, reaction counts, and reaction types. Essential for building engaging social features with detailed interaction analytics and personalized user experiences.

Architecture Overview

User Reactions

Track individual user reactions with myReactions property

All Reactions

Access complete reaction data with reactions property

Reaction Counts

Get total and per-type reaction counts instantly

Real-time Updates

Live reaction data that updates automatically

Key Features

Personal Reaction Tracking: myReactions property for user-specific reaction data
Complete Reaction List: reactions property for all reactions on a comment
Reaction Analytics: reactionsCount for total and categorized counts
Real-time Updates: Live data that updates when reactions change
Multi-platform Support: Consistent API across all platforms

Reaction Data Properties

Property	Type	Description
myReactions	`Array<Reaction>`	Reactions made by the current user
reactions	`Array<Reaction>`	All reactions on the comment
reactionsCount	`Number`	Total count of all reactions
reactionsSummary	`Object`	Count breakdown by reaction type

Implementation Guide

Accessing Reaction Data

// Get comment with reaction data
SocialPlus.shared.getComment(commentId: "comment_123") { result in
    switch result {
    case .success(let comment):
        // User's own reactions
        let myReactions = comment.myReactions
        print("My reactions: \(myReactions)")
        
        // All reactions on the comment
        let allReactions = comment.reactions
        print("Total reactions: \(allReactions.count)")
        
        // Reaction count
        let count = comment.reactionsCount
        print("Reaction count: \(count)")
        
        // Process reactions
        processReactionData(comment)
        
    case .failure(let error):
        handleError(error)
    }
}

Advanced Reaction Analytics

Reaction Statistics

Generate detailed analytics and insights from reaction data.

interface ReactionAnalytics {
    totalReactions: number;
    reactionBreakdown: Record<string, number>;
    topReaction: string;
    userEngagement: {
        hasReacted: boolean;
        reactionTypes: string[];
    };
    trends: {
        recentActivity: number;
        popularityScore: number;
    };
}

function analyzeReactions(comment: Comment): ReactionAnalytics {
    const reactionBreakdown = comment.reactions.reduce((acc, reaction) => {
        acc[reaction.reactionName] = (acc[reaction.reactionName] || 0) + 1;
        return acc;
    }, {} as Record<string, number>);

    const topReaction = Object.entries(reactionBreakdown)
        .sort(([,a], [,b]) => b - a)[0]?.[0] || '';

    return {
        totalReactions: comment.reactionsCount,
        reactionBreakdown,
        topReaction,
        userEngagement: {
            hasReacted: comment.myReactions.length > 0,
            reactionTypes: comment.myReactions.map(r => r.reactionName)
        },
        trends: {
            recentActivity: calculateRecentActivity(comment.reactions),
            popularityScore: calculatePopularityScore(comment)
        }
    };
}

Reaction Leaderboard

Create leaderboards based on reaction data.

struct ReactionLeaderboard {
    let topReactors: [String] // User IDs
    let mostPopularReaction: String
    let engagementScore: Double
}

func generateReactionLeaderboard(_ comment: AmityComment) -> ReactionLeaderboard {
    // Count reactions per user
    let userReactionCounts = Dictionary(grouping: comment.reactions) { $0.userId }
        .mapValues { $0.count }
    
    let topReactors = userReactionCounts
        .sorted { $0.value > $1.value }
        .prefix(10)
        .map { $0.key }
    
    // Find most popular reaction
    let reactionCounts = Dictionary(grouping: comment.reactions) { $0.reactionName }
        .mapValues { $0.count }
    
    let mostPopularReaction = reactionCounts
        .sorted { $0.value > $1.value }
        .first?.key ?? ""
    
    // Calculate engagement score
    let engagementScore = Double(comment.reactionsCount) / max(1.0, Double(comment.viewCount ?? 1))
    
    return ReactionLeaderboard(
        topReactors: Array(topReactors),
        mostPopularReaction: mostPopularReaction,
        engagementScore: engagementScore
    )
}

Real-time Reaction Aggregation

Aggregate reaction data across multiple comments in real-time.

class ReactionAggregator {
    private val reactionData = mutableMapOf<String, ReactionStats>()
    
    data class ReactionStats(
        val totalReactions: Int,
        val reactionBreakdown: Map<String, Int>,
        val userReactions: List<String>
    )
    
    fun aggregateCommentReactions(comments: List<AmityComment>) {
        comments.forEach { comment ->
            val stats = ReactionStats(
                totalReactions = comment.reactionsCount,
                reactionBreakdown = comment.reactions.groupBy { it.reactionName }
                    .mapValues { it.value.size },
                userReactions = comment.myReactions.map { it.reactionName }
            )
            
            reactionData[comment.commentId] = stats
        }
        
        // Notify observers of aggregated data
        notifyReactionDataUpdated()
    }
    
    fun getOverallReactionStats(): ReactionStats {
        val totalReactions = reactionData.values.sumOf { it.totalReactions }
        val overallBreakdown = mutableMapOf<String, Int>()
        val allUserReactions = mutableSetOf<String>()
        
        reactionData.values.forEach { stats ->
            stats.reactionBreakdown.forEach { (type, count) ->
                overallBreakdown[type] = (overallBreakdown[type] ?: 0) + count
            }
            allUserReactions.addAll(stats.userReactions)
        }
        
        return ReactionStats(
            totalReactions = totalReactions,
            reactionBreakdown = overallBreakdown,
            userReactions = allUserReactions.toList()
        )
    }
}

Best Practices

Performance Optimization

Cache reaction data to reduce API calls
Use pagination for large reaction lists
Implement efficient diff algorithms for UI updates
Batch reaction data requests when possible

Real-time Updates

Listen to live object changes for instant updates
Handle reaction additions/removals gracefully
Implement optimistic UI updates for better UX
Use debouncing for rapid reaction changes

User Experience

Show visual feedback for user’s own reactions
Implement smooth animations for reaction changes
Display popular reactions prominently
Provide reaction analytics and insights

Data Management

Normalize reaction data for efficient storage
Implement proper error handling for missing data
Use consistent reaction type naming conventions
Handle edge cases like deleted reactions

Reaction Data Structure

interface Reaction {
    reactionId: string;
    reactionName: string; // "like", "love", "laugh", "angry", etc.
    userId: string;
    createdAt: Date;
    updatedAt: Date;
}

interface Comment {
    commentId: string;
    // ...other comment properties
    myReactions: Reaction[];      // Current user's reactions
    reactions: Reaction[];        // All reactions on the comment
    reactionsCount: number;       // Total reaction count
    reactionsSummary: {           // Count by reaction type
        [reactionType: string]: number;
    };
}

Error Handling

Error Type	Description	Recommended Action
REACTION_NOT_FOUND	Reaction data unavailable	Show fallback UI state
PERMISSION_DENIED	User cannot view reactions	Handle authentication
NETWORK_ERROR	Connection issues	Implement retry logic
RATE_LIMITED	Too many reaction requests	Use exponential backoff
INVALID_REACTION_TYPE	Unknown reaction type	Filter or handle gracefully

Use Cases

Interactive Comment Feed

Build an engaging comment feed with rich reaction displays.

interface CommentFeedItem {
    comment: Comment;
    reactionAnalytics: ReactionAnalytics;
    userInteraction: {
        hasReacted: boolean;
        canReact: boolean;
        reactionTypes: string[];
    };
}

class CommentFeed {
    async loadCommentsWithReactions(postId: string): Promise<CommentFeedItem[]> {
        const comments = await SocialPlus.queryComments(postId);
        
        return comments.map(comment => ({
            comment,
            reactionAnalytics: this.analyzeReactions(comment),
            userInteraction: {
                hasReacted: comment.myReactions.length > 0,
                canReact: this.canUserReact(comment),
                reactionTypes: comment.myReactions.map(r => r.reactionName)
            }
        }));
    }
}

Reaction Dashboard

Create analytics dashboards showing reaction trends and insights.

class ReactionDashboard {
    func generateReactionInsights(for comments: [AmityComment]) -> ReactionInsights {
        let totalReactions = comments.reduce(0) { $0 + $1.reactionsCount }
        let avgReactionsPerComment = Double(totalReactions) / Double(comments.count)
        
        // Most popular reaction types
        let allReactions = comments.flatMap { $0.reactions }
        let reactionTypePopularity = Dictionary(grouping: allReactions) { $0.reactionName }
            .mapValues { $0.count }
            .sorted { $0.value > $1.value }
        
        // User engagement metrics
        let userEngagement = comments.map { comment in
            UserEngagement(
                commentId: comment.commentId,
                reactionCount: comment.reactionsCount,
                userReacted: !comment.myReactions.isEmpty,
                topReaction: reactionTypePopularity.first?.key ?? ""
            )
        }
        
        return ReactionInsights(
            totalReactions: totalReactions,
            averageReactions: avgReactionsPerComment,
            popularReactionTypes: reactionTypePopularity.map { $0.key },
            userEngagement: userEngagement
        )
    }
}

Reaction Notification System

Send notifications based on reaction patterns and thresholds.

class ReactionNotificationManager {
    fun checkReactionMilestones(comment: AmityComment) {
        val reactionCount = comment.reactionsCount
        val milestones = listOf(10, 50, 100, 500, 1000)
        
        milestones.forEach { milestone ->
            if (reactionCount == milestone) {
                sendMilestoneNotification(comment, milestone)
            }
        }
        
        // Check for trending reactions
        val recentReactions = comment.reactions.filter { 
            it.createdAt.isAfter(LocalDateTime.now().minusHours(1))
        }
        
        if (recentReactions.size >= 10) {
            sendTrendingNotification(comment, recentReactions.size)
        }
    }
    
    private fun sendMilestoneNotification(comment: AmityComment, milestone: Int) {
        val notification = NotificationBuilder()
            .setTitle("Your comment is popular!")
            .setMessage("Your comment reached $milestone reactions")
            .setAction("VIEW_COMMENT", comment.commentId)
            .build()
            
        notificationService.send(comment.userId, notification)
    }
}

For advanced real-time features, see Real-time Events.

Reactions - Complete reaction system documentation
Reactions - See the unified reactions guide at /social-plus-sdk/core-concepts/content-handling/reactions
Real-time Events - Live data updates

Powered by

Getting Started

Fundamentals

Social

Chat

Video

Support

Get comment reaction data

Get Comment Reaction Data

Architecture Overview

User Reactions

All Reactions

Reaction Counts

Real-time Updates

Key Features

Reaction Data Properties

Implementation Guide

Accessing Reaction Data

Advanced Reaction Analytics

Best Practices

Performance Optimization

Real-time Updates

User Experience

Data Management

Reaction Data Structure

Error Handling

Use Cases

Powered by

Getting Started

Fundamentals

Social

Chat

Video

Support

​Get Comment Reaction Data

​Architecture Overview

User Reactions

All Reactions

Reaction Counts

Real-time Updates

​Key Features

​Reaction Data Properties

​Implementation Guide

​Accessing Reaction Data

​Advanced Reaction Analytics

​Best Practices

Performance Optimization

Real-time Updates

User Experience

Data Management

​Reaction Data Structure

​Error Handling

​Use Cases

​Related Documentation

Get Comment Reaction Data

Architecture Overview

Key Features

Reaction Data Properties

Implementation Guide

Accessing Reaction Data

Advanced Reaction Analytics

Best Practices

Reaction Data Structure

Error Handling

Use Cases

Related Documentation