-import { ActivityAnnounce, ActivityFollow, ActivityLike, ActivityUndo } from '../../../../shared/models/activitypub'
+import { ActivityAnnounce, ActivityFollow, ActivityLike, ActivityUndo, CacheFileObject } from '../../../../shared/models/activitypub'
import { DislikeObject } from '../../../../shared/models/activitypub/objects'
import { getActorUrl } from '../../../helpers/activitypub'
import { retryTransactionWrapper } from '../../../helpers/database-utils'
import { forwardVideoRelatedActivity } from '../send/utils'
import { getOrCreateVideoAndAccountAndChannel } from '../videos'
import { VideoShareModel } from '../../../models/video/video-share'
+import { VideoRedundancyModel } from '../../../models/redundancy/video-redundancy'
-async function processUndoActivity (activity: ActivityUndo) {
+async function processUndoActivity (activity: ActivityUndo, byActor: ActorModel) {
const activityToUndo = activity.object
const actorUrl = getActorUrl(activity.actor)
if (activityToUndo.type === 'Like') {
return retryTransactionWrapper(processUndoLike, actorUrl, activity)
- } else if (activityToUndo.type === 'Create' && activityToUndo.object.type === 'Dislike') {
- return retryTransactionWrapper(processUndoDislike, actorUrl, activity)
- } else if (activityToUndo.type === 'Follow') {
- return retryTransactionWrapper(processUndoFollow, actorUrl, activityToUndo)
- } else if (activityToUndo.type === 'Announce') {
- return retryTransactionWrapper(processUndoAnnounce, actorUrl, activityToUndo)
+ }
+
+ if (activityToUndo.type === 'Create') {
+ if (activityToUndo.object.type === 'Dislike') {
+ return retryTransactionWrapper(processUndoDislike, actorUrl, activity)
+ } else if (activityToUndo.object.type === 'CacheFile') {
+ return retryTransactionWrapper(processUndoCacheFile, byActor, activity)
+ }
+ }
+
+ if (activityToUndo.type === 'Follow') {
+ return retryTransactionWrapper(processUndoFollow, byActor, activityToUndo)
+ }
+
+ if (activityToUndo.type === 'Announce') {
+ return retryTransactionWrapper(processUndoAnnounce, byActor, activityToUndo)
}
logger.warn('Unknown activity object type %s -> %s when undo activity.', activityToUndo.type, { activity: activity.id })
async function processUndoLike (actorUrl: string, activity: ActivityUndo) {
const likeActivity = activity.object as ActivityLike
- const { video } = await getOrCreateVideoAndAccountAndChannel(likeActivity.object)
+ const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: likeActivity.object })
return sequelizeTypescript.transaction(async t => {
const byAccount = await AccountModel.loadByUrl(actorUrl, t)
async function processUndoDislike (actorUrl: string, activity: ActivityUndo) {
const dislike = activity.object.object as DislikeObject
- const { video } = await getOrCreateVideoAndAccountAndChannel(dislike.object)
+ const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: dislike.object })
return sequelizeTypescript.transaction(async t => {
const byAccount = await AccountModel.loadByUrl(actorUrl, t)
})
}
-function processUndoFollow (actorUrl: string, followActivity: ActivityFollow) {
+async function processUndoCacheFile (byActor: ActorModel, activity: ActivityUndo) {
+ const cacheFileObject = activity.object.object as CacheFileObject
+
+ const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: cacheFileObject.object })
+
+ return sequelizeTypescript.transaction(async t => {
+ const cacheFile = await VideoRedundancyModel.loadByUrl(cacheFileObject.id)
+ if (!cacheFile) throw new Error('Unknown video cache ' + cacheFile.url)
+
+ await cacheFile.destroy()
+
+ if (video.isOwned()) {
+ // Don't resend the activity to the sender
+ const exceptions = [ byActor ]
+
+ await forwardVideoRelatedActivity(activity, t, exceptions, video)
+ }
+ })
+}
+
+function processUndoFollow (follower: ActorModel, followActivity: ActivityFollow) {
return sequelizeTypescript.transaction(async t => {
- const follower = await ActorModel.loadByUrl(actorUrl, t)
- const following = await ActorModel.loadByUrl(followActivity.object, t)
+ const following = await ActorModel.loadByUrlAndPopulateAccountAndChannel(followActivity.object, t)
const actorFollow = await ActorFollowModel.loadByActorAndTarget(follower.id, following.id, t)
if (!actorFollow) throw new Error(`'Unknown actor follow ${follower.id} -> ${following.id}.`)
})
}
-function processUndoAnnounce (actorUrl: string, announceActivity: ActivityAnnounce) {
+function processUndoAnnounce (byActor: ActorModel, announceActivity: ActivityAnnounce) {
return sequelizeTypescript.transaction(async t => {
- const byActor = await ActorModel.loadByUrl(actorUrl, t)
- if (!byActor) throw new Error('Unknown actor ' + actorUrl)
-
const share = await VideoShareModel.loadByUrl(announceActivity.id, t)
if (!share) throw new Error(`Unknown video share ${announceActivity.id}.`)