2018-09-11 16:27:07 +02:00
|
|
|
import { ActivityUpdate, CacheFileObject, VideoTorrentObject } from '../../../../shared/models/activitypub'
|
2018-01-03 16:38:50 +01:00
|
|
|
import { ActivityPubActor } from '../../../../shared/models/activitypub/activitypub-actor'
|
2018-08-14 15:28:30 +02:00
|
|
|
import { resetSequelizeInstance, retryTransactionWrapper } from '../../../helpers/database-utils'
|
2017-12-28 11:16:08 +01:00
|
|
|
import { logger } from '../../../helpers/logger'
|
2020-05-07 14:58:24 +02:00
|
|
|
import { sequelizeTypescript } from '../../../initializers/database'
|
2018-01-03 16:38:50 +01:00
|
|
|
import { AccountModel } from '../../../models/account/account'
|
2017-12-14 17:38:41 +01:00
|
|
|
import { ActorModel } from '../../../models/activitypub/actor'
|
2018-02-15 14:46:26 +01:00
|
|
|
import { VideoChannelModel } from '../../../models/video/video-channel'
|
2019-08-09 11:32:40 +02:00
|
|
|
import { getAvatarInfoIfExists, updateActorAvatarInstance, updateActorInstance } from '../actor'
|
2018-09-19 14:44:20 +02:00
|
|
|
import { getOrCreateVideoAndAccountAndChannel, getOrCreateVideoChannelFromVideoObject, updateVideoFromAP } from '../videos'
|
2018-06-13 10:06:50 +02:00
|
|
|
import { sanitizeAndCheckVideoTorrentObject } from '../../../helpers/custom-validators/activitypub/videos'
|
2018-09-11 16:27:07 +02:00
|
|
|
import { isCacheFileObjectValid } from '../../../helpers/custom-validators/activitypub/cache-file'
|
2018-10-02 14:39:35 +02:00
|
|
|
import { createOrUpdateCacheFile } from '../cache-file'
|
2018-09-24 13:07:33 +02:00
|
|
|
import { forwardVideoRelatedActivity } from '../send/utils'
|
2019-02-26 10:55:40 +01:00
|
|
|
import { PlaylistObject } from '../../../../shared/models/activitypub/objects/playlist-object'
|
|
|
|
import { createOrUpdateVideoPlaylist } from '../playlist'
|
2019-08-02 10:53:36 +02:00
|
|
|
import { APProcessorOptions } from '../../../typings/activitypub-processor.model'
|
2019-08-21 08:57:00 +02:00
|
|
|
import { MActorSignature, MAccountIdActor } from '../../../typings/models'
|
2020-04-07 15:27:41 +02:00
|
|
|
import { isRedundancyAccepted } from '@server/lib/redundancy'
|
2019-08-02 10:53:36 +02:00
|
|
|
|
|
|
|
async function processUpdateActivity (options: APProcessorOptions<ActivityUpdate>) {
|
|
|
|
const { activity, byActor } = options
|
2017-11-10 14:34:45 +01:00
|
|
|
|
2018-02-15 14:46:26 +01:00
|
|
|
const objectType = activity.object.type
|
2017-11-09 17:51:58 +01:00
|
|
|
|
2018-02-15 14:46:26 +01:00
|
|
|
if (objectType === 'Video') {
|
2018-09-19 14:44:20 +02:00
|
|
|
return retryTransactionWrapper(processUpdateVideo, byActor, activity)
|
2018-09-11 16:27:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (objectType === 'Person' || objectType === 'Application' || objectType === 'Group') {
|
2018-09-19 14:44:20 +02:00
|
|
|
// We need more attributes
|
|
|
|
const byActorFull = await ActorModel.loadByUrlAndPopulateAccountAndChannel(byActor.url)
|
|
|
|
return retryTransactionWrapper(processUpdateActor, byActorFull, activity)
|
2017-11-09 17:51:58 +01:00
|
|
|
}
|
2017-11-10 14:34:45 +01:00
|
|
|
|
2018-09-11 16:27:07 +02:00
|
|
|
if (objectType === 'CacheFile') {
|
2018-09-19 14:44:20 +02:00
|
|
|
// We need more attributes
|
|
|
|
const byActorFull = await ActorModel.loadByUrlAndPopulateAccountAndChannel(byActor.url)
|
|
|
|
return retryTransactionWrapper(processUpdateCacheFile, byActorFull, activity)
|
2018-09-11 16:27:07 +02:00
|
|
|
}
|
|
|
|
|
2019-02-26 10:55:40 +01:00
|
|
|
if (objectType === 'Playlist') {
|
|
|
|
return retryTransactionWrapper(processUpdatePlaylist, byActor, activity)
|
|
|
|
}
|
|
|
|
|
2018-06-13 10:06:50 +02:00
|
|
|
return undefined
|
2017-11-09 17:51:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
export {
|
|
|
|
processUpdateActivity
|
|
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
2019-08-15 11:53:26 +02:00
|
|
|
async function processUpdateVideo (actor: MActorSignature, activity: ActivityUpdate) {
|
2018-06-13 10:06:50 +02:00
|
|
|
const videoObject = activity.object as VideoTorrentObject
|
2017-12-14 17:38:41 +01:00
|
|
|
|
2018-06-13 10:06:50 +02:00
|
|
|
if (sanitizeAndCheckVideoTorrentObject(videoObject) === false) {
|
|
|
|
logger.debug('Video sent by update is not valid.', { videoObject })
|
|
|
|
return undefined
|
|
|
|
}
|
2018-06-12 20:04:58 +02:00
|
|
|
|
2019-08-15 11:53:26 +02:00
|
|
|
const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: videoObject.id, allowRefresh: false, fetchType: 'all' })
|
2018-08-23 17:58:39 +02:00
|
|
|
const channelActor = await getOrCreateVideoChannelFromVideoObject(videoObject)
|
2018-01-10 17:18:12 +01:00
|
|
|
|
2019-08-21 08:57:00 +02:00
|
|
|
const account = actor.Account as MAccountIdActor
|
|
|
|
account.Actor = actor
|
|
|
|
|
2018-09-19 11:41:21 +02:00
|
|
|
const updateOptions = {
|
|
|
|
video,
|
|
|
|
videoObject,
|
2019-08-21 08:57:00 +02:00
|
|
|
account,
|
2018-09-19 11:41:21 +02:00
|
|
|
channel: channelActor.VideoChannel,
|
|
|
|
overrideTo: activity.to
|
|
|
|
}
|
|
|
|
return updateVideoFromAP(updateOptions)
|
2018-09-11 16:27:07 +02:00
|
|
|
}
|
|
|
|
|
2019-08-15 11:53:26 +02:00
|
|
|
async function processUpdateCacheFile (byActor: MActorSignature, activity: ActivityUpdate) {
|
2020-04-07 15:27:41 +02:00
|
|
|
if (await isRedundancyAccepted(activity, byActor) !== true) return
|
|
|
|
|
2018-09-11 16:27:07 +02:00
|
|
|
const cacheFileObject = activity.object as CacheFileObject
|
|
|
|
|
2018-09-24 13:07:33 +02:00
|
|
|
if (!isCacheFileObjectValid(cacheFileObject)) {
|
|
|
|
logger.debug('Cache file object sent by update is not valid.', { cacheFileObject })
|
2018-09-11 16:27:07 +02:00
|
|
|
return undefined
|
|
|
|
}
|
|
|
|
|
2018-09-24 13:07:33 +02:00
|
|
|
const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: cacheFileObject.object })
|
|
|
|
|
|
|
|
await sequelizeTypescript.transaction(async t => {
|
2018-10-02 14:39:35 +02:00
|
|
|
await createOrUpdateCacheFile(cacheFileObject, video, byActor, t)
|
2018-09-24 13:07:33 +02:00
|
|
|
})
|
2018-09-11 16:27:07 +02:00
|
|
|
|
2018-09-24 13:07:33 +02:00
|
|
|
if (video.isOwned()) {
|
|
|
|
// Don't resend the activity to the sender
|
|
|
|
const exceptions = [ byActor ]
|
|
|
|
|
|
|
|
await forwardVideoRelatedActivity(activity, undefined, exceptions, video)
|
|
|
|
}
|
2017-11-10 14:34:45 +01:00
|
|
|
}
|
2018-01-03 16:38:50 +01:00
|
|
|
|
2018-06-13 14:27:40 +02:00
|
|
|
async function processUpdateActor (actor: ActorModel, activity: ActivityUpdate) {
|
2018-02-15 14:46:26 +01:00
|
|
|
const actorAttributesToUpdate = activity.object as ActivityPubActor
|
2018-01-03 16:38:50 +01:00
|
|
|
|
2019-05-31 14:02:26 +02:00
|
|
|
logger.debug('Updating remote account "%s".', actorAttributesToUpdate.url)
|
2018-02-15 14:46:26 +01:00
|
|
|
let accountOrChannelInstance: AccountModel | VideoChannelModel
|
2018-01-03 16:38:50 +01:00
|
|
|
let actorFieldsSave: object
|
2018-02-15 14:46:26 +01:00
|
|
|
let accountOrChannelFieldsSave: object
|
2018-01-03 16:38:50 +01:00
|
|
|
|
|
|
|
// Fetch icon?
|
2019-08-09 11:32:40 +02:00
|
|
|
const avatarInfo = await getAvatarInfoIfExists(actorAttributesToUpdate)
|
2018-01-03 16:38:50 +01:00
|
|
|
|
|
|
|
try {
|
|
|
|
await sequelizeTypescript.transaction(async t => {
|
2018-01-04 14:04:02 +01:00
|
|
|
actorFieldsSave = actor.toJSON()
|
2018-01-03 16:38:50 +01:00
|
|
|
|
2018-02-15 14:46:26 +01:00
|
|
|
if (actorAttributesToUpdate.type === 'Group') accountOrChannelInstance = actor.VideoChannel
|
|
|
|
else accountOrChannelInstance = actor.Account
|
|
|
|
|
|
|
|
accountOrChannelFieldsSave = accountOrChannelInstance.toJSON()
|
|
|
|
|
|
|
|
await updateActorInstance(actor, actorAttributesToUpdate)
|
2018-01-03 16:38:50 +01:00
|
|
|
|
2019-08-09 11:32:40 +02:00
|
|
|
if (avatarInfo !== undefined) {
|
|
|
|
const avatarOptions = Object.assign({}, avatarInfo, { onDisk: false })
|
|
|
|
|
|
|
|
await updateActorAvatarInstance(actor, avatarOptions, t)
|
2018-01-03 16:38:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
await actor.save({ transaction: t })
|
|
|
|
|
2019-04-18 11:28:17 +02:00
|
|
|
accountOrChannelInstance.name = actorAttributesToUpdate.name || actorAttributesToUpdate.preferredUsername
|
|
|
|
accountOrChannelInstance.description = actorAttributesToUpdate.summary
|
|
|
|
|
|
|
|
if (accountOrChannelInstance instanceof VideoChannelModel) accountOrChannelInstance.support = actorAttributesToUpdate.support
|
|
|
|
|
2018-02-15 14:46:26 +01:00
|
|
|
await accountOrChannelInstance.save({ transaction: t })
|
2018-01-03 16:38:50 +01:00
|
|
|
})
|
|
|
|
|
2019-05-31 14:02:26 +02:00
|
|
|
logger.info('Remote account %s updated', actorAttributesToUpdate.url)
|
2018-01-03 16:38:50 +01:00
|
|
|
} catch (err) {
|
2018-01-04 14:04:02 +01:00
|
|
|
if (actor !== undefined && actorFieldsSave !== undefined) {
|
|
|
|
resetSequelizeInstance(actor, actorFieldsSave)
|
2018-01-03 16:38:50 +01:00
|
|
|
}
|
|
|
|
|
2018-02-15 14:46:26 +01:00
|
|
|
if (accountOrChannelInstance !== undefined && accountOrChannelFieldsSave !== undefined) {
|
|
|
|
resetSequelizeInstance(accountOrChannelInstance, accountOrChannelFieldsSave)
|
2018-01-03 16:38:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// This is just a debug because we will retry the insert
|
2018-03-26 15:54:13 +02:00
|
|
|
logger.debug('Cannot update the remote account.', { err })
|
2018-01-03 16:38:50 +01:00
|
|
|
throw err
|
|
|
|
}
|
|
|
|
}
|
2019-02-26 10:55:40 +01:00
|
|
|
|
2019-08-15 11:53:26 +02:00
|
|
|
async function processUpdatePlaylist (byActor: MActorSignature, activity: ActivityUpdate) {
|
2019-02-26 10:55:40 +01:00
|
|
|
const playlistObject = activity.object as PlaylistObject
|
|
|
|
const byAccount = byActor.Account
|
|
|
|
|
|
|
|
if (!byAccount) throw new Error('Cannot update video playlist with the non account actor ' + byActor.url)
|
|
|
|
|
|
|
|
await createOrUpdateVideoPlaylist(playlistObject, byAccount, activity.to)
|
|
|
|
}
|