+import { map } from 'bluebird'
import { sanitizeAndCheckVideoCommentObject } from '../../helpers/custom-validators/activitypub/video-comments'
import { logger } from '../../helpers/logger'
-import { doRequest } from '../../helpers/requests'
+import { doJSONRequest } from '../../helpers/requests'
import { ACTIVITY_PUB, CRAWL_REQUEST_CONCURRENCY } from '../../initializers/constants'
import { VideoCommentModel } from '../../models/video/video-comment'
-import { getOrCreateActorAndServerAndModel } from './actor'
-import { getOrCreateVideoAndAccountAndChannel } from './videos'
-import * as Bluebird from 'bluebird'
-import { checkUrlsSameHost } from '../../helpers/activitypub'
-import { MCommentOwner, MCommentOwnerVideo, MVideoAccountLightBlacklistAllFiles } from '../../types/models/video'
+import { MComment, MCommentOwner, MCommentOwnerVideo, MVideoAccountLightBlacklistAllFiles } from '../../types/models/video'
+import { isRemoteVideoCommentAccepted } from '../moderation'
+import { Hooks } from '../plugins/hooks'
+import { getOrCreateAPActor } from './actors'
+import { checkUrlsSameHost } from './url'
+import { getOrCreateAPVideo } from './videos'
type ResolveThreadParams = {
url: string
type ResolveThreadResult = Promise<{ video: MVideoAccountLightBlacklistAllFiles, comment: MCommentOwnerVideo, commentCreated: boolean }>
async function addVideoComments (commentUrls: string[]) {
- return Bluebird.map(commentUrls, commentUrl => {
- return resolveThread({ url: commentUrl, isVideo: false })
+ return map(commentUrls, async commentUrl => {
+ try {
+ await resolveThread({ url: commentUrl, isVideo: false })
+ } catch (err) {
+ logger.warn('Cannot resolve thread %s.', commentUrl, { err })
+ }
}, { concurrency: CRAWL_REQUEST_CONCURRENCY })
}
async function resolveThread (params: ResolveThreadParams): ResolveThreadResult {
const { url, isVideo } = params
+
if (params.commentCreated === undefined) params.commentCreated = false
if (params.comments === undefined) params.comments = []
- // Already have this comment?
- if (isVideo !== true) {
+ // If it is not a video, or if we don't know if it's a video, try to get the thread from DB
+ if (isVideo === false || isVideo === undefined) {
const result = await resolveCommentFromDB(params)
if (result) return result
}
try {
- if (isVideo !== false) return await tryResolveThreadFromVideo(params)
-
- return resolveParentComment(params)
+ // If it is a video, or if we don't know if it's a video
+ if (isVideo === true || isVideo === undefined) {
+ // Keep await so we catch the exception
+ return await tryToResolveThreadFromVideo(params)
+ }
} catch (err) {
- logger.debug('Cannot get or create account and video and channel for reply %s, fetch comment', url, { err })
-
- return resolveParentComment(params)
+ logger.debug('Cannot resolve thread from video %s, maybe because it was not a video', url, { err })
}
+
+ return resolveRemoteParentComment(params)
}
export {
const { url, comments, commentCreated } = params
const commentFromDatabase = await VideoCommentModel.loadByUrlAndPopulateReplyAndVideoUrlAndAccount(url)
- if (commentFromDatabase) {
- let parentComments = comments.concat([ commentFromDatabase ])
+ if (!commentFromDatabase) return undefined
- // Speed up things and resolve directly the thread
- if (commentFromDatabase.InReplyToVideoComment) {
- const data = await VideoCommentModel.listThreadParentComments(commentFromDatabase, undefined, 'DESC')
+ let parentComments = comments.concat([ commentFromDatabase ])
- parentComments = parentComments.concat(data)
- }
+ // Speed up things and resolve directly the thread
+ if (commentFromDatabase.InReplyToVideoComment) {
+ const data = await VideoCommentModel.listThreadParentComments(commentFromDatabase, undefined, 'DESC')
- return resolveThread({
- url: commentFromDatabase.Video.url,
- comments: parentComments,
- isVideo: true,
- commentCreated
- })
+ parentComments = parentComments.concat(data)
}
- return undefined
+ return resolveThread({
+ url: commentFromDatabase.Video.url,
+ comments: parentComments,
+ isVideo: true,
+ commentCreated
+ })
}
-async function tryResolveThreadFromVideo (params: ResolveThreadParams) {
+async function tryToResolveThreadFromVideo (params: ResolveThreadParams) {
const { url, comments, commentCreated } = params
// Maybe it's a reply to a video?
// If yes, it's done: we resolved all the thread
- const syncParam = { likes: true, dislikes: true, shares: true, comments: false, thumbnail: true, refreshVideo: false }
- const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: url, syncParam })
+ const syncParam = { rates: true, shares: true, comments: false, thumbnail: true, refreshVideo: false }
+ const { video } = await getOrCreateAPVideo({ videoObject: url, syncParam })
+
+ if (video.isOwned() && !video.hasPrivacyForFederation()) {
+ throw new Error('Cannot resolve thread of video with privacy that is not compatible with federation')
+ }
let resultComment: MCommentOwnerVideo
if (comments.length !== 0) {
firstReply.changed('updatedAt', true)
firstReply.Video = video
+ if (await isRemoteCommentAccepted(firstReply) !== true) {
+ return undefined
+ }
+
comments[comments.length - 1] = await firstReply.save()
for (let i = comments.length - 2; i >= 0; i--) {
comment.changed('updatedAt', true)
comment.Video = video
+ if (await isRemoteCommentAccepted(comment) !== true) {
+ return undefined
+ }
+
comments[i] = await comment.save()
}
return { video, comment: resultComment, commentCreated }
}
-async function resolveParentComment (params: ResolveThreadParams) {
+async function resolveRemoteParentComment (params: ResolveThreadParams) {
const { url, comments } = params
if (comments.length > ACTIVITY_PUB.MAX_RECURSION_COMMENTS) {
throw new Error('Recursion limit reached when resolving a thread')
}
- const { body } = await doRequest<any>({
- uri: url,
- json: true,
- activityPub: true
- })
+ const { body } = await doJSONRequest<any>(url, { activityPub: true })
if (sanitizeAndCheckVideoCommentObject(body) === false) {
- throw new Error('Remote video comment JSON is not valid:' + JSON.stringify(body))
+ throw new Error(`Remote video comment JSON ${url} is not valid:` + JSON.stringify(body))
}
const actorUrl = body.attributedTo
}
const actor = actorUrl
- ? await getOrCreateActorAndServerAndModel(actorUrl, 'all')
+ ? await getOrCreateAPActor(actorUrl, 'all')
: null
const comment = new VideoCommentModel({
commentCreated: true
})
}
+
+async function isRemoteCommentAccepted (comment: MComment) {
+ // Already created
+ if (comment.id) return true
+
+ const acceptParameters = {
+ comment
+ }
+
+ const acceptedResult = await Hooks.wrapFun(
+ isRemoteVideoCommentAccepted,
+ acceptParameters,
+ 'filter:activity-pub.remote-video-comment.create.accept.result'
+ )
+
+ if (!acceptedResult || acceptedResult.accepted !== true) {
+ logger.info('Refused to create a remote comment.', { acceptedResult, acceptParameters })
+
+ return false
+ }
+
+ return true
+}