Comment Review

const canReview = client
  .hasPermission(Amity.Permission.ReviewCommunityCommentPermission)
  .community(communityId);

renderResults(canReview);

let canReview = await client.hasPermission(
    .reviewCommunityComment,
    forCommunity: "community-id"
)

showSuccessMessage(canReview)

import com.amity.socialcloud.sdk.model.core.permission.AmityPermission

AmityCoreClient
    .hasPermission(permission = AmityPermission.REVIEW_COMMUNITY_COMMENT)
    .atCommunity(communityId = communityId)
    .check()
    .doOnNext { canReview: Boolean ->
        showSuccessMessage(canReview)
    }
    .subscribe()

import { CommunityRepository } from "@amityco/ts-sdk";

const { data: community } = await CommunityRepository.updateCommunity(
  communityId,
  {
    needApprovalOnCommentCreation: true,
  },
);

renderResults(community.needApprovalOnCommentCreation);

let updateOptions = AmityCommunityUpdateOptions()
updateOptions.setNeedApprovalOnCommentCreation(true)

let community = try await communityRepository.editCommunity(
    withId: "community-id",
    options: updateOptions
)

renderResults(community.isCommentReviewEnabled)

import { CommentRepository } from "@amityco/ts-sdk";

const { data: comment } = await CommentRepository.createComment(
  {
    referenceId: postId,
    referenceType: "post",
    data: { text: "Hello world!" },
  },
  false, // isOptimistic: wait for the server's approval status
);

if (comment.approvalStatus === "pending") {
  renderResults("Awaiting review — only you can see this comment");
} else {
  renderResults(comment);
}

let options = AmityCommentCreateOptions(
    referenceId: "post-id",
    referenceType: .post,
    text: "Hello world!",
    isOptimistic: false // wait for the server's approval status
)

let comment = try await commentRepository.createComment(with: options)

switch comment.approvalStatus {
case .pending:
    showSuccessMessage("Awaiting review — only you can see this comment")
case .approved:
    showSuccessMessage(comment.commentId)
case .rejected:
    showSuccessMessage("declined")
}

import com.amity.socialcloud.sdk.api.social.comment.review.AmityCommentApprovalStatus

when (comment.getApprovalStatus()) {
    AmityCommentApprovalStatus.PENDING ->
        showSuccessMessage("Awaiting review — only you can see this comment")
    AmityCommentApprovalStatus.APPROVED -> showSuccessMessage(comment.getCommentId())
    AmityCommentApprovalStatus.REJECTED -> showSuccessMessage("declined")
}

import { CommentRepository } from "@amityco/ts-sdk";

const unsubscribe = CommentRepository.getCommentReviewQueue(
  {
    communityId,
    startDate: "2026-09-01",
    endDate: "2026-09-30",
    timeZone: "Asia/Bangkok",
    limit: 10,
  },
  ({ data: comments, loading, error, onNextPage, hasNextPage }) => {
    if (loading) return;
    if (error) {
      handleError(error);
      return;
    }

    renderResults(comments);

    if (hasNextPage) {
      onNextPage?.();
    }
  },
);

let options = AmityCommentReviewQueueQueryOptions(
    communityId: "community-id",
    postId: nil,
    startDate: nil,
    endDate: nil,
    timeZone: "Asia/Bangkok",
    pageSize: 10
)

token = commentRepository.getCommentReviewQueue(with: options).observe { collection, error in
    if let error = error {
        handleError(error)
        return
    }

    showSuccessMessage(collection.snapshots.count)
}

import org.joda.time.DateTime

AmitySocialClient.newCommentRepository()
    .getCommentReviewQueue(communityId = communityId)
    .startDate(startDate = DateTime.parse("2026-09-01"))
    .endDate(endDate = DateTime.parse("2026-09-30"))
    .timeZone(timeZone = "Asia/Bangkok")
    .pageSize(pageSize = 10)
    .build()
    .query()
    .subscribe(
        { pagingData -> getPagingData(pagingData) },
        { error -> handleGeneralError(error) }
    )

import { CommentRepository } from "@amityco/ts-sdk";

const { data: approvedComment } =
  await CommentRepository.approveComment(commentId);

const { data: declinedComment } = await CommentRepository.declineComment(
  commentId,
  "Off-topic",
);

renderResults([approvedComment, declinedComment]);

try await commentRepository.approveComment(withId: "comment-id")
try await commentRepository.declineComment(withId: "comment-id", reason: "Off-topic")

showSuccessMessage()

AmitySocialClient.newCommentRepository()
    .approveComment(commentId = commentId)
    .subscribe(
        { showSuccessMessage(commentId) },
        { error -> handleGeneralError(error) }
    )

AmitySocialClient.newCommentRepository()
    .declineComment(commentId = commentId, reason = "Off-topic")
    .subscribe(
        { showSuccessMessage(commentId) },
        { error -> handleGeneralError(error) }
    )