server/controllers/api/server/follows.ts

   1 import * as express from 'express'
   2 import { UserRight } from '../../../../shared/models/users'
   3 import { logger } from '../../../helpers/logger'
   4 import { getFormattedObjects } from '../../../helpers/utils'
   5 import { SERVER_ACTOR_NAME } from '../../../initializers/constants'
   6 import { sendAccept, sendReject, sendUndoFollow } from '../../../lib/activitypub/send'
   7 import {
   8   asyncMiddleware,
   9   authenticate,
  10   ensureUserHasRight,
  11   paginationValidator,
  12   setBodyHostsPort,
  13   setDefaultPagination,
  14   setDefaultSort
  15 } from '../../../middlewares'
  16 import {
  17   acceptOrRejectFollowerValidator,
  18   followersSortValidator,
  19   followingSortValidator,
  20   followValidator,
  21   getFollowerValidator,
  22   removeFollowingValidator,
  23   listFollowsValidator
  24 } from '../../../middlewares/validators'
  25 import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
  26 import { JobQueue } from '../../../lib/job-queue'
  27 import { removeRedundanciesOfServer } from '../../../lib/redundancy'
  28 import { sequelizeTypescript } from '../../../initializers/database'
  29 import { autoFollowBackIfNeeded } from '../../../lib/activitypub/follow'
  30 import { getServerActor } from '@server/models/application/application'
  31
  32 const serverFollowsRouter = express.Router()
  33 serverFollowsRouter.get('/following',
  34   listFollowsValidator,
  35   paginationValidator,
  36   followingSortValidator,
  37   setDefaultSort,
  38   setDefaultPagination,
  39   asyncMiddleware(listFollowing)
  40 )
  41
  42 serverFollowsRouter.post('/following',
  43   authenticate,
  44   ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
  45   followValidator,
  46   setBodyHostsPort,
  47   asyncMiddleware(followInstance)
  48 )
  49
  50 serverFollowsRouter.delete('/following/:host',
  51   authenticate,
  52   ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
  53   asyncMiddleware(removeFollowingValidator),
  54   asyncMiddleware(removeFollowing)
  55 )
  56
  57 serverFollowsRouter.get('/followers',
  58   listFollowsValidator,
  59   paginationValidator,
  60   followersSortValidator,
  61   setDefaultSort,
  62   setDefaultPagination,
  63   asyncMiddleware(listFollowers)
  64 )
  65
  66 serverFollowsRouter.delete('/followers/:nameWithHost',
  67   authenticate,
  68   ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
  69   asyncMiddleware(getFollowerValidator),
  70   asyncMiddleware(removeOrRejectFollower)
  71 )
  72
  73 serverFollowsRouter.post('/followers/:nameWithHost/reject',
  74   authenticate,
  75   ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
  76   asyncMiddleware(getFollowerValidator),
  77   acceptOrRejectFollowerValidator,
  78   asyncMiddleware(removeOrRejectFollower)
  79 )
  80
  81 serverFollowsRouter.post('/followers/:nameWithHost/accept',
  82   authenticate,
  83   ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
  84   asyncMiddleware(getFollowerValidator),
  85   acceptOrRejectFollowerValidator,
  86   asyncMiddleware(acceptFollower)
  87 )
  88
  89 // ---------------------------------------------------------------------------
  90
  91 export {
  92   serverFollowsRouter
  93 }
  94
  95 // ---------------------------------------------------------------------------
  96
  97 async function listFollowing (req: express.Request, res: express.Response) {
  98   const serverActor = await getServerActor()
  99   const resultList = await ActorFollowModel.listFollowingForApi({
 100     id: serverActor.id,
 101     start: req.query.start,
 102     count: req.query.count,
 103     sort: req.query.sort,
 104     search: req.query.search,
 105     actorType: req.query.actorType,
 106     state: req.query.state
 107   })
 108
 109   return res.json(getFormattedObjects(resultList.data, resultList.total))
 110 }
 111
 112 async function listFollowers (req: express.Request, res: express.Response) {
 113   const serverActor = await getServerActor()
 114   const resultList = await ActorFollowModel.listFollowersForApi({
 115     actorId: serverActor.id,
 116     start: req.query.start,
 117     count: req.query.count,
 118     sort: req.query.sort,
 119     search: req.query.search,
 120     actorType: req.query.actorType,
 121     state: req.query.state
 122   })
 123
 124   return res.json(getFormattedObjects(resultList.data, resultList.total))
 125 }
 126
 127 async function followInstance (req: express.Request, res: express.Response) {
 128   const hosts = req.body.hosts as string[]
 129   const follower = await getServerActor()
 130
 131   for (const host of hosts) {
 132     const payload = {
 133       host,
 134       name: SERVER_ACTOR_NAME,
 135       followerActorId: follower.id
 136     }
 137
 138     JobQueue.Instance.createJob({ type: 'activitypub-follow', payload })
 139   }
 140
 141   return res.status(204).end()
 142 }
 143
 144 async function removeFollowing (req: express.Request, res: express.Response) {
 145   const follow = res.locals.follow
 146
 147   await sequelizeTypescript.transaction(async t => {
 148     if (follow.state === 'accepted') await sendUndoFollow(follow, t)
 149
 150     // Disable redundancy on unfollowed instances
 151     const server = follow.ActorFollowing.Server
 152     server.redundancyAllowed = false
 153     await server.save({ transaction: t })
 154
 155     // Async, could be long
 156     removeRedundanciesOfServer(server.id)
 157       .catch(err => logger.error('Cannot remove redundancy of %s.', server.host, err))
 158
 159     await follow.destroy({ transaction: t })
 160   })
 161
 162   return res.status(204).end()
 163 }
 164
 165 async function removeOrRejectFollower (req: express.Request, res: express.Response) {
 166   const follow = res.locals.follow
 167
 168   await sendReject(follow.ActorFollower, follow.ActorFollowing)
 169
 170   await follow.destroy()
 171
 172   return res.status(204).end()
 173 }
 174
 175 async function acceptFollower (req: express.Request, res: express.Response) {
 176   const follow = res.locals.follow
 177
 178   await sendAccept(follow)
 179
 180   follow.state = 'accepted'
 181   await follow.save()
 182
 183   await autoFollowBackIfNeeded(follow)
 184
 185   return res.status(204).end()
 186 }