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

   1 import { ActivityAnnounce, ActivityFollow, ActivityLike, ActivityUndo } from '../../../../shared/models/activitypub'
   2 import { DislikeObject } from '../../../../shared/models/activitypub/objects'
   3 import { getActorUrl } from '../../../helpers/activitypub'
   4 import { retryTransactionWrapper } from '../../../helpers/database-utils'
   5 import { logger } from '../../../helpers/logger'
   6 import { sequelizeTypescript } from '../../../initializers'
   7 import { AccountModel } from '../../../models/account/account'
   8 import { AccountVideoRateModel } from '../../../models/account/account-video-rate'
   9 import { ActorModel } from '../../../models/activitypub/actor'
  10 import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
  11 import { forwardVideoRelatedActivity } from '../send/utils'
  12 import { getOrCreateAccountAndVideoAndChannel } from '../videos'
  13 import { VideoShareModel } from '../../../models/video/video-share'
  14
  15 async function processUndoActivity (activity: ActivityUndo) {
  16   const activityToUndo = activity.object
  17
  18   const actorUrl = getActorUrl(activity.actor)
  19
  20   if (activityToUndo.type === 'Like') {
  21     return processUndoLike(actorUrl, activity)
  22   } else if (activityToUndo.type === 'Create' && activityToUndo.object.type === 'Dislike') {
  23     return processUndoDislike(actorUrl, activity)
  24   } else if (activityToUndo.type === 'Follow') {
  25     return processUndoFollow(actorUrl, activityToUndo)
  26   } else if (activityToUndo.type === 'Announce') {
  27     return processUndoAnnounce(actorUrl, activityToUndo)
  28   }
  29
  30   logger.warn('Unknown activity object type %s -> %s when undo activity.', activityToUndo.type, { activity: activity.id })
  31
  32   return undefined
  33 }
  34
  35 // ---------------------------------------------------------------------------
  36
  37 export {
  38   processUndoActivity
  39 }
  40
  41 // ---------------------------------------------------------------------------
  42
  43 function processUndoLike (actorUrl: string, activity: ActivityUndo) {
  44   const options = {
  45     arguments: [ actorUrl, activity ],
  46     errorMessage: 'Cannot undo like with many retries.'
  47   }
  48
  49   return retryTransactionWrapper(undoLike, options)
  50 }
  51
  52 async function undoLike (actorUrl: string, activity: ActivityUndo) {
  53   const likeActivity = activity.object as ActivityLike
  54
  55   const { video } = await getOrCreateAccountAndVideoAndChannel(likeActivity.object)
  56
  57   return sequelizeTypescript.transaction(async t => {
  58     const byAccount = await AccountModel.loadByUrl(actorUrl, t)
  59     if (!byAccount) throw new Error('Unknown account ' + actorUrl)
  60
  61     const rate = await AccountVideoRateModel.load(byAccount.id, video.id, t)
  62     if (!rate) throw new Error(`Unknown rate by account ${byAccount.id} for video ${video.id}.`)
  63
  64     await rate.destroy({ transaction: t })
  65     await video.decrement('likes', { transaction: t })
  66
  67     if (video.isOwned()) {
  68       // Don't resend the activity to the sender
  69       const exceptions = [ byAccount.Actor ]
  70
  71       await forwardVideoRelatedActivity(activity, t, exceptions, video)
  72     }
  73   })
  74 }
  75
  76 function processUndoDislike (actorUrl: string, activity: ActivityUndo) {
  77   const options = {
  78     arguments: [ actorUrl, activity ],
  79     errorMessage: 'Cannot undo dislike with many retries.'
  80   }
  81
  82   return retryTransactionWrapper(undoDislike, options)
  83 }
  84
  85 async function undoDislike (actorUrl: string, activity: ActivityUndo) {
  86   const dislike = activity.object.object as DislikeObject
  87
  88   const { video } = await getOrCreateAccountAndVideoAndChannel(dislike.object)
  89
  90   return sequelizeTypescript.transaction(async t => {
  91     const byAccount = await AccountModel.loadByUrl(actorUrl, t)
  92     if (!byAccount) throw new Error('Unknown account ' + actorUrl)
  93
  94     const rate = await AccountVideoRateModel.load(byAccount.id, video.id, t)
  95     if (!rate) throw new Error(`Unknown rate by account ${byAccount.id} for video ${video.id}.`)
  96
  97     await rate.destroy({ transaction: t })
  98     await video.decrement('dislikes', { transaction: t })
  99
 100     if (video.isOwned()) {
 101       // Don't resend the activity to the sender
 102       const exceptions = [ byAccount.Actor ]
 103
 104       await forwardVideoRelatedActivity(activity, t, exceptions, video)
 105     }
 106   })
 107 }
 108
 109 function processUndoFollow (actorUrl: string, followActivity: ActivityFollow) {
 110   const options = {
 111     arguments: [ actorUrl, followActivity ],
 112     errorMessage: 'Cannot undo follow with many retries.'
 113   }
 114
 115   return retryTransactionWrapper(undoFollow, options)
 116 }
 117
 118 function undoFollow (actorUrl: string, followActivity: ActivityFollow) {
 119   return sequelizeTypescript.transaction(async t => {
 120     const follower = await ActorModel.loadByUrl(actorUrl, t)
 121     const following = await ActorModel.loadByUrl(followActivity.object, t)
 122     const actorFollow = await ActorFollowModel.loadByActorAndTarget(follower.id, following.id, t)
 123
 124     if (!actorFollow) throw new Error(`'Unknown actor follow ${follower.id} -> ${following.id}.`)
 125
 126     await actorFollow.destroy({ transaction: t })
 127
 128     return undefined
 129   })
 130 }
 131
 132 function processUndoAnnounce (actorUrl: string, announceActivity: ActivityAnnounce) {
 133   const options = {
 134     arguments: [ actorUrl, announceActivity ],
 135     errorMessage: 'Cannot undo announce with many retries.'
 136   }
 137
 138   return retryTransactionWrapper(undoAnnounce, options)
 139 }
 140
 141 function undoAnnounce (actorUrl: string, announceActivity: ActivityAnnounce) {
 142   return sequelizeTypescript.transaction(async t => {
 143     const byAccount = await AccountModel.loadByUrl(actorUrl, t)
 144     if (!byAccount) throw new Error('Unknown account ' + actorUrl)
 145
 146     const share = await VideoShareModel.loadByUrl(announceActivity.id, t)
 147     if (!share) throw new Error(`'Unknown video share ${announceActivity.id}.`)
 148
 149     await share.destroy({ transaction: t })
 150
 151     if (share.Video.isOwned()) {
 152       // Don't resend the activity to the sender
 153       const exceptions = [ byAccount.Actor ]
 154
 155       await forwardVideoRelatedActivity(announceActivity, t, exceptions, share.Video)
 156     }
 157   })
 158 }