From 2422c46b27790d94fd29a7092170cee5a1b56008 Mon Sep 17 00:00:00 2001
From: Chocobozzz <me@florianbigard.com>
Date: Thu, 15 Feb 2018 14:46:26 +0100
Subject: Implement support field in video and video channel

---
 server/lib/activitypub/actor.ts                  | 13 ++++--
 server/lib/activitypub/process/process-update.ts | 52 ++++++++++++++----------
 server/lib/activitypub/send/send-update.ts       | 23 +++++++----
 server/lib/activitypub/videos.ts                 |  6 +++
 4 files changed, 62 insertions(+), 32 deletions(-)

(limited to 'server/lib/activitypub')

diff --git a/server/lib/activitypub/actor.ts b/server/lib/activitypub/actor.ts
index c3255d8ca..897acee85 100644
--- a/server/lib/activitypub/actor.ts
+++ b/server/lib/activitypub/actor.ts
@@ -225,12 +225,10 @@ function saveActorAndServerAndModelIfNotExist (
     })
 
     if (actorCreated.type === 'Person' || actorCreated.type === 'Application') {
-      const account = await saveAccount(actorCreated, result, t)
-      actorCreated.Account = account
+      actorCreated.Account = await saveAccount(actorCreated, result, t)
       actorCreated.Account.Actor = actorCreated
     } else if (actorCreated.type === 'Group') { // Video channel
-      const videoChannel = await saveVideoChannel(actorCreated, result, ownerActor, t)
-      actorCreated.VideoChannel = videoChannel
+      actorCreated.VideoChannel = await saveVideoChannel(actorCreated, result, ownerActor, t)
       actorCreated.VideoChannel.Actor = actorCreated
     }
 
@@ -242,6 +240,7 @@ type FetchRemoteActorResult = {
   actor: ActorModel
   name: string
   summary: string
+  support?: string
   avatarName?: string
   attributedTo: ActivityPubAttributedTo[]
 }
@@ -290,6 +289,7 @@ async function fetchRemoteActor (actorUrl: string): Promise<FetchRemoteActorResu
     name,
     avatarName,
     summary: actorJSON.summary,
+    support: actorJSON.support,
     attributedTo: actorJSON.attributedTo
   }
 }
