Content Flagging

import { ContentFlagReasonEnum, PostRepository } from '@amityco/ts-sdk';

const didFlag = await PostRepository.flagPost(
  postId,
  ContentFlagReasonEnum.SpamOrScams,
);

if (didFlag) {
  showSuccessMessage('Post flagged');
}

let repository = AmityPostRepository()

try await repository.flagPost(
    withId: "post-id",
    reason: .spamOrScams
)

val disposable = AmitySocialClient.newPostRepository()
    .flagPost(
        postId = postId,
        reason = AmityContentFlagReason.SpamOrScams,
    )
    .subscribe(
        { showSuccessMessage() },
        { error -> handleGeneralError(error) },
    )

final didFlag = await post.report().flag();

if (didFlag) {
  // Show flagged state.
}

import { CommentRepository, ContentFlagReasonEnum } from '@amityco/ts-sdk';

const didFlag = await CommentRepository.flagComment(
  commentId,
  ContentFlagReasonEnum.HarassmentOrBullying,
);

if (didFlag) {
  showSuccessMessage('Comment flagged');
}

let repository = AmityCommentRepository()

try await repository.flagComment(
    withId: "comment-id",
    reason: .harassmentOrBullying
)

val disposable = AmitySocialClient.newCommentRepository()
    .flagComment(
        commentId = commentId,
        reason = AmityContentFlagReason.HarassmentOrBullying,
    )
    .subscribe(
        { showSuccessMessage() },
        { error -> handleGeneralError(error) },
    )

final didFlag = await comment.report().flag();

if (didFlag) {
  // Show flagged state.
}

import { CommentRepository, PostRepository } from '@amityco/ts-sdk';

const didUnflagPost = await PostRepository.unflagPost(postId);
const didUnflagComment = await CommentRepository.unflagComment(commentId);

let postRepository = AmityPostRepository()
let commentRepository = AmityCommentRepository()

try await postRepository.unflagPost(withId: "post-id")
try await commentRepository.unflagComment(withId: "comment-id")

val postDisposable = AmitySocialClient.newPostRepository()
    .unflagPost(postId = postId)
    .subscribe()

val commentDisposable = AmitySocialClient.newCommentRepository()
    .unflagComment(commentId = commentId)
    .subscribe()

final didUnflagPost = await post.report().unflag();
final didUnflagComment = await comment.report().unflag();

import { CommentRepository, PostRepository } from '@amityco/ts-sdk';

const isPostFlagged = await PostRepository.isPostFlaggedByMe(postId);
const isCommentFlagged = await CommentRepository.isCommentFlaggedByMe(commentId);

let postRepository = AmityPostRepository()
let commentRepository = AmityCommentRepository()

let isPostFlagged = try await postRepository.isFlaggedByMe(withId: "post-id")
let isCommentFlagged = try await commentRepository.isCommentFlaggedByMe(withId: "comment-id")

val loadedPost = post ?: return
val loadedComment = comment ?: return

val isPostFlagged = loadedPost.isFlaggedByMe()
val isCommentFlagged = loadedComment.isFlaggedByMe()

final isPostFlagged = post.isFlaggedByMe;
final isCommentFlagged = comment.isFlaggedByMe;