PeerTube/server/lib/activitypub/video-comments.ts

160 lines
5.3 KiB
TypeScript
Raw Normal View History

2018-01-10 10:18:12 -06:00
import { VideoCommentObject } from '../../../shared/models/activitypub/objects/video-comment-object'
2018-05-11 08:41:54 -05:00
import { sanitizeAndCheckVideoCommentObject } from '../../helpers/custom-validators/activitypub/video-comments'
2018-01-10 10:18:12 -06:00
import { logger } from '../../helpers/logger'
import { doRequest } from '../../helpers/requests'
import { ACTIVITY_PUB, CRAWL_REQUEST_CONCURRENCY } from '../../initializers'
2018-01-10 10:18:12 -06:00
import { ActorModel } from '../../models/activitypub/actor'
import { VideoModel } from '../../models/video/video'
import { VideoCommentModel } from '../../models/video/video-comment'
import { getOrCreateActorAndServerAndModel } from './actor'
2018-08-22 09:15:35 -05:00
import { getOrCreateVideoAndAccountAndChannel } from './videos'
import * as Bluebird from 'bluebird'
2018-01-10 10:18:12 -06:00
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)
2018-01-10 10:18:12 -06:00
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,
2018-01-10 10:18:12 -06:00
text: comment.content,
videoId: video.id,
accountId: actor.Account.id,
inReplyToCommentId,
originCommentId,
createdAt: new Date(comment.published),
updatedAt: new Date(comment.updated)
}
}
async function addVideoComments (commentUrls: string[], instance: VideoModel) {
return Bluebird.map(commentUrls, commentUrl => {
return addVideoComment(instance, commentUrl)
}, { concurrency: CRAWL_REQUEST_CONCURRENCY })
2018-01-10 10:18:12 -06:00
}
async function addVideoComment (videoInstance: VideoModel, commentUrl: string) {
logger.info('Fetching remote video comment %s.', commentUrl)
const { body } = await doRequest({
uri: commentUrl,
json: true,
activityPub: true
})
2018-05-11 08:41:54 -05:00
if (sanitizeAndCheckVideoCommentObject(body) === false) {
2018-01-10 10:18:12 -06:00
logger.debug('Remote video comment JSON is not valid.', { body })
return { created: false }
2018-01-10 10:18:12 -06:00
}
const actorUrl = body.attributedTo
if (!actorUrl) return { created: false }
2018-01-10 10:18:12 -06:00
const actor = await getOrCreateActorAndServerAndModel(actorUrl)
const entry = await videoCommentActivityObjectToDBAttributes(videoInstance, actor, body)
if (!entry) return { created: false }
2018-01-10 10:18:12 -06:00
const [ comment, created ] = await VideoCommentModel.findOrCreate({
2018-01-10 10:18:12 -06:00
where: {
url: body.id
},
defaults: entry
})
return { comment, created }
2018-01-10 10:18:12 -06:00
}
async function resolveThread (url: string, comments: VideoCommentModel[] = []) {
// Already have this comment?
const commentFromDatabase = await VideoCommentModel.loadByUrlAndPopulateReplyAndVideo(url)
if (commentFromDatabase) {
let parentComments = comments.concat([ commentFromDatabase ])
// Speed up things and resolve directly the thread
if (commentFromDatabase.InReplyToVideoComment) {
const data = await VideoCommentModel.listThreadParentComments(commentFromDatabase, undefined, 'DESC')
parentComments = parentComments.concat(data)
}
return resolveThread(commentFromDatabase.Video.url, parentComments)
}
try {
// Maybe it's a reply to a video?
// If yes, it's done: we resolved all the thread
2018-09-19 04:16:23 -05:00
const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: url })
2018-01-10 10:18:12 -06:00
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 { video, parents: comments }
} catch (err) {
2018-03-26 08:54:13 -05:00
logger.debug('Cannot get or create account and video and channel for reply %s, fetch comment', url, { err })
2018-01-10 10:18:12 -06:00
if (comments.length > ACTIVITY_PUB.MAX_RECURSION_COMMENTS) {
throw new Error('Recursion limit reached when resolving a thread')
}
const { body } = await doRequest({
uri: url,
json: true,
activityPub: true
})
2018-05-11 08:41:54 -05:00
if (sanitizeAndCheckVideoCommentObject(body) === false) {
2018-01-10 10:18:12 -06:00
throw new Error('Remote video comment JSON is not valid :' + JSON.stringify(body))
}
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.url,
text: body.content,
videoId: null,
accountId: actor.Account.id,
inReplyToCommentId: null,
originCommentId: null,
createdAt: new Date(body.published),
updatedAt: new Date(body.updated)
})
return resolveThread(body.inReplyTo, comments.concat([ comment ]))
}
}
export {
videoCommentActivityObjectToDBAttributes,
addVideoComments,
addVideoComment,
resolveThread
}