server/lib/activitypub/share.ts

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