import * as express from 'express'
-import { UserRight } from '../../../../shared/models/users/user-right.enum'
-import { getFormattedObjects } from '../../../helpers'
+import { UserRight } from '../../../../shared/models/users'
import { logger } from '../../../helpers/logger'
-import { getApplicationAccount } from '../../../helpers/utils'
-import { getAccountFromWebfinger } from '../../../helpers/webfinger'
-import { SERVER_ACCOUNT_NAME } from '../../../initializers/constants'
-import { database as db } from '../../../initializers/database'
-import { sendFollow } from '../../../lib/activitypub/send-request'
-import { asyncMiddleware, paginationValidator, setFollowersSort, setPagination } from '../../../middlewares'
-import { authenticate } from '../../../middlewares/oauth'
-import { setBodyHostsPort } from '../../../middlewares/servers'
-import { setFollowingSort } from '../../../middlewares/sort'
-import { ensureUserHasRight } from '../../../middlewares/user-right'
-import { followValidator } from '../../../middlewares/validators/servers'
-import { followersSortValidator, followingSortValidator } from '../../../middlewares/validators/sort'
-
-const applicationFollowsRouter = express.Router()
-
-applicationFollowsRouter.get('/following',
+import { getFormattedObjects, getServerActor } from '../../../helpers/utils'
+import { sequelizeTypescript, SERVER_ACTOR_NAME } from '../../../initializers'
+import { sendUndoFollow } from '../../../lib/activitypub/send'
+import {
+ asyncMiddleware,
+ authenticate,
+ ensureUserHasRight,
+ paginationValidator,
+ removeFollowingValidator,
+ setBodyHostsPort,
+ setDefaultPagination,
+ setDefaultSort
+} from '../../../middlewares'
+import { followersSortValidator, followingSortValidator, followValidator } from '../../../middlewares/validators'
+import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
+import { JobQueue } from '../../../lib/job-queue'
+import { removeRedundancyOf } from '../../../lib/redundancy'
+
+const serverFollowsRouter = express.Router()
+serverFollowsRouter.get('/following',
paginationValidator,
followingSortValidator,
- setFollowingSort,
- setPagination,
+ setDefaultSort,
+ setDefaultPagination,
asyncMiddleware(listFollowing)
)
-applicationFollowsRouter.post('/follow',
+serverFollowsRouter.post('/following',
authenticate,
- ensureUserHasRight(UserRight.MANAGE_APPLICATION_FOLLOW),
+ ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
followValidator,
setBodyHostsPort,
- asyncMiddleware(follow)
+ asyncMiddleware(followInstance)
)
-applicationFollowsRouter.get('/followers',
+serverFollowsRouter.delete('/following/:host',
+ authenticate,
+ ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
+ asyncMiddleware(removeFollowingValidator),
+ asyncMiddleware(removeFollow)
+)
+
+serverFollowsRouter.get('/followers',
paginationValidator,
followersSortValidator,
- setFollowersSort,
- setPagination,
+ setDefaultSort,
+ setDefaultPagination,
asyncMiddleware(listFollowers)
)
// ---------------------------------------------------------------------------
export {
- applicationFollowsRouter
+ serverFollowsRouter
}
// ---------------------------------------------------------------------------
async function listFollowing (req: express.Request, res: express.Response, next: express.NextFunction) {
- const applicationAccount = await getApplicationAccount()
- const resultList = await db.AccountFollow.listFollowingForApi(applicationAccount.id, req.query.start, req.query.count, req.query.sort)
+ const serverActor = await getServerActor()
+ const resultList = await ActorFollowModel.listFollowingForApi(
+ serverActor.id,
+ req.query.start,
+ req.query.count,
+ req.query.sort,
+ req.query.search
+ )
return res.json(getFormattedObjects(resultList.data, resultList.total))
}
async function listFollowers (req: express.Request, res: express.Response, next: express.NextFunction) {
- const applicationAccount = await getApplicationAccount()
- const resultList = await db.AccountFollow.listFollowersForApi(applicationAccount.id, req.query.start, req.query.count, req.query.sort)
+ const serverActor = await getServerActor()
+ const resultList = await ActorFollowModel.listFollowersForApi(
+ serverActor.id,
+ req.query.start,
+ req.query.count,
+ req.query.sort,
+ req.query.search
+ )
return res.json(getFormattedObjects(resultList.data, resultList.total))
}
-async function follow (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function followInstance (req: express.Request, res: express.Response, next: express.NextFunction) {
const hosts = req.body.hosts as string[]
- const fromAccount = await getApplicationAccount()
-
- const tasks: Promise<any>[] = []
- const accountName = SERVER_ACCOUNT_NAME
+ const follower = await getServerActor()
for (const host of hosts) {
-
- // We process each host in a specific transaction
- // First, we add the follow request in the database
- // Then we send the follow request to other account
- const p = loadLocalOrGetAccountFromWebfinger(accountName, host)
- .then(accountResult => {
- let targetAccount = accountResult.account
-
- return db.sequelize.transaction(async t => {
- if (accountResult.loadedFromDB === false) {
- targetAccount = await targetAccount.save({ transaction: t })
- }
-
- const [ accountFollow ] = await db.AccountFollow.findOrCreate({
- where: {
- accountId: fromAccount.id,
- targetAccountId: targetAccount.id
- },
- defaults: {
- state: 'pending',
- accountId: fromAccount.id,
- targetAccountId: targetAccount.id
- },
- transaction: t
- })
-
- // Send a notification to remote server
- if (accountFollow.state === 'pending') {
- await sendFollow(fromAccount, targetAccount, t)
- }
- })
- })
- .catch(err => logger.warn('Cannot follow server %s.', `${accountName}@${host}`, err))
-
- tasks.push(p)
+ const payload = {
+ host,
+ name: SERVER_ACTOR_NAME,
+ followerActorId: follower.id
+ }
+
+ JobQueue.Instance.createJob({ type: 'activitypub-follow', payload })
+ .catch(err => logger.error('Cannot create follow job for %s.', host, err))
}
- // Don't make the client wait the tasks
- Promise.all(tasks)
- .catch(err => {
- logger.error('Error in follow.', err)
- })
-
return res.status(204).end()
}
-async function loadLocalOrGetAccountFromWebfinger (name: string, host: string) {
- let loadedFromDB = true
- let account = await db.Account.loadByNameAndHost(name, host)
+async function removeFollow (req: express.Request, res: express.Response, next: express.NextFunction) {
+ const follow: ActorFollowModel = res.locals.follow
- if (!account) {
- const nameWithDomain = name + '@' + host
- account = await getAccountFromWebfinger(nameWithDomain)
- loadedFromDB = false
- }
+ await sequelizeTypescript.transaction(async t => {
+ if (follow.state === 'accepted') await sendUndoFollow(follow, t)
+
+ // Disable redundancy on unfollowed instances
+ const server = follow.ActorFollowing.Server
+ server.redundancyAllowed = false
+ await server.save({ transaction: t })
- return { account, loadedFromDB }
+ // Async, could be long
+ removeRedundancyOf(server.id)
+ .catch(err => logger.error('Cannot remove redundancy of %s.', server.host, err))
+
+ await follow.destroy({ transaction: t })
+ })
+
+ return res.status(204).end()
}