server/controllers/activitypub/client.ts

   1 // Intercept ActivityPub client requests
   2 import * as express from 'express'
   3 import { VideoPrivacy, VideoRateType } from '../../../shared/models/videos'
   4 import { activityPubCollectionPagination, activityPubContextify } from '../../helpers/activitypub'
   5 import { CONFIG, ROUTE_CACHE_LIFETIME } from '../../initializers'
   6 import { buildVideoAnnounce } from '../../lib/activitypub/send'
   7 import { audiencify, getAudience } from '../../lib/activitypub/audience'
   8 import { createActivityData } from '../../lib/activitypub/send/send-create'
   9 import { asyncMiddleware, executeIfActivityPub, localAccountValidator } from '../../middlewares'
  10 import { videoChannelsGetValidator, videosGetValidator, videosShareValidator } from '../../middlewares/validators'
  11 import { videoCommentGetValidator } from '../../middlewares/validators/video-comments'
  12 import { AccountModel } from '../../models/account/account'
  13 import { ActorModel } from '../../models/activitypub/actor'
  14 import { ActorFollowModel } from '../../models/activitypub/actor-follow'
  15 import { VideoModel } from '../../models/video/video'
  16 import { VideoChannelModel } from '../../models/video/video-channel'
  17 import { VideoCommentModel } from '../../models/video/video-comment'
  18 import { VideoShareModel } from '../../models/video/video-share'
  19 import { cacheRoute } from '../../middlewares/cache'
  20 import { activityPubResponse } from './utils'
  21 import { AccountVideoRateModel } from '../../models/account/account-video-rate'
  22 import {
  23   getVideoCommentsActivityPubUrl,
  24   getVideoDislikesActivityPubUrl,
  25   getVideoLikesActivityPubUrl,
  26   getVideoSharesActivityPubUrl
  27 } from '../../lib/activitypub'
  28
  29 const activityPubClientRouter = express.Router()
  30
  31 activityPubClientRouter.get('/accounts?/:name',
  32   executeIfActivityPub(asyncMiddleware(localAccountValidator)),
  33   executeIfActivityPub(accountController)
  34 )
  35 activityPubClientRouter.get('/accounts?/:name/followers',
  36   executeIfActivityPub(asyncMiddleware(localAccountValidator)),
  37   executeIfActivityPub(asyncMiddleware(accountFollowersController))
  38 )
  39 activityPubClientRouter.get('/accounts?/:name/following',
  40   executeIfActivityPub(asyncMiddleware(localAccountValidator)),
  41   executeIfActivityPub(asyncMiddleware(accountFollowingController))
  42 )
  43
  44 activityPubClientRouter.get('/videos/watch/:id',
  45   executeIfActivityPub(asyncMiddleware(cacheRoute(ROUTE_CACHE_LIFETIME.ACTIVITY_PUB.VIDEOS))),
  46   executeIfActivityPub(asyncMiddleware(videosGetValidator)),
  47   executeIfActivityPub(asyncMiddleware(videoController))
  48 )
  49 activityPubClientRouter.get('/videos/watch/:id/activity',
  50   executeIfActivityPub(asyncMiddleware(videosGetValidator)),
  51   executeIfActivityPub(asyncMiddleware(videoController))
  52 )
  53 activityPubClientRouter.get('/videos/watch/:id/announces',
  54   executeIfActivityPub(asyncMiddleware(videosGetValidator)),
  55   executeIfActivityPub(asyncMiddleware(videoAnnouncesController))
  56 )
  57 activityPubClientRouter.get('/videos/watch/:id/announces/:accountId',
  58   executeIfActivityPub(asyncMiddleware(videosShareValidator)),
  59   executeIfActivityPub(asyncMiddleware(videoAnnounceController))
  60 )
  61 activityPubClientRouter.get('/videos/watch/:id/likes',
  62   executeIfActivityPub(asyncMiddleware(videosGetValidator)),
  63   executeIfActivityPub(asyncMiddleware(videoLikesController))
  64 )
  65 activityPubClientRouter.get('/videos/watch/:id/dislikes',
  66   executeIfActivityPub(asyncMiddleware(videosGetValidator)),
  67   executeIfActivityPub(asyncMiddleware(videoDislikesController))
  68 )
  69 activityPubClientRouter.get('/videos/watch/:id/comments',
  70   executeIfActivityPub(asyncMiddleware(videosGetValidator)),
  71   executeIfActivityPub(asyncMiddleware(videoCommentsController))
  72 )
  73 activityPubClientRouter.get('/videos/watch/:videoId/comments/:commentId',
  74   executeIfActivityPub(asyncMiddleware(videoCommentGetValidator)),
  75   executeIfActivityPub(asyncMiddleware(videoCommentController))
  76 )
  77 activityPubClientRouter.get('/videos/watch/:videoId/comments/:commentId/activity',
  78   executeIfActivityPub(asyncMiddleware(videoCommentGetValidator)),
  79   executeIfActivityPub(asyncMiddleware(videoCommentController))
  80 )
  81
  82 activityPubClientRouter.get('/video-channels/:id',
  83   executeIfActivityPub(asyncMiddleware(videoChannelsGetValidator)),
  84   executeIfActivityPub(asyncMiddleware(videoChannelController))
  85 )
  86 activityPubClientRouter.get('/video-channels/:id/followers',
  87   executeIfActivityPub(asyncMiddleware(videoChannelsGetValidator)),
  88   executeIfActivityPub(asyncMiddleware(videoChannelFollowersController))
  89 )
  90 activityPubClientRouter.get('/video-channels/:id/following',
  91   executeIfActivityPub(asyncMiddleware(videoChannelsGetValidator)),
  92   executeIfActivityPub(asyncMiddleware(videoChannelFollowingController))
  93 )
  94
  95 // ---------------------------------------------------------------------------
  96
  97 export {
  98   activityPubClientRouter
  99 }
 100
 101 // ---------------------------------------------------------------------------
 102
 103 function accountController (req: express.Request, res: express.Response, next: express.NextFunction) {
 104   const account: AccountModel = res.locals.account
 105
 106   return activityPubResponse(activityPubContextify(account.toActivityPubObject()), res)
 107 }
 108
 109 async function accountFollowersController (req: express.Request, res: express.Response, next: express.NextFunction) {
 110   const account: AccountModel = res.locals.account
 111   const activityPubResult = await actorFollowers(req, account.Actor)
 112
 113   return activityPubResponse(activityPubContextify(activityPubResult), res)
 114 }
 115
 116 async function accountFollowingController (req: express.Request, res: express.Response, next: express.NextFunction) {
 117   const account: AccountModel = res.locals.account
 118   const activityPubResult = await actorFollowing(req, account.Actor)
 119
 120   return activityPubResponse(activityPubContextify(activityPubResult), res)
 121 }
 122
 123 async function videoController (req: express.Request, res: express.Response, next: express.NextFunction) {
 124   const video: VideoModel = res.locals.video
 125
 126   const audience = getAudience(video.VideoChannel.Account.Actor, video.privacy === VideoPrivacy.PUBLIC)
 127   const videoObject = audiencify(video.toActivityPubObject(), audience)
 128
 129   if (req.path.endsWith('/activity')) {
 130     const data = createActivityData(video.url, video.VideoChannel.Account.Actor, videoObject, audience)
 131     return activityPubResponse(activityPubContextify(data), res)
 132   }
 133
 134   return activityPubResponse(activityPubContextify(videoObject), res)
 135 }
 136
 137 async function videoAnnounceController (req: express.Request, res: express.Response, next: express.NextFunction) {
 138   const share = res.locals.videoShare as VideoShareModel
 139   const object = await buildVideoAnnounce(share.Actor, share, res.locals.video, undefined)
 140
 141   return activityPubResponse(activityPubContextify(object), res)
 142 }
 143
 144 async function videoAnnouncesController (req: express.Request, res: express.Response, next: express.NextFunction) {
 145   const video: VideoModel = res.locals.video
 146
 147   const handler = async (start: number, count: number) => {
 148     const result = await VideoShareModel.listAndCountByVideoId(video.id, start, count)
 149     return {
 150       total: result.count,
 151       data: result.rows.map(r => r.url)
 152     }
 153   }
 154   const json = await activityPubCollectionPagination(getVideoSharesActivityPubUrl(video), handler, req.query.page)
 155
 156   return activityPubResponse(activityPubContextify(json), res)
 157 }
 158
 159 async function videoLikesController (req: express.Request, res: express.Response, next: express.NextFunction) {
 160   const video: VideoModel = res.locals.video
 161   const json = await videoRates(req, 'like', video, getVideoLikesActivityPubUrl(video))
 162
 163   return activityPubResponse(activityPubContextify(json), res)
 164 }
 165
 166 async function videoDislikesController (req: express.Request, res: express.Response, next: express.NextFunction) {
 167   const video: VideoModel = res.locals.video
 168   const json = await videoRates(req, 'dislike', video, getVideoDislikesActivityPubUrl(video))
 169
 170   return activityPubResponse(activityPubContextify(json), res)
 171 }
 172
 173 async function videoCommentsController (req: express.Request, res: express.Response, next: express.NextFunction) {
 174   const video: VideoModel = res.locals.video
 175
 176   const handler = async (start: number, count: number) => {
 177     const result = await VideoCommentModel.listAndCountByVideoId(video.id, start, count)
 178     return {
 179       total: result.count,
 180       data: result.rows.map(r => r.url)
 181     }
 182   }
 183   const json = await activityPubCollectionPagination(getVideoCommentsActivityPubUrl(video), handler, req.query.page)
 184
 185   return activityPubResponse(activityPubContextify(json), res)
 186 }
 187
 188 async function videoChannelController (req: express.Request, res: express.Response, next: express.NextFunction) {
 189   const videoChannel: VideoChannelModel = res.locals.videoChannel
 190
 191   return activityPubResponse(activityPubContextify(videoChannel.toActivityPubObject()), res)
 192 }
 193
 194 async function videoChannelFollowersController (req: express.Request, res: express.Response, next: express.NextFunction) {
 195   const videoChannel: VideoChannelModel = res.locals.videoChannel
 196   const activityPubResult = await actorFollowers(req, videoChannel.Actor)
 197
 198   return activityPubResponse(activityPubContextify(activityPubResult), res)
 199 }
 200
 201 async function videoChannelFollowingController (req: express.Request, res: express.Response, next: express.NextFunction) {
 202   const videoChannel: VideoChannelModel = res.locals.videoChannel
 203   const activityPubResult = await actorFollowing(req, videoChannel.Actor)
 204
 205   return activityPubResponse(activityPubContextify(activityPubResult), res)
 206 }
 207
 208 async function videoCommentController (req: express.Request, res: express.Response, next: express.NextFunction) {
 209   const videoComment: VideoCommentModel = res.locals.videoComment
 210
 211   const threadParentComments = await VideoCommentModel.listThreadParentComments(videoComment, undefined)
 212   const isPublic = true // Comments are always public
 213   const audience = getAudience(videoComment.Account.Actor, isPublic)
 214
 215   const videoCommentObject = audiencify(videoComment.toActivityPubObject(threadParentComments), audience)
 216
 217   if (req.path.endsWith('/activity')) {
 218     const data = createActivityData(videoComment.url, videoComment.Account.Actor, videoCommentObject, audience)
 219     return activityPubResponse(activityPubContextify(data), res)
 220   }
 221
 222   return activityPubResponse(activityPubContextify(videoCommentObject), res)
 223 }
 224
 225 // ---------------------------------------------------------------------------
 226
 227 async function actorFollowing (req: express.Request, actor: ActorModel) {
 228   const handler = (start: number, count: number) => {
 229     return ActorFollowModel.listAcceptedFollowingUrlsForApi([ actor.id ], undefined, start, count)
 230   }
 231
 232   return activityPubCollectionPagination(CONFIG.WEBSERVER.URL + req.url, handler, req.query.page)
 233 }
 234
 235 async function actorFollowers (req: express.Request, actor: ActorModel) {
 236   const handler = (start: number, count: number) => {
 237     return ActorFollowModel.listAcceptedFollowerUrlsForApi([ actor.id ], undefined, start, count)
 238   }
 239
 240   return activityPubCollectionPagination(CONFIG.WEBSERVER.URL + req.url, handler, req.query.page)
 241 }
 242
 243 function videoRates (req: express.Request, rateType: VideoRateType, video: VideoModel, url: string) {
 244   const handler = async (start: number, count: number) => {
 245     const result = await AccountVideoRateModel.listAndCountAccountUrlsByVideoId(rateType, video.id, start, count)
 246     return {
 247       total: result.count,
 248       data: result.rows.map(r => r.Account.Actor.url)
 249     }
 250   }
 251   return activityPubCollectionPagination(url, handler, req.query.page)
 252 }