X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Flib%2Factivitypub%2Fprocess%2Fprocess-create.ts;h=1e6e8956ccc8e349b91946ce95efdbdf8c3fd24a;hb=b2a70e3ca2611a8831b6e490cc25dbf3066562c0;hp=e882669ceea30cb6954e99ce9d286ebc2c9cf43e;hpb=97567dd81f508dd6295ac4d73d849aa2ce0a6549;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/lib/activitypub/process/process-create.ts b/server/lib/activitypub/process/process-create.ts
index e882669ce..1e6e8956c 100644
--- a/server/lib/activitypub/process/process-create.ts
+++ b/server/lib/activitypub/process/process-create.ts
@@ -1,42 +1,41 @@
-import { ActivityCreate, CacheFileObject, VideoTorrentObject } from '../../../../shared'
-import { VideoCommentObject } from '../../../../shared/models/activitypub/objects/video-comment-object'
+import { isBlockedByServerOrAccount } from '@server/lib/blocklist'
+import { isRedundancyAccepted } from '@server/lib/redundancy'
+import { VideoModel } from '@server/models/video/video'
+import { ActivityCreate, CacheFileObject, PlaylistObject, VideoCommentObject, VideoObject, WatchActionObject } from '@shared/models'
 import { retryTransactionWrapper } from '../../../helpers/database-utils'
 import { logger } from '../../../helpers/logger'
-import { sequelizeTypescript } from '../../../initializers'
-import { ActorModel } from '../../../models/activitypub/actor'
-import { addVideoComment, resolveThread } from '../video-comments'
-import { getOrCreateVideoAndAccountAndChannel } from '../videos'
-import { forwardVideoRelatedActivity } from '../send/utils'
-import { createOrUpdateCacheFile } from '../cache-file'
+import { sequelizeTypescript } from '../../../initializers/database'
+import { APProcessorOptions } from '../../../types/activitypub-processor.model'
+import { MActorSignature, MCommentOwnerVideo, MVideoAccountLightBlacklistAllFiles } from '../../../types/models'
 import { Notifier } from '../../notifier'
