4 files changed, 276 insertions, 0 deletions

diff --git a/server/lib/activitypub/actors/shared/creator.ts b/server/lib/activitypub/actors/shared/creator.ts
new file mode 100644
index 000000000..999aed97d
--- /dev/null
+++ b/server/lib/activitypub/actors/shared/creator.ts
@@ -0,0 +1,149 @@
+import { Op, Transaction } from 'sequelize'
+import { sequelizeTypescript } from '@server/initializers/database'
+import { AccountModel } from '@server/models/account/account'
+import { ActorModel } from '@server/models/actor/actor'
+import { ServerModel } from '@server/models/server/server'
+import { VideoChannelModel } from '@server/models/video/video-channel'
+import { MAccount, MAccountDefault, MActor, MActorFullActor, MActorId, MActorImages, MChannel, MServer } from '@server/types/models'
+import { ActivityPubActor, ActorImageType } from '@shared/models'
+import { updateActorImageInstance } from '../image'
+import { getActorAttributesFromObject, getActorDisplayNameFromObject, getImageInfoFromObject } from './object-to-model-attributes'
+import { fetchActorFollowsCount } from './url-to-object'
+
+export class APActorCreator {
+
+  constructor (
+    private readonly actorObject: ActivityPubActor,
+    private readonly ownerActor?: MActorFullActor
+  ) {
+
+  }
+
+  async create (): Promise<MActorFullActor> {
+    const { followersCount, followingCount } = await fetchActorFollowsCount(this.actorObject)
+
+    const actorInstance = new ActorModel(getActorAttributesFromObject(this.actorObject, followersCount, followingCount))
+
+    return sequelizeTypescript.transaction(async t => {
+      const server = await this.setServer(actorInstance, t)
+
+      await this.setImageIfNeeded(actorInstance, ActorImageType.AVATAR, t)
+      await this.setImageIfNeeded(actorInstance, ActorImageType.BANNER, t)
+
+      const { actorCreated, created } = await this.saveActor(actorInstance, t)
+
+      await this.tryToFixActorUrlIfNeeded(actorCreated, actorInstance, created, t)
+
+      if (actorCreated.type === 'Person' || actorCreated.type === 'Application') { // Account or PeerTube instance
+        actorCreated.Account = await this.saveAccount(actorCreated, t) as MAccountDefault
+        actorCreated.Account.Actor = actorCreated
+      }
+
+      if (actorCreated.type === 'Group') { // Video channel
+        const channel = await this.saveVideoChannel(actorCreated, t)
+        actorCreated.VideoChannel = Object.assign(channel, { Actor: actorCreated, Account: this.ownerActor.Account })
+      }
+
+      actorCreated.Server = server
+
+      return actorCreated
+    })
+  }
+
+  private async setServer (actor: MActor, t: Transaction) {
+    const actorHost = new URL(actor.url).host
+
+    const serverOptions = {
+      where: {
+        host: actorHost
+      },
+      defaults: {
+        host: actorHost
+      },
+      transaction: t
+    }
+    const [ server ] = await ServerModel.findOrCreate(serverOptions)
+
+    // Save our new account in database
+    actor.serverId = server.id
+
+    return server as MServer
+  }
+
+  private async setImageIfNeeded (actor: MActor, type: ActorImageType, t: Transaction) {
+    const imageInfo = getImageInfoFromObject(this.actorObject, type)
+    if (!imageInfo) return
+
+    return updateActorImageInstance(actor as MActorImages, type, imageInfo, t)
+  }
+
+  private async saveActor (actor: MActor, t: Transaction) {
+    // Force the actor creation using findOrCreate() instead of save()
+    // Sometimes Sequelize skips the save() when it thinks the instance already exists
+    // (which could be false in a retried query)
+    const [ actorCreated, created ] = await ActorModel.findOrCreate<MActorFullActor>({
+      defaults: actor.toJSON(),
+      where: {
+        [Op.or]: [
+          {
+            url: actor.url
+          },
+          {
+            serverId: actor.serverId,
+            preferredUsername: actor.preferredUsername
+          }
+        ]
+      },
+      transaction: t
+    })
+
+    return { actorCreated, created }
+  }
+
+  private async tryToFixActorUrlIfNeeded (actorCreated: MActor, newActor: MActor, created: boolean, t: Transaction) {
+    // Try to fix non HTTPS accounts of remote instances that fixed their URL afterwards
+    if (created !== true && actorCreated.url !== newActor.url) {
+      // Only fix http://example.com/account/djidane to https://example.com/account/djidane
+      if (actorCreated.url.replace(/^http:\/\//, '') !== newActor.url.replace(/^https:\/\//, '')) {
+        throw new Error(`Actor from DB with URL ${actorCreated.url} does not correspond to actor ${newActor.url}`)
+      }
+
+      actorCreated.url = newActor.url
+      await actorCreated.save({ transaction: t })
+    }
+  }
+
+  private async saveAccount (actor: MActorId, t: Transaction) {
+    const [ accountCreated ] = await AccountModel.findOrCreate({
+      defaults: {
+        name: getActorDisplayNameFromObject(this.actorObject),
+        description: this.actorObject.summary,
+        actorId: actor.id
+      },
+      where: {
+        actorId: actor.id
+      },
+      transaction: t
+    })
+
+    return accountCreated as MAccount
+  }
+
+  private async saveVideoChannel (actor: MActorId, t: Transaction) {
+    const [ videoChannelCreated ] = await VideoChannelModel.findOrCreate({
+      defaults: {
+        name: getActorDisplayNameFromObject(this.actorObject),
+        description: this.actorObject.summary,
+        support: this.actorObject.support,
+        actorId: actor.id,
+        accountId: this.ownerActor.Account.id
+      },
+      where: {
+        actorId: actor.id
+      },
+      transaction: t
+    })
+
+    return videoChannelCreated as MChannel
+  }
+}
diff --git a/server/lib/activitypub/actors/shared/index.ts b/server/lib/activitypub/actors/shared/index.ts
new file mode 100644
index 000000000..a2ff468cf
--- /dev/null
+++ b/server/lib/activitypub/actors/shared/index.ts
@@ -0,0 +1,3 @@
+export * from './creator'
+export * from './url-to-object'
+export * from './object-to-model-attributes'
diff --git a/server/lib/activitypub/actors/shared/object-to-model-attributes.ts b/server/lib/activitypub/actors/shared/object-to-model-attributes.ts
new file mode 100644
index 000000000..66b22c952
--- /dev/null
+++ b/server/lib/activitypub/actors/shared/object-to-model-attributes.ts
@@ -0,0 +1,70 @@
+import { extname } from 'path'
+import { v4 as uuidv4 } from 'uuid'
+import { isActivityPubUrlValid } from '@server/helpers/custom-validators/activitypub/misc'
+import { MIMETYPES } from '@server/initializers/constants'
+import { ActorModel } from '@server/models/actor/actor'
+import { FilteredModelAttributes } from '@server/types'
+import { ActivityPubActor, ActorImageType } from '@shared/models'
+
+function getActorAttributesFromObject (
+  actorObject: ActivityPubActor,
+  followersCount: number,
+  followingCount: number
+): FilteredModelAttributes<ActorModel> {
+  return {
+    type: actorObject.type,
+    preferredUsername: actorObject.preferredUsername,
+    url: actorObject.id,
+    publicKey: actorObject.publicKey.publicKeyPem,
+    privateKey: null,
+    followersCount,
+    followingCount,
+    inboxUrl: actorObject.inbox,
+    outboxUrl: actorObject.outbox,
+    followersUrl: actorObject.followers,
+    followingUrl: actorObject.following,
+
+    sharedInboxUrl: actorObject.endpoints?.sharedInbox
+      ? actorObject.endpoints.sharedInbox
+      : null
+  }
+}
+
+function getImageInfoFromObject (actorObject: ActivityPubActor, type: ActorImageType) {
+  const mimetypes = MIMETYPES.IMAGE
+  const icon = type === ActorImageType.AVATAR
+    ? actorObject.icon
+    : actorObject.image
+
+  if (!icon || icon.type !== 'Image' || !isActivityPubUrlValid(icon.url)) return undefined
+
+  let extension: string
+
+  if (icon.mediaType) {
+    extension = mimetypes.MIMETYPE_EXT[icon.mediaType]
+  } else {
+    const tmp = extname(icon.url)
+
+    if (mimetypes.EXT_MIMETYPE[tmp] !== undefined) extension = tmp
+  }
+
+  if (!extension) return undefined
+
+  return {
+    name: uuidv4() + extension,
+    fileUrl: icon.url,
+    height: icon.height,
+    width: icon.width,
+    type
+  }
+}
+
+function getActorDisplayNameFromObject (actorObject: ActivityPubActor) {
+  return actorObject.name || actorObject.preferredUsername
+}
+
+export {
+  getActorAttributesFromObject,
+  getImageInfoFromObject,
+  getActorDisplayNameFromObject
+}
diff --git a/server/lib/activitypub/actors/shared/url-to-object.ts b/server/lib/activitypub/actors/shared/url-to-object.ts
new file mode 100644
index 000000000..f4f16b044
--- /dev/null
+++ b/server/lib/activitypub/actors/shared/url-to-object.ts
@@ -0,0 +1,54 @@
+
+import { checkUrlsSameHost } from '@server/helpers/activitypub'
+import { sanitizeAndCheckActorObject } from '@server/helpers/custom-validators/activitypub/actor'
+import { logger } from '@server/helpers/logger'
+import { doJSONRequest } from '@server/helpers/requests'
+import { ActivityPubActor, ActivityPubOrderedCollection } from '@shared/models'
+
+async function fetchRemoteActor (actorUrl: string): Promise<{ statusCode: number, actorObject: ActivityPubActor }> {
+  logger.info('Fetching remote actor %s.', actorUrl)
+
+  const { body, statusCode } = await doJSONRequest<ActivityPubActor>(actorUrl, { activityPub: true })
+
+  if (sanitizeAndCheckActorObject(body) === false) {
+    logger.debug('Remote actor JSON is not valid.', { actorJSON: body })
+    return { actorObject: undefined, statusCode: statusCode }
+  }
+
+  if (checkUrlsSameHost(body.id, actorUrl) !== true) {
+    logger.warn('Actor url %s has not the same host than its AP id %s', actorUrl, body.id)
+    return { actorObject: undefined, statusCode: statusCode }
+  }
+
+  return {
+    statusCode,
+
+    actorObject: body
+  }
+}
+
+async function fetchActorFollowsCount (actorObject: ActivityPubActor) {
+  const followersCount = await fetchActorTotalItems(actorObject.followers)
+  const followingCount = await fetchActorTotalItems(actorObject.following)
+
+  return { followersCount, followingCount }
+}
+
+// ---------------------------------------------------------------------------
+export {
+  fetchActorFollowsCount,
+  fetchRemoteActor
+}
+
+// ---------------------------------------------------------------------------
+
+async function fetchActorTotalItems (url: string) {
+  try {
+    const { body } = await doJSONRequest<ActivityPubOrderedCollection<unknown>>(url, { activityPub: true })
+
+    return body.totalItems || 0
+  } catch (err) {
+    logger.warn('Cannot fetch remote actor count %s.', url, { err })
+    return 0
+  }
+}