@@ -298,6 +298,7 @@ async function saveAccount (actor: ActorModel, result: FetchRemoteActorResult, t
   const [ accountCreated ] = await AccountModel.findOrCreate({
     defaults: {
       name: result.name,
+      description: result.summary,
       actorId: actor.id
     },
     where: {
@@ -314,6 +315,7 @@ async function saveVideoChannel (actor: ActorModel, result: FetchRemoteActorResu
     defaults: {
       name: result.name,
       description: result.summary,
+      support: result.support,
       actorId: actor.id,
       accountId: ownerActor.Account.id
     },
@@ -352,11 +354,14 @@ async function refreshActorIfNeeded (actor: ActorModel) {
         await actor.save({ transaction: t })
 
         actor.Account.set('name', result.name)
+        actor.Account.set('description', result.summary)
         await actor.Account.save({ transaction: t })
       } else if (actor.VideoChannel) {
         await actor.save({ transaction: t })
 
         actor.VideoChannel.set('name', result.name)
+        actor.VideoChannel.set('description', result.summary)
+        actor.VideoChannel.set('support', result.support)
         await actor.VideoChannel.save({ transaction: t })
       }
 
diff --git a/server/lib/activitypub/process/process-update.ts b/server/lib/activitypub/process/process-update.ts
index c7ad412bc..566e5938b 100644
--- a/server/lib/activitypub/process/process-update.ts
+++ b/server/lib/activitypub/process/process-update.ts
@@ -9,20 +9,24 @@ import { sequelizeTypescript } from '../../../initializers'
 import { AccountModel } from '../../../models/account/account'
 import { ActorModel } from '../../../models/activitypub/actor'
 import { TagModel } from '../../../models/video/tag'
+import { VideoChannelModel } from '../../../models/video/video-channel'
 import { VideoFileModel } from '../../../models/video/video-file'
 import { fetchAvatarIfExists, getOrCreateActorAndServerAndModel, updateActorAvatarInstance, updateActorInstance } from '../actor'
 import {
-  generateThumbnailFromUrl, getOrCreateAccountAndVideoAndChannel, videoActivityObjectToDBAttributes,
+  generateThumbnailFromUrl,
+  getOrCreateAccountAndVideoAndChannel,
+  videoActivityObjectToDBAttributes,
   videoFileActivityUrlToDBAttributes
 } from '../videos'
 
 async function processUpdateActivity (activity: ActivityUpdate) {
   const actor = await getOrCreateActorAndServerAndModel(activity.actor)
+  const objectType = activity.object.type
 
-  if (activity.object.type === 'Video') {
+  if (objectType === 'Video') {
     return processUpdateVideo(actor, activity)
-  } else if (activity.object.type === 'Person') {
-    return processUpdateAccount(actor, activity)
+  } else if (objectType === 'Person' || objectType === 'Application' || objectType === 'Group') {
+    return processUpdateActor(actor, activity)
   }
 
   return
@@ -75,6 +79,7 @@ async function updateRemoteVideo (actor: ActorModel, activity: ActivityUpdate) {
       videoInstance.set('licence', videoData.licence)
       videoInstance.set('language', videoData.language)
       videoInstance.set('description', videoData.description)
+      videoInstance.set('support', videoData.support)
       videoInstance.set('nsfw', videoData.nsfw)
       videoInstance.set('commentsEnabled', videoData.commentsEnabled)
       videoInstance.set('duration', videoData.duration)
@@ -117,33 +122,36 @@ async function updateRemoteVideo (actor: ActorModel, activity: ActivityUpdate) {
   }
 }
 
-function processUpdateAccount (actor: ActorModel, activity: ActivityUpdate) {
+function processUpdateActor (actor: ActorModel, activity: ActivityUpdate) {
   const options = {
     arguments: [ actor, activity ],
-    errorMessage: 'Cannot update the remote account with many retries'
+    errorMessage: 'Cannot update the remote actor with many retries'
   }
 
-  return retryTransactionWrapper(updateRemoteAccount, options)
+  return retryTransactionWrapper(updateRemoteActor, options)
 }
 
-async function updateRemoteAccount (actor: ActorModel, activity: ActivityUpdate) {
-  const accountAttributesToUpdate = activity.object as ActivityPubActor
+async function updateRemoteActor (actor: ActorModel, activity: ActivityUpdate) {
+  const actorAttributesToUpdate = activity.object as ActivityPubActor
 
-  logger.debug('Updating remote account "%s".', accountAttributesToUpdate.uuid)
-  let accountInstance: AccountModel
+  logger.debug('Updating remote account "%s".', actorAttributesToUpdate.uuid)
+  let accountOrChannelInstance: AccountModel | VideoChannelModel
   let actorFieldsSave: object
-  let accountFieldsSave: object
+  let accountOrChannelFieldsSave: object
 
   // Fetch icon?
-  const avatarName = await fetchAvatarIfExists(accountAttributesToUpdate)
+  const avatarName = await fetchAvatarIfExists(actorAttributesToUpdate)
 
   try {
     await sequelizeTypescript.transaction(async t => {
       actorFieldsSave = actor.toJSON()
-      accountInstance = actor.Account
-      accountFieldsSave = actor.Account.toJSON()
 
-      await updateActorInstance(actor, accountAttributesToUpdate)
+      if (actorAttributesToUpdate.type === 'Group') accountOrChannelInstance = actor.VideoChannel
+      else accountOrChannelInstance = actor.Account
+
+      accountOrChannelFieldsSave = accountOrChannelInstance.toJSON()
+
+      await updateActorInstance(actor, actorAttributesToUpdate)
 
       if (avatarName !== undefined) {
         await updateActorAvatarInstance(actor, avatarName, t)
@@ -151,18 +159,20 @@ async function updateRemoteAccount (actor: ActorModel, activity: ActivityUpdate)
 
       await actor.save({ transaction: t })
 
-      actor.Account.set('name', accountAttributesToUpdate.name || accountAttributesToUpdate.preferredUsername)
-      await actor.Account.save({ transaction: t })
+      accountOrChannelInstance.set('name', actorAttributesToUpdate.name || actorAttributesToUpdate.preferredUsername)
+      accountOrChannelInstance.set('description', actorAttributesToUpdate.summary)
+      accountOrChannelInstance.set('support', actorAttributesToUpdate.support)
+      await accountOrChannelInstance.save({ transaction: t })
     })
 
-    logger.info('Remote account with uuid %s updated', accountAttributesToUpdate.uuid)
+    logger.info('Remote account with uuid %s updated', actorAttributesToUpdate.uuid)
   } catch (err) {
     if (actor !== undefined && actorFieldsSave !== undefined) {
       resetSequelizeInstance(actor, actorFieldsSave)
     }
 
-    if (accountInstance !== undefined && accountFieldsSave !== undefined) {
-      resetSequelizeInstance(accountInstance, accountFieldsSave)
+    if (accountOrChannelInstance !== undefined && accountOrChannelFieldsSave !== undefined) {
+      resetSequelizeInstance(accountOrChannelInstance, accountOrChannelFieldsSave)
     }
 
     // This is just a debug because we will retry the insert
diff --git a/server/lib/activitypub/send/send-update.ts b/server/lib/activitypub/send/send-update.ts
index e8f11edd0..622648308 100644
--- a/server/lib/activitypub/send/send-update.ts
+++ b/server/lib/activitypub/send/send-update.ts
@@ -1,9 +1,10 @@
 import { Transaction } from 'sequelize'
 import { ActivityAudience, ActivityUpdate } from '../../../../shared/models/activitypub'
 import { VideoPrivacy } from '../../../../shared/models/videos'
-import { UserModel } from '../../../models/account/user'
+import { AccountModel } from '../../../models/account/account'
 import { ActorModel } from '../../../models/activitypub/actor'
 import { VideoModel } from '../../../models/video/video'
+import { VideoChannelModel } from '../../../models/video/video-channel'
 import { VideoShareModel } from '../../../models/video/video-share'
 import { getUpdateActivityPubUrl } from '../url'
 import { audiencify, broadcastToFollowers, getAudience } from './misc'
@@ -23,15 +24,23 @@ async function sendUpdateVideo (video: VideoModel, t: Transaction) {
   return broadcastToFollowers(data, byActor, actorsInvolved, t)
 }
 
-async function sendUpdateUser (user: UserModel, t: Transaction) {
-  const byActor = user.Account.Actor
+async function sendUpdateActor (accountOrChannel: AccountModel | VideoChannelModel, t: Transaction) {
+  const byActor = accountOrChannel.Actor
 
   const url = getUpdateActivityPubUrl(byActor.url, byActor.updatedAt.toISOString())
-  const accountObject = user.Account.toActivityPubObject()
+  const accountOrChannelObject = accountOrChannel.toActivityPubObject()
   const audience = await getAudience(byActor, t)
-  const data = await updateActivityData(url, byActor, accountObject, t, audience)
+  const data = await updateActivityData(url, byActor, accountOrChannelObject, t, audience)
+
+  let actorsInvolved: ActorModel[]
+  if (accountOrChannel instanceof AccountModel) {
+    // Actors that shared my videos are involved too
+    actorsInvolved = await VideoShareModel.loadActorsByVideoOwner(byActor.id, t)
+  } else {
+    // Actors that shared videos of my channel are involved too
+    actorsInvolved = await VideoShareModel.loadActorsByVideoChannel(accountOrChannel.id, t)
+  }
 
-  const actorsInvolved = await VideoShareModel.loadActorsByVideoOwner(byActor.id, t)
   actorsInvolved.push(byActor)
 
   return broadcastToFollowers(data, byActor, actorsInvolved, t)
@@ -40,7 +49,7 @@ async function sendUpdateUser (user: UserModel, t: Transaction) {
 // ---------------------------------------------------------------------------
 
 export {
-  sendUpdateUser,
+  sendUpdateActor,
   sendUpdateVideo
 }
 
diff --git a/server/lib/activitypub/videos.ts b/server/lib/activitypub/videos.ts
index 40e9318e3..e65362190 100644
--- a/server/lib/activitypub/videos.ts
+++ b/server/lib/activitypub/videos.ts
@@ -83,6 +83,11 @@ async function videoActivityObjectToDBAttributes (videoChannel: VideoChannelMode
     description = videoObject.content
   }
 
+  let support = null
+  if (videoObject.support) {
+    support = videoObject.support
+  }
+
   return {
     name: videoObject.name,
     uuid: videoObject.uuid,
@@ -91,6 +96,7 @@ async function videoActivityObjectToDBAttributes (videoChannel: VideoChannelMode
     licence,
     language,
     description,
+    support,
     nsfw: videoObject.sensitive,
     commentsEnabled: videoObject.commentsEnabled,
     channelId: videoChannel.id,
-- 
cgit v1.2.3