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

   1 import { ActivityFollow, ActivityLike, ActivityUndo } from '../../../../shared/models/activitypub/activity'
   2 import { DislikeObject } from '../../../../shared/models/activitypub/objects/dislike-object'
   3 import { retryTransactionWrapper } from '../../../helpers/database-utils'
   4 import { logger } from '../../../helpers/logger'
   5 import { database as db } from '../../../initializers'
   6 import { sendUndoDislikeToVideoFollowers } from '../index'
   7 import { sendUndoLikeToVideoFollowers } from '../send/send-undo'
   8
   9 async function processUndoActivity (activity: ActivityUndo) {
  10   const activityToUndo = activity.object
  11
  12   if (activityToUndo.type === 'Like') {
  13     return processUndoLike(activity.actor, activityToUndo)
  14   } else if (activityToUndo.type === 'Create' && activityToUndo.object.type === 'Dislike') {
  15     return processUndoDislike(activity.actor, activityToUndo.object)
  16   } else if (activityToUndo.type === 'Follow') {
  17     return processUndoFollow(activity.actor, activityToUndo)
  18   }
  19
  20   logger.warn('Unknown activity object type %s -> %s when undo activity.', activityToUndo.type, { activity: activity.id })
  21
  22   return undefined
  23 }
  24
  25 // ---------------------------------------------------------------------------
  26
  27 export {
  28   processUndoActivity
  29 }
  30
  31 // ---------------------------------------------------------------------------
  32
  33 function processUndoLike (actor: string, likeActivity: ActivityLike) {
  34   const options = {
  35     arguments: [ actor, likeActivity ],
  36     errorMessage: 'Cannot undo like with many retries.'
  37   }
  38
  39   return retryTransactionWrapper(undoLike, options)
  40 }
  41
  42 function undoLike (actor: string, likeActivity: ActivityLike) {
  43   return db.sequelize.transaction(async t => {
  44     const byAccount = await db.Account.loadByUrl(actor, t)
  45     if (!byAccount) throw new Error('Unknown account ' + actor)
  46
  47     const video = await db.Video.loadByUrlAndPopulateAccount(likeActivity.object)
  48     if (!video) throw new Error('Unknown video ' + likeActivity.actor)
  49
  50     const rate = await db.AccountVideoRate.load(byAccount.id, video.id, t)
  51     if (!rate) throw new Error(`Unknown rate by account ${byAccount.id} for video ${video.id}.`)
  52
  53     await rate.destroy({ transaction: t })
  54     await video.decrement('likes')
  55
  56     if (video.isOwned()) await sendUndoLikeToVideoFollowers(byAccount, video, t)
  57   })
  58 }
  59
  60 function processUndoDislike (actor: string, dislikeCreateActivity: DislikeObject) {
  61   const options = {
  62     arguments: [ actor, dislikeCreateActivity ],
  63     errorMessage: 'Cannot undo dislike with many retries.'
  64   }
  65
  66   return retryTransactionWrapper(undoDislike, options)
  67 }
  68
  69 function undoDislike (actor: string, dislike: DislikeObject) {
  70   return db.sequelize.transaction(async t => {
  71     const byAccount = await db.Account.loadByUrl(actor, t)
  72     if (!byAccount) throw new Error('Unknown account ' + actor)
  73
  74     const video = await db.Video.loadByUrlAndPopulateAccount(dislike.object)
  75     if (!video) throw new Error('Unknown video ' + dislike.actor)
  76
  77     const rate = await db.AccountVideoRate.load(byAccount.id, video.id, t)
  78     if (!rate) throw new Error(`Unknown rate by account ${byAccount.id} for video ${video.id}.`)
  79
  80     await rate.destroy({ transaction: t })
  81     await video.decrement('dislikes')
  82
  83     if (video.isOwned()) await sendUndoDislikeToVideoFollowers(byAccount, video, t)
  84   })
  85 }
  86
  87 function processUndoFollow (actor: string, followActivity: ActivityFollow) {
  88   const options = {
  89     arguments: [ actor, followActivity ],
  90     errorMessage: 'Cannot undo follow with many retries.'
  91   }
  92
  93   return retryTransactionWrapper(undoFollow, options)
  94 }
  95
  96 function undoFollow (actor: string, followActivity: ActivityFollow) {
  97   return db.sequelize.transaction(async t => {
  98     const follower = await db.Account.loadByUrl(actor, t)
  99     const following = await db.Account.loadByUrl(followActivity.object, t)
 100     const accountFollow = await db.AccountFollow.loadByAccountAndTarget(follower.id, following.id, t)
 101
 102     if (!accountFollow) throw new Error(`'Unknown account follow ${follower.id} -> ${following.id}.`)
 103
 104     await accountFollow.destroy({ transaction: t })
 105
 106     return undefined
 107   })
 108 }