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

155 lines
5.6 KiB
TypeScript
Raw Normal View History

2021-06-03 14:30:09 +02:00
import { isBlockedByServerOrAccount } from '@server/lib/blocklist'
import { isRedundancyAccepted } from '@server/lib/redundancy'
import { VideoModel } from '@server/models/video/video'
import { ActivityCreate, CacheFileObject, PlaylistObject, VideoCommentObject, VideoObject, WatchActionObject } from '@shared/models'
2017-12-28 11:16:08 +01:00
import { retryTransactionWrapper } from '../../../helpers/database-utils'
import { logger } from '../../../helpers/logger'
2020-05-07 14:58:24 +02:00
import { sequelizeTypescript } from '../../../initializers/database'
2020-06-18 10:45:25 +02:00
import { APProcessorOptions } from '../../../types/activitypub-processor.model'
import { MActorSignature, MCommentOwnerVideo, MVideoAccountLightBlacklistAllFiles } from '../../../types/models'
import { Notifier } from '../../notifier'
import { createOrUpdateCacheFile } from '../cache-file'
import { createOrUpdateLocalVideoViewer } from '../local-video-viewer'
2021-06-03 14:30:09 +02:00
import { createOrUpdateVideoPlaylist } from '../playlists'
import { forwardVideoRelatedActivity } from '../send/shared/send-utils'
import { resolveThread } from '../video-comments'
2021-06-02 15:47:05 +02:00
import { getOrCreateAPVideo } from '../videos'
2017-11-09 17:51:58 +01:00
2019-08-02 10:53:36 +02:00
async function processCreateActivity (options: APProcessorOptions<ActivityCreate>) {
const { activity, byActor } = options
// Only notify if it is not from a fetcher job
const notify = options.fromFetch !== true
2017-11-09 17:51:58 +01:00
const activityObject = activity.object
const activityType = activityObject.type
if (activityType === 'Video') {
2019-08-02 10:53:36 +02:00
return processCreateVideo(activity, notify)
}
if (activityType === 'Note') {
2021-11-16 10:05:12 +01:00
// Comments will be fetched from videos
if (options.fromFetch) return
2019-08-02 10:53:36 +02:00
return retryTransactionWrapper(processCreateVideoComment, activity, byActor, notify)
}
if (activityType === 'WatchAction') {
return retryTransactionWrapper(processCreateWatchAction, activity)
}
if (activityType === 'CacheFile') {
2019-02-26 10:55:40 +01:00
return retryTransactionWrapper(processCreateCacheFile, activity, byActor)
}
if (activityType === 'Playlist') {
return retryTransactionWrapper(processCreatePlaylist, activity, byActor)
2017-11-09 17:51:58 +01:00
}
logger.warn('Unknown activity object type %s when creating activity.', activityType, { activity: activity.id })
2017-11-10 14:34:45 +01:00
return Promise.resolve(undefined)
2017-11-09 17:51:58 +01:00
}
// ---------------------------------------------------------------------------
export {
processCreateActivity
}
// ---------------------------------------------------------------------------
2019-08-02 10:53:36 +02:00
async function processCreateVideo (activity: ActivityCreate, notify: boolean) {
2020-09-17 13:59:02 +02:00
const videoToCreateData = activity.object as VideoObject
2017-12-14 17:38:41 +01:00
const syncParam = { rates: false, shares: false, comments: false, thumbnail: true, refreshVideo: false }
2021-06-02 15:47:05 +02:00
const { video, created } = await getOrCreateAPVideo({ videoObject: videoToCreateData, syncParam })
2018-12-26 10:36:24 +01:00
2019-08-02 10:53:36 +02:00
if (created && notify) Notifier.Instance.notifyOnNewVideoIfNeeded(video)
2017-12-14 17:38:41 +01:00
return video
}
2019-08-15 11:53:26 +02:00
async function processCreateCacheFile (activity: ActivityCreate, byActor: MActorSignature) {
if (await isRedundancyAccepted(activity, byActor) !== true) return
2018-09-11 16:27:07 +02:00
const cacheFile = activity.object as CacheFileObject
2021-06-02 15:47:05 +02:00
const { video } = await getOrCreateAPVideo({ videoObject: cacheFile.object })
2018-09-11 16:27:07 +02:00
await sequelizeTypescript.transaction(async t => {
2018-10-02 14:39:35 +02:00
return createOrUpdateCacheFile(cacheFile, video, byActor, t)
})
2018-09-11 16:27:07 +02:00
if (video.isOwned()) {
// Don't resend the activity to the sender
const exceptions = [ byActor ]
await forwardVideoRelatedActivity(activity, undefined, exceptions, video)
2018-09-11 16:27:07 +02:00
}
}
async function processCreateWatchAction (activity: ActivityCreate) {
const watchAction = activity.object as WatchActionObject
if (watchAction.actionStatus !== 'CompletedActionStatus') return
const video = await VideoModel.loadByUrl(watchAction.object)
if (video.remote) return
await sequelizeTypescript.transaction(async t => {
return createOrUpdateLocalVideoViewer(watchAction, video, t)
})
}
2019-08-15 11:53:26 +02:00
async function processCreateVideoComment (activity: ActivityCreate, byActor: MActorSignature, notify: boolean) {
const commentObject = activity.object as VideoCommentObject
const byAccount = byActor.Account
if (!byAccount) throw new Error('Cannot create video comment with the non account actor ' + byActor.url)
2019-08-20 13:52:49 +02:00
let video: MVideoAccountLightBlacklistAllFiles
2019-08-06 17:19:53 +02:00
let created: boolean
2019-08-15 11:53:26 +02:00
let comment: MCommentOwnerVideo
2022-09-23 11:38:18 +02:00
try {
2019-08-06 17:19:53 +02:00
const resolveThreadResult = await resolveThread({ url: commentObject.id, isVideo: false })
2022-09-23 11:38:18 +02:00
if (!resolveThreadResult) return // Comment not accepted
video = resolveThreadResult.video
2019-08-06 17:19:53 +02:00
created = resolveThreadResult.commentCreated
comment = resolveThreadResult.comment
} catch (err) {
logger.debug(
'Cannot process video comment because we could not resolve thread %s. Maybe it was not a video thread, so skip it.',
commentObject.inReplyTo,
{ err }
)
return
}
2018-01-10 17:18:12 +01:00
// Try to not forward unwanted comments on our videos
if (video.isOwned()) {
if (await isBlockedByServerOrAccount(comment.Account, video.VideoChannel.Account)) {
logger.info('Skip comment forward from blocked account or server %s.', comment.Account.Actor.url)
return
}
if (created === true) {
// Don't resend the activity to the sender
const exceptions = [ byActor ]
2018-01-08 10:00:35 +01:00
await forwardVideoRelatedActivity(activity, undefined, exceptions, video)
}
}
2018-12-26 10:36:24 +01:00
2019-08-02 10:53:36 +02:00
if (created && notify) Notifier.Instance.notifyOnNewComment(comment)
}
2019-02-26 10:55:40 +01:00
2019-08-15 11:53:26 +02:00
async function processCreatePlaylist (activity: ActivityCreate, byActor: MActorSignature) {
2019-02-26 10:55:40 +01:00
const playlistObject = activity.object as PlaylistObject
const byAccount = byActor.Account
if (!byAccount) throw new Error('Cannot create video playlist with the non account actor ' + byActor.url)
2021-06-17 16:02:38 +02:00
await createOrUpdateVideoPlaylist(playlistObject, activity.to)
2019-02-26 10:55:40 +01:00
}