Fix lint

[github/Chocobozzz/PeerTube.git] / server / lib / activitypub / process / misc.ts

diff --git a/server/lib/activitypub/process/misc.ts b/server/lib/activitypub/process/misc.ts
index eefbe28842c429dcea971c79feea0914f973487d..461619ea758c6f4a0ad98016fca5902ce424ed07 100644 (file)
--- a/server/lib/activitypub/process/misc.ts
+++ b/server/lib/activitypub/process/misc.ts
@@ -1,29 +1,20 @@
 import * as magnetUtil from 'magnet-uri'
 import { VideoTorrentObject } from '../../../../shared'
-import { VideoChannelObject } from '../../../../shared/models/activitypub/objects/video-channel-object'
+import { VideoCommentObject } from '../../../../shared/models/activitypub/objects/video-comment-object'
+import { VideoPrivacy } from '../../../../shared/models/videos'
 import { isVideoFileInfoHashValid } from '../../../helpers/custom-validators/videos'
-import { ACTIVITY_PUB, VIDEO_MIMETYPE_EXT } from '../../../initializers/constants'
-import { AccountInstance } from '../../../models/account/account-interface'
-import { VideoChannelInstance } from '../../../models/video/video-channel-interface'
-import { VideoFileAttributes } from '../../../models/video/video-file-interface'
-import { VideoAttributes, VideoInstance } from '../../../models/video/video-interface'
-import { VideoPrivacy } from '../../../../shared/models/videos/video-privacy.enum'
-
-function videoChannelActivityObjectToDBAttributes (videoChannelObject: VideoChannelObject, account: AccountInstance) {
-  return {
-    name: videoChannelObject.name,
-    description: videoChannelObject.content,
-    uuid: videoChannelObject.uuid,
-    url: videoChannelObject.id,
-    createdAt: new Date(videoChannelObject.published),
-    updatedAt: new Date(videoChannelObject.updated),
-    remote: true,
-    accountId: account.id
-  }
-}
+import { logger } from '../../../helpers/logger'
+import { doRequest } from '../../../helpers/requests'
+import { ACTIVITY_PUB, VIDEO_MIMETYPE_EXT } from '../../../initializers'
+import { ActorModel } from '../../../models/activitypub/actor'
+import { VideoModel } from '../../../models/video/video'
+import { VideoChannelModel } from '../../../models/video/video-channel'
+import { VideoCommentModel } from '../../../models/video/video-comment'
+import { VideoShareModel } from '../../../models/video/video-share'
+import { getOrCreateActorAndServerAndModel } from '../actor'
 
 async function videoActivityObjectToDBAttributes (
-  videoChannel: VideoChannelInstance,
+  videoChannel: VideoChannelModel,
   videoObject: VideoTorrentObject,
   to: string[] = [],
   cc: string[] = []
@@ -38,15 +29,31 @@ async function videoActivityObjectToDBAttributes (
     language = parseInt(videoObject.language.identifier, 10)
   }
 
-  const videoData: VideoAttributes = {
+  let category = null
+  if (videoObject.category) {
+    category = parseInt(videoObject.category.identifier, 10)
+  }
+
+  let licence = null
+  if (videoObject.licence) {
+    licence = parseInt(videoObject.licence.identifier, 10)
+  }
+
+  let description = null
+  if (videoObject.content) {
+    description = videoObject.content
+  }
+
+  return {
     name: videoObject.name,
     uuid: videoObject.uuid,
     url: videoObject.id,
-    category: parseInt(videoObject.category.identifier, 10),
-    licence: parseInt(videoObject.licence.identifier, 10),
+    category,
+    licence,
     language,
+    description,
     nsfw: videoObject.nsfw,
-    description: videoObject.content,
+    commentsEnabled: videoObject.commentsEnabled,
     channelId: videoChannel.id,
     duration: parseInt(duration, 10),
     createdAt: new Date(videoObject.published),
@@ -58,11 +65,9 @@ async function videoActivityObjectToDBAttributes (
     remote: true,
     privacy
   }
-
-  return videoData
 }
 
-function videoFileActivityUrlToDBAttributes (videoCreated: VideoInstance, videoObject: VideoTorrentObject) {
+function videoFileActivityUrlToDBAttributes (videoCreated: VideoModel, videoObject: VideoTorrentObject) {
   const mimeTypes = Object.keys(VIDEO_MIMETYPE_EXT)
   const fileUrls = videoObject.url.filter(u => {
     return mimeTypes.indexOf(u.mimeType) !== -1 && u.mimeType.startsWith('video/')
@@ -72,7 +77,7 @@ function videoFileActivityUrlToDBAttributes (videoCreated: VideoInstance, videoO
     throw new Error('Cannot find video files for ' + videoCreated.url)
   }
 
-  const attributes: VideoFileAttributes[] = []
+  const attributes = []
   for (const fileUrl of fileUrls) {
     // Fetch associated magnet uri
     const magnet = videoObject.url.find(u => {
@@ -97,10 +102,93 @@ function videoFileActivityUrlToDBAttributes (videoCreated: VideoInstance, videoO
   return attributes
 }
 
+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 [ 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.url,
+    text: comment.content,
+    videoId: video.id,
+    accountId: actor.Account.id,
+    inReplyToCommentId,
+    originCommentId,
+    createdAt: new Date(comment.published),
+    updatedAt: new Date(comment.updated)
+  }
+}
+
+async function addVideoShares (instance: VideoModel, shareUrls: string[]) {
+  for (const shareUrl of shareUrls) {
+    // Fetch url
+    const { body } = await doRequest({
+      uri: shareUrl,
+      json: true,
+      activityPub: true
+    })
+    const actorUrl = body.actor
+    if (!actorUrl) continue
+
+    const actor = await getOrCreateActorAndServerAndModel(actorUrl)
+
+    const entry = {
+      actorId: actor.id,
+      videoId: instance.id
+    }
+
+    await VideoShareModel.findOrCreate({
+      where: entry,
+      defaults: entry
+    })
+  }
+}
+
+async function addVideoComments (instance: VideoModel, commentUrls: string[]) {
+  for (const commentUrl of commentUrls) {
+    await addVideoComment(instance, commentUrl)
+  }
+}
+
+async function addVideoComment (instance: VideoModel, commentUrl: string) {
+  // Fetch url
+  const { body } = await doRequest({
+    uri: commentUrl,
+    json: true,
+    activityPub: true
+  })
+
+  const actorUrl = body.attributedTo
+  if (!actorUrl) return []
+
+  const actor = await getOrCreateActorAndServerAndModel(actorUrl)
+  const entry = await videoCommentActivityObjectToDBAttributes(instance, actor, body)
+  if (!entry) return []
+
+  return VideoCommentModel.findOrCreate({
+    where: {
+      url: body.id
+    },
+    defaults: entry
+  })
+}
+
 // ---------------------------------------------------------------------------
 
 export {
   videoFileActivityUrlToDBAttributes,
   videoActivityObjectToDBAttributes,
-  videoChannelActivityObjectToDBAttributes
+  addVideoShares,
+  addVideoComments
 }