-
-import { checkUrlsSameHost, getAPId } from '@server/helpers/activitypub'
import { retryTransactionWrapper } from '@server/helpers/database-utils'
import { logger } from '@server/helpers/logger'
import { JobQueue } from '@server/lib/job-queue'
import { ActorLoadByUrlType, loadActorByUrl } from '@server/lib/model-loaders'
import { MActor, MActorAccountChannelId, MActorAccountChannelIdActor, MActorAccountId, MActorFullActor } from '@server/types/models'
import { ActivityPubActor } from '@shared/models'
+import { getAPId } from '../activity'
+import { checkUrlsSameHost } from '../url'
import { refreshActorIfNeeded } from './refresh'
import { APActorCreator, fetchRemoteActor } from './shared'
const { actorObject } = await fetchRemoteActor(actorUrl)
if (actorObject === undefined) throw new Error('Cannot fetch remote actor ' + actorUrl)
+ // actorUrl is just an alias/rediraction, so process object id instead
+ if (actorObject.id !== actorUrl) return getOrCreateAPActor(actorObject, 'all', recurseIfNeeded, updateCollections)
+
// Create the attributed to actor
// In PeerTube a video channel is owned by an account
let ownerActor: MActorFullActor
return actorRefreshed
}
+function getOrCreateAPOwner (actorObject: ActivityPubActor, actorUrl: string) {
+ const accountAttributedTo = actorObject.attributedTo.find(a => a.type === 'Person')
+ if (!accountAttributedTo) throw new Error('Cannot find account attributed to video channel ' + actorUrl)
+
+ if (checkUrlsSameHost(accountAttributedTo.id, actorUrl) !== true) {
+ throw new Error(`Account attributed to ${accountAttributedTo.id} does not have the same host than actor url ${actorUrl}`)
+ }
+
+ try {
+ // Don't recurse another time
+ const recurseIfNeeded = false
+ return getOrCreateAPActor(accountAttributedTo.id, 'all', recurseIfNeeded)
+ } catch (err) {
+ logger.error('Cannot get or create account attributed to video channel ' + actorUrl)
+ throw new Error(err)
+ }
+}
+
// ---------------------------------------------------------------------------
export {
+ getOrCreateAPOwner,
getOrCreateAPActor
}
return actor
}
-function getOrCreateAPOwner (actorObject: ActivityPubActor, actorUrl: string) {
- const accountAttributedTo = actorObject.attributedTo.find(a => a.type === 'Person')
- if (!accountAttributedTo) throw new Error('Cannot find account attributed to video channel ' + actorUrl)
-
- if (checkUrlsSameHost(accountAttributedTo.id, actorUrl) !== true) {
- throw new Error(`Account attributed to ${accountAttributedTo.id} does not have the same host than actor url ${actorUrl}`)
- }
-
- try {
- // Don't recurse another time
- const recurseIfNeeded = false
- return getOrCreateAPActor(accountAttributedTo.id, 'all', recurseIfNeeded)
- } catch (err) {
- logger.error('Cannot get or create account attributed to video channel ' + actorUrl)
- throw new Error(err)
- }
-}
-
async function scheduleOutboxFetchIfNeeded (actor: MActor, created: boolean, refreshed: boolean, updateCollections: boolean) {
if ((created === true || refreshed === true) && updateCollections === true) {
const payload = { uri: actor.outboxUrl, type: 'activity' as 'activity' }
async function schedulePlaylistFetchIfNeeded (actor: MActorAccountId, created: boolean, accountPlaylistsUrl: string) {
// We created a new account: fetch the playlists
if (created === true && actor.Account && accountPlaylistsUrl) {
- const payload = { uri: accountPlaylistsUrl, accountId: actor.Account.id, type: 'account-playlists' as 'account-playlists' }
+ const payload = { uri: accountPlaylistsUrl, type: 'account-playlists' as 'account-playlists' }
await JobQueue.Instance.createJobWithPromise({ type: 'activitypub-http-fetcher', payload })
}
}