Comments
Use Comments to allow your audience to add their comments and reply to others on any feature or topic in your experience.
Comments Service
The comments service enables app developers to add comments to anything in their experience. By creating comment boards and associating those boards with content in your app, you enable users to add comments and replies to that content. Some use cases for the comments service include:
- Comments on blog posts
- Reactions to videos
- Fan discussion of teams and players
Glossary
- Board: resource that represents a topic to comment on. Clients associate boards to their blog posts, videos, teams, individual sports matches, and so on.
- Comment: resource that represents a post made to a board. Comments have IDs, authors, contents, and timestamps. Comments can be posted directly to a board, or in response to another comment. Comments that respond to other comments are called replies.
- Reply: a comment posted in direct response to another comment.
Working with Comment Boards
Comment Board related APIs can be accessed with the help of the CommentBoardClient
. The CommentBoardClient
is a part of the EngagementSDK
and can be accessed using an instance of the same.
boards = liveLikeEngagementSDK.commentBoard()
let sdk: EngagementSDK
sdk.commentBoards
import LiveLike from "@livelike/engagementsdk";
Creating a Comment Board
Users can create a Comment Board using the createCommentBoard method which is a part of the CommentBoardClient for Android and IOS.
boards.createCommentBoard(
CreateCommentBoardRequestOptions(
customId = "",
title = "",
allowComments = true,
replyDepth = 1,
customData = "",
description = ""
),
object: LiveLikeCallback <
CommentBoard >
() {
override fun onResponse(
result: CommentBoard ? ,
error : String ?
) {
...
}
}
)
let sdk: EngagementSDK
let createBoardOptions = CreateCommentBoardRequestOptions(
title: "",
customID: "",
allowComments: true,
repliesDepth: 1
)
sdk.commentBoards.createCommentBoard(
createCommentBoardOptions: createBoardOptions
) { result in
switch result {
case .success(let commentBoard):
// handle success
case .failure(let error):
// handle failure
}
}
LiveLike.createCommentBoard({
title: 'sd',
customId: 'postid1',
repliesDepth: 2,
allowComments: true,
description: 'desc',
customData: 'abc',
}).then((commentBoard) => console.log(commentBoard));
Updating a Comment Board
Users can update a Comment Board using the updateCommentBoard method which is a part of the CommentBoardClient for Android and IOS.
boards.updateCommentBoard(
UpdateCommentBoardRequestOptions(
commentBoardId = "",
customId = "",
title = "",
allowComment = true,
replyDepth = 1,
customData = "",
val description = ""
),
object: LiveLikeCallback < CommentBoard > () {
override fun onResponse(
result: CommentBoard ? ,
error : String ?
) {
...
}
}
)
let sdk: EngagementSDK
let updateBoardOptions = UpdateCommentBoardRequestOptions(
title: "",
customID: "",
allowComments: true,
repliesDepth: 1
)
sdk.commentBoards.updateCommentBoard(
commentBoardID: "",
updateCommentBoardOptions: updateBoardOptions
) { result in
switch result {
case .success(let commentBoard):
// handle success
case .failure(let error):
// handle failure
}
}
LiveLike.updateCommentBoard({
commentBoardId: '5f5fea99-569b-42f3-875d-5b3943b64ba0',
title: 'title',
customId: 'postID431',
repliesDepth: 1,
allowComments: true,
description: 'abc',
customData: 'custom data',
}).then((commentBoard) => console.log(commentBoard));
Getting a list of Comments Boards
boards.getCommentBoards(
LiveLikePagination.FIRST,
object : LiveLikeCallback<List<CommentBoard>>() {
override fun onResponse(result: List<CommentBoard>?, error: String?) {
}
}
)
let sdk: EngagementSDK
sdk.commentBoards.getCommentBoards(
page: .first
) { result in
switch result {
case .success(let commentBoards):
// handle success
case .failure(let error):
// handle failure
}
}
LiveLike.getCommentBoards().then(({results}) => console.log(results))
Deleting a Comment Board
boards.deleteCommentBoards(
DeleteCommentBoardRequestOptions(commentBoardId = ""),
object : LiveLikeCallback<LiveLikeEmptyResponse>() {
override fun onResponse(result: LiveLikeEmptyResponse?, error: String?) {
}
}
)
let sdk: EngagementSDK
sdk.commentBoards.deleteCommentBoard(
commentBoardID: ""
) { result in
switch result {
case .success:
// handle succes
case .failure(let error):
// handle failure
}
}
LiveLike.deleteCommentBoard({
commentBoardId: 'aa7e03fc-01f0-4a98-a2e0-3fed689632d7',
}).then(({ results }) => console.log(results));
Working with Comments
Comments related APIs can be accessed with the help of the CommentClient. The CommentClient is linked to a Comment Board and can be initialized using the createCommentClient method in the EngagementSDK. It requires the commentBoardID as a parameter which gives the user access to the following APIs after initialization.
For WebSDK, we do not need any commentClient all the APIs are available under LiveLike
private var activeCommentSession: LiveLikeCommentClient? = null
activeCommentSession = activeCommentBoard.id ? .let {
commentBoardId - >
liveLikeEngagementSDK.comment(
commentBoardId
)
}
let sdk: EngagementSDK
sdk.createCommentClient(
for: ""
) { result in
switch result {
case .success(let commentClient):
// store `commentClient` for later usage
case .failure(let error):
//handle failure
}
}
import LiveLike from "@livelike/engagementsdk";
Creating a Comment
activeCommentSession.addComment(
AddCommentRequestOptions(
text = "",
customData = ""
), object: LiveLikeCallback < Comment > () {
override fun onResponse(result: Comment ? , error : String ? ) {
...
}
}
)
let commentClient: CommentClient
commentClient.addComment(
text: ""
) { result in
switch result {
case .success(let comment):
// handle success
case .failure(let error):
// handle failure
}
}
LiveLike.addComment({
text: '<Your text comment>',
customData:'<Your custom data to send with reply comment>',
commentBoardId:'<Your comment board Id>'
}).then(comment => console.log(comment));
Reply to a Comment
activeCommentSession.addCommentReply(
AddCommentReplyRequestOptions(
parentCommentId = "",
text = "",
customData = ""
), object: LiveLikeCallback < Comment > () {
override fun onResponse(result: Comment ? , error : String ? ) {
...
}
}
)
let commentClient: CommentClient
commentClient.addCommentReply(
parentCommentID: "",
text: ""
) { result in
switch result {
case .success(let comment):
// handle success
case .failure(let error):
// handle failure
}
}
LiveLike.addCommentReply({
text: '<Your text comment>',
customData: '<Your custom data to send with reply comment>',
commentBoardId: '<Your comment board Id>',
parentCommentId: '<Your parent comment Id>'
}).then(comment => console.log(comment));
Get Comment
activeCommentSession.getComment(
GetCommentRequestOptions(binding.etCreateComment.text.toString().trim()),
object : LiveLikeCallback<Comment>() {
override fun onResponse(result: Comment?, error: String?) {
binding.tvComment.text = result?.text
activeComment = result
}
}
)
LiveLike.getComment({
commentBoardId: "<comment-board-id>",
commentId:"<comment-id>"})
.then(({results}) => console.log(results))
Get a list of Top Level Comments
Integrator can filter top level comments with filters like:
NEWEST ,OLDEST,
OLDEST_REPLIES(Comments with oldest reply),
NEWEST_REPLIES(Comments with newest reply),
repliedSince(Get comments with reply since timestamp ),
repliedUntil (Get comments with reply until timestamp ),
isReported (Get reported comments ),
activeCommentSession.getComments(
GetCommentsRequestOptions(
CommentSortingOptions.NEWEST,
CommentSortingOptions.NEWEST_REPLIES,
repliedSince=""),
LiveLikePagination.FIRST,
object: LiveLikeCallback < List < Comment >> () {
override fun onResponse(
result: List < Comment > ? ,
error : String ?
) {
...
}
}
)
let commentClient: CommentClient
commentClient.getCommentsList(
page: .first
) { result in
switch result {
case .success(let comments):
// handle success
case .failure(let error):
// handle failure
}
}
LiveLike.getComments({
commentBoardId:'<comment-board-id>',
sorting:'<Your comment sorting enum value>',
repliedSince:'<2023-12-19T15:28:46.493Z>',
repliedUntil:'<2023-12-19T15:28:46.493Z>',
isReported: true,
}).then(commentBoard => console.log(commentBoard));
Get a list of Replies to a Comment
activeCommentSession.getCommentReplies(
GetCommentRepliesRequestOptions(commentId = “”,
CommentSortingOptions.NEWEST),
LiveLikePagination.FIRST,
object: LiveLikeCallback < List < Comment >> () {
override fun onResponse(
result: List < Comment > ? ,
error : String ?
) {
...
}
}
)
let commentClient: CommentClient
let options = GetCommentRepliesListRequestOptions(
commentBoardID: "",
parentCommentID: ""
)
commentClient.getCommentRepliesList(
options: options,
page: .first
) { result in
switch result {
case .success(let comments):
// handle success
case .failure(let error):
// handle failure
}
}
LiveLike.getCommentReplies({
commentBoardId:'<comment-board-id>',
commentId:'<comment-id>',
sorting: LiveLike.CommentSort.NEWEST,
}).then(comments => console.log(comments));
Edit a Comment
activeCommentSession.editComment(
UpdateCommentRequestOptions(
commentId = "", text = ""
),
object: LiveLikeCallback < Comment > () {
override fun onResponse(
result: Comment ? ,
error : String ?
) {
...
}
}
)
let commentClient: CommentClient
commentClient.editComment(
commentID: "",
text: ""
) { result in
switch result {
case .success(let comment):
// handle success
case .failure(let error):
// handle failure
}
}
LiveLike.editComment({
commentBoardId: "<comment-board-id>",
commentId: "<comment-id>",
text: '<Your text comment>',
customData: '<Your custom data to send with reply comment>',
}).then(comment => console.log(comment))
Delete a Comment
activeCommentSession.deleteComment(
DeleteCommentRequestOptions(
commentId = ""
),
object: LiveLikeCallback < LiveLikeEmptyResponse > () {
override fun onResponse(
result: LiveLikeEmptyResponse ? ,
error : String ?
) {
...
}
}
)
let commentClient: CommentClient
commentClient.deleteComment(
commentID: ""
) { result in
switch result {
case .success(let comment):
// handle success
case .failure(let error):
// handle failure
}
}
LiveLike.deleteComment({
commentBoardId: "<comment-board-id>",
commentId: "<comment-id>"
})
Comment Board Moderation
Create Comment Board Ban
Moderators can ban a profile to restrict its access in a comment board but the banned profile does not lose access to moderation tools if they have that.
- profile_id: required,
- comment_board_id: optional, if not provided, the profile will be banned from all the comment boards in the application, provided the moderator has sufficient permissions to do that.
- description: optional, this field can be used to provide additional information about a ban or the reason for banning a user.
boards.createCommentBoardBan(
CreateCommentBanRequestOptions(
binding.profileId.text.toString().trim(),
binding.commentBoardId.text.toString().trim().let(::nullOverEmpty),
binding.description.text.toString().trim().let(::nullOverEmpty)
),
object : LiveLikeCallback<CommentBoardBanDetails>() {
override fun onResponse(result: CommentBoardBanDetails?, error: String?) {
showToast(error, "comment board ban")
showToast(result?.toString(), "comment board ban")
}
}
)
LiveLike.createCommentBoardBan({
profileId: '<profile_id>',
commentBoardId: '<comment_board_id>',
description: '<Reason for banning>',
}).then((commentBoardBan) => console.log(commentBoardBan));
let createCommentBoardBanOptions = CommentBoardBanRequestOptions(
commentBoardID: commentBoardID,
description: description
)
sdk.commentBoards.createCommentBoardBan(
profileID: profileID,
options: createCommentBoardBanOptions
) { result in
switch result {
case .success(let commentBoardBan):
//Success block
case .failure(let error):
//Failure Block
}
}
List Comment Board Bans
Get a list of comment board bans in an Application. Each comment board ban resource represents restrictive access to the comment board for a given user profile.
- As a producer or privileged user I can see all the comment-board-ban-profile from the application
- As a moderator, I can get a list of all comment-board-ban-profile for the comment boards where I am a moderator
- As a normal profile, I will get a list of comment-board-ban-profile for myself only.
boards.getCommentBoardBans(
ListCommentBoardBanRequestOptions(
binding.banProfileId.text.toString().trim().let(::nullOverEmpty),
binding.banCommentBoardId.text.toString().trim().let(::nullOverEmpty)
),
LiveLikePagination.FIRST,
object : LiveLikeCallback<List<CommentBoardBanDetails>>() {
override fun onResponse(result: List<CommentBoardBanDetails>?, error: String?) {
showToast(error, "comment board ban")
showToast(result?.toString(), "comment board ban list")
}
}
)
LiveLike.getCommentBoardBans({
profileId: '<profile_id>',
commentBoardId: '<comment_board_id>',
}).then((paginatedResponse) => console.log(paginatedResponse));
let options = GetCommentBoardBansListRequestOptions(
profileID: profileID,
commentBoardID: commentBoardID
)
sdk.commentBoards.getCommentBoardBans(
page: .first,
options: options
) { result in
switch result {
case .success(let commentBoardBans):
//Success Block
case .failure(let error):
//Failure Block
}
}
Get Comment Board Ban
Get Ban details by providing a ban id.
boards.getCommentBoardBan(
GetBanDetailsRequestOptions(binding.commentBoardBanId.text.toString().trim()),
object : LiveLikeCallback<CommentBoardBanDetails>() {
override fun onResponse(result: CommentBoardBanDetails?, error: String?) {
showToast(error, "ban detail not found!")
showToast(result?.toString(), "comment board ban detail")
}
}
)
LiveLike.getCommentBoardBan({
commentBoardBanId: '<comment_board_ban_id>',
}).then((commentBoardBan) => console.log(commentBoardBan));
sdk.commentBoards.getCommentBoardBanDetails(commentBoardBanID: banDetailsID) { result in
switch result {
case .success(let commentBoardBan):
//Success Block
case .failure(let error):
//Failure Block
}
}
Delete Comment Board Ban
Remove ban by providing a ban id.
A profile with moderation tools can unban himself if its get banned by other moderation access profile.
boards.deleteCommentBoardBan(
DeleteCommentBanRequestOption(binding.commentBoardBanId.text.toString().trim()),
object : LiveLikeCallback<LiveLikeEmptyResponse>() {
override fun onResponse(result: LiveLikeEmptyResponse?, error: String?) {
error?.let { showToast(error, "delete comment board ban") }
result?.let { showToast("Deleted:", "comment board ban deleted") }
}
}
)
LiveLike.deleteCommentBoardBan({
commentBoardBanId: '<comment_board_ban_id>',
})
sdk.commentBoards.deleteCommentBoardBan(commentBoardBanID: banDetailsID) { result in
switch result {
case .success:
//Success Block
case .failure(let error):
//Failure Block
}
}
Create Comment Report
Users can report comments to moderators.
activeCommentSession?.createCommentReport(
CreateCommentReportRequestOptions(
activeComment?.id!!,
description = "",
),
object : LiveLikeCallback<CommentReport>() {
override fun onResponse(result: CommentReport?, error: String?) {
result?.let {
showToast(result?.toString(), result?.reportStatus!!)
activeCommentReport = result
}
error?.let { showToast(error, "Error!!") }
}
}
)
commentClient.createCommentReport(
commentID: commentID,
options: CreateCommentReportRequestOptions(
description: descriptiontext
)
) { result in
switch result {
case .success(let commentReport):
//Success Block
case .failure(let error):
//Failure Block
}
}
LiveLike.createCommentReport({
commentId: '<comment_id>',
description: '<Reason for reporting>',
}).then((commentReport) => console.log(commentReport));
Get Comment Report
activeCommentSession?.getCommentReportDetail(
GetCommentReportDetailRequestOptions(commentReportId = activeCommentReport?.id!!),
object : LiveLikeCallback<CommentReport>() {
override fun onResponse(result: CommentReport?, error: String?) {
result?.let { showToast(result.toString(), "Current Report") }
error?.let { showToast(error, "Error!!") }
}
}
)
client.getCommentReportDetails(
commentReportID: commentReportID
) { result in
switch result {
case .success(let commentReport):
//Success Block
case .failure(let error):
//Failure Block
}
}
LiveLike.getCommentReport({
commentReportId: '<comment_report_id>',
}).then((commentReport) => console.log(commentReport));
Get Comment Report List
activeCommentSession?.getCommentReports(
GetCommentReportsRequestOptions(
commentId = activeComment?.id!!,
ReportStatusOptions.PENDING,
commentBoardId = ""
),
LiveLikePagination.FIRST,
object : LiveLikeCallback<List<CommentReport>>() {
override fun onResponse(result: List<CommentReport>?, error: String?) {
result?.let { showToast(result.toString(), result?.size.toString()) }
error?.let { showToast(error, "Error!!") }
}
}
)
commentClient.getCommentReports(
page: .first,
options: .init(
commentBoardID: commentBoardID,
commentID: nil,
reportStatus: .dismissed
)
) { result in
switch result {
case .success(let commentReports):
//Success Block
case .failure(let error):
//Failure Block
}
}
LiveLike.getCommentReports({
commentBoardId: '<comment_board_id>',
commentId: '<comment_id>',
reportStatus: LiveLike.CommentReportStatus.PENDING,
}).then((paginatedResponse) => console.log(paginatedResponse));
Delete Comment Report
activeCommentSession?.deleteCommentReport(
DeleteCommentReportRequestOptions(commentReportId = activeCommentReport?.id!!),
object : LiveLikeCallback<LiveLikeEmptyResponse>() {
override fun onResponse(result: LiveLikeEmptyResponse?, error: String?) {
result?.let { showToast(result.toString(), "Report Deleted") }
error?.let { showToast(error, "Error!!") }
}
}
)
commentClient.deleteCommentReport(
commentReportID: commentReportID
) { result in
switch result {
case .success:
self.showAlert(title: "Comment Report Deleted",
message: "Comment Report Id: \(commentReportID)")
case .failure(let error):
self.showAlert(title: "Error", message: error.localizedDescription)
}
}
LiveLike.deleteCommentReport({
commentReportId: '<comment_report_id>',
})
Dismiss Comment Report
activeCommentSession?.dismissCommentReport(
DismissCommentReportRequestOptions(commentReportId = activeCommentReport?.id!!),
object : LiveLikeCallback<CommentReport>() {
override fun onResponse(result: CommentReport?, error: String?) {
result?.let { showToast(result.toString(), "Report Dismissed") }
error?.let { showToast(error, "Error!!") }
}
}
)
commentClient.dismissCommentReport(
commentReportID: commentReportID
) { result in
switch result {
case .success(let reportDetail):
self.showAlert(title: "Comment Report Dismissed",
message: "Report Status: \(String(describing: reportDetail.reportStatus))")
case .failure(let error):
self.showAlert(title: "Error", message: error.localizedDescription)
}
}
LiveLike.dismissCommentReport({
commentReportId: '<comment_report_id>',
}).then((commentReport) => console.log(commentReport));
Dismiss All Comment Reports
activeCommentSession?.dismissAllCommentReports(
DismissAllReportsForACommentRequestOptions(commentId = activeComment?.id!!),
object : LiveLikeCallback<DismissAllReports>() {
override fun onResponse(result: DismissAllReports?, error: String?) {
result?.let { showToast(result.toString(), "All Report Dismissed") }
error?.let { showToast(error, "Error!!") }
}
}
)
commentClient.dismissAllCommentReports(
commentID: commentID
) { result in
switch result {
case .success(let reportDetail):
self.showAlert(title: "Report Dismissed",
message: "Report Status: \(String(describing: reportDetail.detail))")
case .failure(let error):
self.showAlert(title: "Error", message: error.localizedDescription)
}
}
LiveLike.dismissAllCommentReports({
commentBoardId: '<comment_board_id>',
commentId: '<comment_id>',
})
Updated 4 months ago