-import { processViewActivity } from './process-view'
-import { processDislikeActivity } from './process-dislike'
-import { processFlagActivity } from './process-flag'
-import { PlaylistObject } from '../../../../shared/models/activitypub/objects/playlist-object'
-import { createOrUpdateVideoPlaylist } from '../playlist'
+import { createOrUpdateCacheFile } from '../cache-file'
+import { createOrUpdateLocalVideoViewer } from '../local-video-viewer'
+import { createOrUpdateVideoPlaylist } from '../playlists'
+import { forwardVideoRelatedActivity } from '../send/shared/send-utils'
+import { resolveThread } from '../video-comments'
+import { getOrCreateAPVideo } from '../videos'
+
+async function processCreateActivity (options: APProcessorOptions<ActivityCreate>) {
+  const { activity, byActor } = options
 
-async function processCreateActivity (activity: ActivityCreate, byActor: ActorModel) {
+  // Only notify if it is not from a fetcher job
+  const notify = options.fromFetch !== true
   const activityObject = activity.object
   const activityType = activityObject.type
 
-  if (activityType === 'View') {
-    return processViewActivity(activity, byActor)
-  }
-
-  if (activityType === 'Dislike') {
-    return retryTransactionWrapper(processDislikeActivity, activity, byActor)
+  if (activityType === 'Video') {
+    return processCreateVideo(activity, notify)
   }
 
-  if (activityType === 'Flag') {
-    return retryTransactionWrapper(processFlagActivity, activity, byActor)
-  }
+  if (activityType === 'Note') {
+    // Comments will be fetched from videos
+    if (options.fromFetch) return
 
-  if (activityType === 'Video') {
-    return processCreateVideo(activity)
+    return retryTransactionWrapper(processCreateVideoComment, activity, byActor, notify)
   }
 
-  if (activityType === 'Note') {
-    return retryTransactionWrapper(processCreateVideoComment, activity, byActor)
+  if (activityType === 'WatchAction') {
+    return retryTransactionWrapper(processCreateWatchAction, activity)
   }
 
   if (activityType === 'CacheFile') {
@@ -59,20 +58,23 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function processCreateVideo (activity: ActivityCreate) {
-  const videoToCreateData = activity.object as VideoTorrentObject
+async function processCreateVideo (activity: ActivityCreate, notify: boolean) {
+  const videoToCreateData = activity.object as VideoObject
 
-  const { video, created } = await getOrCreateVideoAndAccountAndChannel({ videoObject: videoToCreateData })
+  const syncParam = { rates: false, shares: false, comments: false, thumbnail: true, refreshVideo: false }
+  const { video, created } = await getOrCreateAPVideo({ videoObject: videoToCreateData, syncParam })
 
-  if (created) Notifier.Instance.notifyOnNewVideo(video)
+  if (created && notify) Notifier.Instance.notifyOnNewVideoIfNeeded(video)
 
   return video
 }
 
-async function processCreateCacheFile (activity: ActivityCreate, byActor: ActorModel) {
+async function processCreateCacheFile (activity: ActivityCreate, byActor: MActorSignature) {
+  if (await isRedundancyAccepted(activity, byActor) !== true) return
+
   const cacheFile = activity.object as CacheFileObject
 
-  const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: cacheFile.object })
+  const { video } = await getOrCreateAPVideo({ videoObject: cacheFile.object })
 
   await sequelizeTypescript.transaction(async t => {
     return createOrUpdateCacheFile(cacheFile, video, byActor, t)
@@ -85,31 +87,68 @@ async function processCreateCacheFile (activity: ActivityCreate, byActor: ActorM
   }
 }
 
-async function processCreateVideoComment (activity: ActivityCreate, byActor: ActorModel) {
+async function processCreateWatchAction (activity: ActivityCreate) {
+  const watchAction = activity.object as WatchActionObject
+
+  if (watchAction.actionStatus !== 'CompletedActionStatus') return
+
+  const video = await VideoModel.loadByUrl(watchAction.object)
+  if (video.remote) return
+
+  await sequelizeTypescript.transaction(async t => {
+    return createOrUpdateLocalVideoViewer(watchAction, video, t)
+  })
+}
+
+async function processCreateVideoComment (activity: ActivityCreate, byActor: MActorSignature, notify: boolean) {
   const commentObject = activity.object as VideoCommentObject
   const byAccount = byActor.Account
 
   if (!byAccount) throw new Error('Cannot create video comment with the non account actor ' + byActor.url)
 
-  const { video } = await resolveThread(commentObject.inReplyTo)
+  let video: MVideoAccountLightBlacklistAllFiles
+  let created: boolean
+  let comment: MCommentOwnerVideo
+
+  try {
+    const resolveThreadResult = await resolveThread({ url: commentObject.id, isVideo: false })
+    if (!resolveThreadResult) return // Comment not accepted
+
+    video = resolveThreadResult.video
+    created = resolveThreadResult.commentCreated
+    comment = resolveThreadResult.comment
+  } catch (err) {
+    logger.debug(
+      'Cannot process video comment because we could not resolve thread %s. Maybe it was not a video thread, so skip it.',
+      commentObject.inReplyTo,
+      { err }
+    )
+    return
+  }
 
-  const { comment, created } = await addVideoComment(video, commentObject.id)
+  // Try to not forward unwanted comments on our videos
+  if (video.isOwned()) {
+    if (await isBlockedByServerOrAccount(comment.Account, video.VideoChannel.Account)) {
+      logger.info('Skip comment forward from blocked account or server %s.', comment.Account.Actor.url)
+      return
+    }
 
-  if (video.isOwned() && created === true) {
-    // Don't resend the activity to the sender
-    const exceptions = [ byActor ]
+    if (created === true) {
+      // Don't resend the activity to the sender
+      const exceptions = [ byActor ]
 
-    await forwardVideoRelatedActivity(activity, undefined, exceptions, video)
+      await forwardVideoRelatedActivity(activity, undefined, exceptions, video)
+    }
   }
 
-  if (created === true) Notifier.Instance.notifyOnNewComment(comment)
+  if (created && notify) Notifier.Instance.notifyOnNewComment(comment)
 }
 
-async function processCreatePlaylist (activity: ActivityCreate, byActor: ActorModel) {
+async function processCreatePlaylist (activity: ActivityCreate, byActor: MActorSignature) {
   const playlistObject = activity.object as PlaylistObject
   const byAccount = byActor.Account
 
   if (!byAccount) throw new Error('Cannot create video playlist with the non account actor ' + byActor.url)
 
-  await createOrUpdateVideoPlaylist(playlistObject, byAccount, activity.to)
+  await createOrUpdateVideoPlaylist(playlistObject, activity.to)
 }