server/lib/activitypub/share.ts

   1 import { map } from 'bluebird'
   2 import { Transaction } from 'sequelize'
   3 import { getServerActor } from '@server/models/application/application'
   4 import { logger, loggerTagsFactory } from '../../helpers/logger'
   5 import { doJSONRequest } from '../../helpers/requests'
   6 import { CRAWL_REQUEST_CONCURRENCY } from '../../initializers/constants'
   7 import { VideoShareModel } from '../../models/video/video-share'
   8 import { MChannelActorLight, MVideo, MVideoAccountLight, MVideoId } from '../../types/models/video'
   9 import { getAPId } from './activity'
  10 import { getOrCreateAPActor } from './actors'
  11 import { sendUndoAnnounce, sendVideoAnnounce } from './send'
  12 import { checkUrlsSameHost, getLocalVideoAnnounceActivityPubUrl } from './url'
  13
  14 const lTags = loggerTagsFactory('share')
  15
  16 async function shareVideoByServerAndChannel (video: MVideoAccountLight, t: Transaction) {
  17   if (!video.hasPrivacyForFederation()) return undefined
  18
  19   return Promise.all([
  20     shareByServer(video, t),
  21     shareByVideoChannel(video, t)
  22   ])
  23 }
  24
  25 async function changeVideoChannelShare (
  26   video: MVideoAccountLight,
  27   oldVideoChannel: MChannelActorLight,
  28   t: Transaction
  29 ) {
  30   logger.info(
  31     'Updating video channel of video %s: %s -> %s.', video.uuid, oldVideoChannel.name, video.VideoChannel.name,
  32     lTags(video.uuid)
  33   )
  34
  35   await undoShareByVideoChannel(video, oldVideoChannel, t)
  36
  37   await shareByVideoChannel(video, t)
  38 }
  39
  40 async function addVideoShares (shareUrls: string[], video: MVideoId) {
  41   await map(shareUrls, async shareUrl => {
  42     try {
  43       await addVideoShare(shareUrl, video)
  44     } catch (err) {
  45       logger.warn('Cannot add share %s.', shareUrl, { err })
  46     }
  47   }, { concurrency: CRAWL_REQUEST_CONCURRENCY })
  48 }
  49
  50 export {
  51   changeVideoChannelShare,
  52   addVideoShares,
  53   shareVideoByServerAndChannel
  54 }
  55
  56 // ---------------------------------------------------------------------------
  57
  58 async function addVideoShare (shareUrl: string, video: MVideoId) {
  59   const { body } = await doJSONRequest<any>(shareUrl, { activityPub: true })
  60   if (!body?.actor) throw new Error('Body or body actor is invalid')
  61
  62   const actorUrl = getAPId(body.actor)
  63   if (checkUrlsSameHost(shareUrl, actorUrl) !== true) {
  64     throw new Error(`Actor url ${actorUrl} has not the same host than the share url ${shareUrl}`)
  65   }
  66
  67   const actor = await getOrCreateAPActor(actorUrl)
  68
  69   const entry = {
  70     actorId: actor.id,
  71     videoId: video.id,
  72     url: shareUrl
  73   }
  74
  75   await VideoShareModel.upsert(entry)
  76 }
  77
  78 async function shareByServer (video: MVideo, t: Transaction) {
  79   const serverActor = await getServerActor()
  80
  81   const serverShareUrl = getLocalVideoAnnounceActivityPubUrl(serverActor, video)
  82   const [ serverShare ] = await VideoShareModel.findOrCreate({
  83     defaults: {
  84       actorId: serverActor.id,
  85       videoId: video.id,
  86       url: serverShareUrl
  87     },
  88     where: {
  89       url: serverShareUrl
  90     },
  91     transaction: t
  92   })
  93
  94   return sendVideoAnnounce(serverActor, serverShare, video, t)
  95 }
  96
  97 async function shareByVideoChannel (video: MVideoAccountLight, t: Transaction) {
  98   const videoChannelShareUrl = getLocalVideoAnnounceActivityPubUrl(video.VideoChannel.Actor, video)
  99   const [ videoChannelShare ] = await VideoShareModel.findOrCreate({
 100     defaults: {
 101       actorId: video.VideoChannel.actorId,
 102       videoId: video.id,
 103       url: videoChannelShareUrl
 104     },
 105     where: {
 106       url: videoChannelShareUrl
 107     },
 108     transaction: t
 109   })
 110
 111   return sendVideoAnnounce(video.VideoChannel.Actor, videoChannelShare, video, t)
 112 }
 113
 114 async function undoShareByVideoChannel (video: MVideo, oldVideoChannel: MChannelActorLight, t: Transaction) {
 115   // Load old share
 116   const oldShare = await VideoShareModel.load(oldVideoChannel.actorId, video.id, t)
 117   if (!oldShare) return new Error('Cannot find old video channel share ' + oldVideoChannel.actorId + ' for video ' + video.id)
 118
 119   await sendUndoAnnounce(oldVideoChannel.Actor, oldShare, video, t)
 120   await oldShare.destroy({ transaction: t })
 121 }