-import { VideoCommentObject } from '../../../shared/models/activitypub/objects/video-comment-object'
import { sanitizeAndCheckVideoCommentObject } from '../../helpers/custom-validators/activitypub/video-comments'
import { logger } from '../../helpers/logger'
import { doRequest } from '../../helpers/requests'
import { ACTIVITY_PUB, CRAWL_REQUEST_CONCURRENCY } from '../../initializers/constants'
-import { ActorModel } from '../../models/activitypub/actor'
import { VideoModel } from '../../models/video/video'
import { VideoCommentModel } from '../../models/video/video-comment'
import { getOrCreateActorAndServerAndModel } from './actor'
import * as Bluebird from 'bluebird'
import { checkUrlsSameHost } from '../../helpers/activitypub'
-async function videoCommentActivityObjectToDBAttributes (video: VideoModel, actor: ActorModel, comment: VideoCommentObject) {
- let originCommentId: number = null
- let inReplyToCommentId: number = null
-
- // If this is not a reply to the video (thread), create or get the parent comment
- if (video.url !== comment.inReplyTo) {
- const { comment: parent } = await addVideoComment(video, comment.inReplyTo)
- if (!parent) {
- logger.warn('Cannot fetch or get parent comment %s of comment %s.', comment.inReplyTo, comment.id)
- return undefined
- }
-
- originCommentId = parent.originCommentId || parent.id
- inReplyToCommentId = parent.id
- }
-
- return {
- url: comment.id,
- text: comment.content,
- videoId: video.id,
- accountId: actor.Account.id,
- inReplyToCommentId,
- originCommentId,
- createdAt: new Date(comment.published)
- }
+type ResolveThreadParams = {
+ url: string,
+ comments?: VideoCommentModel[],
+ isVideo?: boolean,
+ commentCreated?: boolean
}
+type ResolveThreadResult = Promise<{ video: VideoModel, comment: VideoCommentModel, commentCreated: boolean }>
-async function addVideoComments (commentUrls: string[], instance: VideoModel) {
+async function addVideoComments (commentUrls: string[]) {
return Bluebird.map(commentUrls, commentUrl => {
- return addVideoComment(instance, commentUrl)
+ return resolveThread({ url: commentUrl, isVideo: false })
}, { concurrency: CRAWL_REQUEST_CONCURRENCY })
}
-async function addVideoComment (videoInstance: VideoModel, commentUrl: string) {
- logger.info('Fetching remote video comment %s.', commentUrl)
+async function resolveThread (params: ResolveThreadParams): ResolveThreadResult {
+ const { url, isVideo } = params
+ if (params.commentCreated === undefined) params.commentCreated = false
+ if (params.comments === undefined) params.comments = []
- const { body } = await doRequest({
- uri: commentUrl,
- json: true,
- activityPub: true
- })
-
- if (sanitizeAndCheckVideoCommentObject(body) === false) {
- logger.debug('Remote video comment JSON %s is not valid.', commentUrl, { body })
- return { created: false }
+ // Already have this comment?
+ if (isVideo !== true) {
+ const result = await resolveCommentFromDB(params)
+ if (result) return result
}
- const actorUrl = body.attributedTo
- if (!actorUrl) return { created: false }
+ try {
+ if (isVideo !== false) return await tryResolveThreadFromVideo(params)
- if (checkUrlsSameHost(commentUrl, actorUrl) !== true) {
- throw new Error(`Actor url ${actorUrl} has not the same host than the comment url ${commentUrl}`)
- }
+ return resolveParentComment(params)
+ } catch (err) {
+ logger.debug('Cannot get or create account and video and channel for reply %s, fetch comment', url, { err })
- if (checkUrlsSameHost(body.id, commentUrl) !== true) {
- throw new Error(`Comment url ${commentUrl} host is different from the AP object id ${body.id}`)
+ return resolveParentComment(params)
}
+}
- const actor = await getOrCreateActorAndServerAndModel(actorUrl, 'all')
- const entry = await videoCommentActivityObjectToDBAttributes(videoInstance, actor, body)
- if (!entry) return { created: false }
+export {
+ addVideoComments,
+ resolveThread
+}
- const [ comment, created ] = await VideoCommentModel.upsert<VideoCommentModel>(entry, { returning: true })
- comment.Account = actor.Account
- comment.Video = videoInstance
+// ---------------------------------------------------------------------------
- return { comment, created }
-}
+async function resolveCommentFromDB (params: ResolveThreadParams) {
+ const { url, comments, commentCreated } = params
-type ResolveThreadResult = Promise<{ video: VideoModel, parents: VideoCommentModel[] }>
-async function resolveThread (url: string, comments: VideoCommentModel[] = []): ResolveThreadResult {
- // Already have this comment?
- const commentFromDatabase = await VideoCommentModel.loadByUrlAndPopulateReplyAndVideo(url)
+ const commentFromDatabase = await VideoCommentModel.loadByUrlAndPopulateReplyAndVideoUrlAndAccount(url)
if (commentFromDatabase) {
let parentComments = comments.concat([ commentFromDatabase ])
parentComments = parentComments.concat(data)
}
- return resolveThread(commentFromDatabase.Video.url, parentComments)
+ return resolveThread({
+ url: commentFromDatabase.Video.url,
+ comments: parentComments,
+ isVideo: true,
+ commentCreated
+ })
}
- try {
- // Maybe it's a reply to a video?
- // If yes, it's done: we resolved all the thread
- const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: url })
-
- if (comments.length !== 0) {
- const firstReply = comments[ comments.length - 1 ]
- firstReply.inReplyToCommentId = null
- firstReply.originCommentId = null
- firstReply.videoId = video.id
- comments[comments.length - 1] = await firstReply.save()
-
- for (let i = comments.length - 2; i >= 0; i--) {
- const comment = comments[ i ]
- comment.originCommentId = firstReply.id
- comment.inReplyToCommentId = comments[ i + 1 ].id
- comment.videoId = video.id
-
- comments[i] = await comment.save()
- }
+ return undefined
+}
+
+async function tryResolveThreadFromVideo (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 })
+
+ let resultComment: VideoCommentModel
+ if (comments.length !== 0) {
+ const firstReply = comments[ comments.length - 1 ]
+ firstReply.inReplyToCommentId = null
+ firstReply.originCommentId = null
+ firstReply.videoId = video.id
+ firstReply.changed('updatedAt', true)
+ firstReply.Video = video
+
+ comments[comments.length - 1] = await firstReply.save()
+
+ for (let i = comments.length - 2; i >= 0; i--) {
+ const comment = comments[ i ]
+ comment.originCommentId = firstReply.id
+ comment.inReplyToCommentId = comments[ i + 1 ].id
+ comment.videoId = video.id
+ comment.changed('updatedAt', true)
+ comment.Video = video
+
+ comments[i] = await comment.save()
}
- return { video, parents: comments }
- } catch (err) {
- logger.debug('Cannot get or create account and video and channel for reply %s, fetch comment', url, { err })
+ resultComment = comments[0]
+ }
- if (comments.length > ACTIVITY_PUB.MAX_RECURSION_COMMENTS) {
- throw new Error('Recursion limit reached when resolving a thread')
- }
+ return { video, comment: resultComment, commentCreated }
+}
- const { body } = await doRequest({
- uri: url,
- json: true,
- activityPub: true
- })
+async function resolveParentComment (params: ResolveThreadParams) {
+ const { url, comments } = params
- if (sanitizeAndCheckVideoCommentObject(body) === false) {
- throw new Error('Remote video comment JSON is not valid:' + JSON.stringify(body))
- }
+ if (comments.length > ACTIVITY_PUB.MAX_RECURSION_COMMENTS) {
+ throw new Error('Recursion limit reached when resolving a thread')
+ }
- const actorUrl = body.attributedTo
- if (!actorUrl) throw new Error('Miss attributed to in comment')
+ const { body } = await doRequest({
+ uri: url,
+ json: true,
+ activityPub: true
+ })
- if (checkUrlsSameHost(url, actorUrl) !== true) {
- throw new Error(`Actor url ${actorUrl} has not the same host than the comment url ${url}`)
- }
+ if (sanitizeAndCheckVideoCommentObject(body) === false) {
+ throw new Error('Remote video comment JSON is not valid:' + JSON.stringify(body))
+ }
- if (checkUrlsSameHost(body.id, url) !== true) {
- throw new Error(`Comment url ${url} host is different from the AP object id ${body.id}`)
- }
+ const actorUrl = body.attributedTo
+ if (!actorUrl) throw new Error('Miss attributed to in comment')
- const actor = await getOrCreateActorAndServerAndModel(actorUrl)
- const comment = new VideoCommentModel({
- url: body.id,
- text: body.content,
- videoId: null,
- accountId: actor.Account.id,
- inReplyToCommentId: null,
- originCommentId: null,
- createdAt: new Date(body.published),
- updatedAt: new Date(body.updated)
- })
+ if (checkUrlsSameHost(url, actorUrl) !== true) {
+ throw new Error(`Actor url ${actorUrl} has not the same host than the comment url ${url}`)
+ }
- return resolveThread(body.inReplyTo, comments.concat([ comment ]))
+ if (checkUrlsSameHost(body.id, url) !== true) {
+ throw new Error(`Comment url ${url} host is different from the AP object id ${body.id}`)
}
-}
-export {
- videoCommentActivityObjectToDBAttributes,
- addVideoComments,
- addVideoComment,
- resolveThread
+ const actor = await getOrCreateActorAndServerAndModel(actorUrl)
+ const comment = new VideoCommentModel({
+ url: body.id,
+ text: body.content,
+ videoId: null,
+ accountId: actor.Account.id,
+ inReplyToCommentId: null,
+ originCommentId: null,
+ createdAt: new Date(body.published),
+ updatedAt: new Date(body.updated)
+ })
+ comment.Account = actor.Account
+
+ return resolveThread({
+ url: body.inReplyTo,
+ comments: comments.concat([ comment ]),
+ commentCreated: true
+ })
}
projects / github / Chocobozzz / PeerTube.git / blobdiff