server/lib/activitypub/process/process-create.ts

   1 import { ActivityCreate, CacheFileObject, VideoAbuseState, VideoTorrentObject } from '../../../../shared'
   2 import { DislikeObject, VideoAbuseObject, ViewObject } from '../../../../shared/models/activitypub/objects'
   3 import { VideoCommentObject } from '../../../../shared/models/activitypub/objects/video-comment-object'
   4 import { retryTransactionWrapper } from '../../../helpers/database-utils'
   5 import { logger } from '../../../helpers/logger'
   6 import { sequelizeTypescript } from '../../../initializers'
   7 import { AccountVideoRateModel } from '../../../models/account/account-video-rate'
   8 import { ActorModel } from '../../../models/activitypub/actor'
   9 import { VideoAbuseModel } from '../../../models/video/video-abuse'
  10 import { addVideoComment, resolveThread } from '../video-comments'
  11 import { getOrCreateVideoAndAccountAndChannel } from '../videos'
  12 import { forwardActivity, forwardVideoRelatedActivity } from '../send/utils'
  13 import { Redis } from '../../redis'
  14 import { createCacheFile } from '../cache-file'
  15
  16 async function processCreateActivity (activity: ActivityCreate, byActor: ActorModel) {
  17   const activityObject = activity.object
  18   const activityType = activityObject.type
  19
  20   if (activityType === 'View') {
  21     return processCreateView(byActor, activity)
  22   } else if (activityType === 'Dislike') {
  23     return retryTransactionWrapper(processCreateDislike, byActor, activity)
  24   } else if (activityType === 'Video') {
  25     return processCreateVideo(activity)
  26   } else if (activityType === 'Flag') {
  27     return retryTransactionWrapper(processCreateVideoAbuse, byActor, activityObject as VideoAbuseObject)
  28   } else if (activityType === 'Note') {
  29     return retryTransactionWrapper(processCreateVideoComment, byActor, activity)
  30   } else if (activityType === 'CacheFile') {
  31     return retryTransactionWrapper(processCacheFile, byActor, activity)
  32   }
  33
  34   logger.warn('Unknown activity object type %s when creating activity.', activityType, { activity: activity.id })
  35   return Promise.resolve(undefined)
  36 }
  37
  38 // ---------------------------------------------------------------------------
  39
  40 export {
  41   processCreateActivity
  42 }
  43
  44 // ---------------------------------------------------------------------------
  45
  46 async function processCreateVideo (activity: ActivityCreate) {
  47   const videoToCreateData = activity.object as VideoTorrentObject
  48
  49   const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: videoToCreateData })
  50
  51   return video
  52 }
  53
  54 async function processCreateDislike (byActor: ActorModel, activity: ActivityCreate) {
  55   const dislike = activity.object as DislikeObject
  56   const byAccount = byActor.Account
  57
  58   if (!byAccount) throw new Error('Cannot create dislike with the non account actor ' + byActor.url)
  59
  60   const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: dislike.object })
  61
  62   return sequelizeTypescript.transaction(async t => {
  63     const rate = {
  64       type: 'dislike' as 'dislike',
  65       videoId: video.id,
  66       accountId: byAccount.id
  67     }
  68     const [ , created ] = await AccountVideoRateModel.findOrCreate({
  69       where: rate,
  70       defaults: rate,
  71       transaction: t
  72     })
  73     if (created === true) await video.increment('dislikes', { transaction: t })
  74
  75     if (video.isOwned() && created === true) {
  76       // Don't resend the activity to the sender
  77       const exceptions = [ byActor ]
  78
  79       await forwardVideoRelatedActivity(activity, t, exceptions, video)
  80     }
  81   })
  82 }
  83
  84 async function processCreateView (byActor: ActorModel, activity: ActivityCreate) {
  85   const view = activity.object as ViewObject
  86
  87   const options = {
  88     videoObject: view.object,
  89     fetchType: 'only-video' as 'only-video'
  90   }
  91   const { video } = await getOrCreateVideoAndAccountAndChannel(options)
  92
  93   await Redis.Instance.addVideoView(video.id)
  94
  95   if (video.isOwned()) {
  96     // Don't resend the activity to the sender
  97     const exceptions = [ byActor ]
  98     await forwardVideoRelatedActivity(activity, undefined, exceptions, video)
  99   }
 100 }
 101
 102 async function processCacheFile (byActor: ActorModel, activity: ActivityCreate) {
 103   const cacheFile = activity.object as CacheFileObject
 104
 105   const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: cacheFile.object })
 106
 107   await sequelizeTypescript.transaction(async t => {
 108     return createCacheFile(cacheFile, video, byActor, t)
 109   })
 110
 111   if (video.isOwned()) {
 112     // Don't resend the activity to the sender
 113     const exceptions = [ byActor ]
 114     await forwardVideoRelatedActivity(activity, undefined, exceptions, video)
 115   }
 116 }
 117
 118 async function processCreateVideoAbuse (byActor: ActorModel, videoAbuseToCreateData: VideoAbuseObject) {
 119   logger.debug('Reporting remote abuse for video %s.', videoAbuseToCreateData.object)
 120
 121   const account = byActor.Account
 122   if (!account) throw new Error('Cannot create dislike with the non account actor ' + byActor.url)
 123
 124   const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: videoAbuseToCreateData.object })
 125
 126   return sequelizeTypescript.transaction(async t => {
 127     const videoAbuseData = {
 128       reporterAccountId: account.id,
 129       reason: videoAbuseToCreateData.content,
 130       videoId: video.id,
 131       state: VideoAbuseState.PENDING
 132     }
 133
 134     await VideoAbuseModel.create(videoAbuseData, { transaction: t })
 135
 136     logger.info('Remote abuse for video uuid %s created', videoAbuseToCreateData.object)
 137   })
 138 }
 139
 140 async function processCreateVideoComment (byActor: ActorModel, activity: ActivityCreate) {
 141   const commentObject = activity.object as VideoCommentObject
 142   const byAccount = byActor.Account
 143
 144   if (!byAccount) throw new Error('Cannot create video comment with the non account actor ' + byActor.url)
 145
 146   const { video } = await resolveThread(commentObject.inReplyTo)
 147
 148   const { created } = await addVideoComment(video, commentObject.id)
 149
 150   if (video.isOwned() && created === true) {
 151     // Don't resend the activity to the sender
 152     const exceptions = [ byActor ]
 153
 154     await forwardVideoRelatedActivity(activity, undefined, exceptions, video)
 155   }
 156 }