server/middlewares/validators/blocklist.ts

   1 import { body, param } from 'express-validator'
   2 import * as express from 'express'
   3 import { logger } from '../../helpers/logger'
   4 import { areValidationErrors } from './utils'
   5 import { AccountBlocklistModel } from '../../models/account/account-blocklist'
   6 import { isHostValid } from '../../helpers/custom-validators/servers'
   7 import { ServerBlocklistModel } from '../../models/server/server-blocklist'
   8 import { ServerModel } from '../../models/server/server'
   9 import { WEBSERVER } from '../../initializers/constants'
  10 import { doesAccountNameWithHostExist } from '../../helpers/middlewares'
  11 import { getServerActor } from '@server/models/application/application'
  12 import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
  13
  14 const blockAccountValidator = [
  15   body('accountName').exists().withMessage('Should have an account name with host'),
  16
  17   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
  18     logger.debug('Checking blockAccountByAccountValidator parameters', { parameters: req.body })
  19
  20     if (areValidationErrors(req, res)) return
  21     if (!await doesAccountNameWithHostExist(req.body.accountName, res)) return
  22
  23     const user = res.locals.oauth.token.User
  24     const accountToBlock = res.locals.account
  25
  26     if (user.Account.id === accountToBlock.id) {
  27       res.fail({
  28         status: HttpStatusCode.CONFLICT_409,
  29         message: 'You cannot block yourself.'
  30       })
  31       return
  32     }
  33
  34     return next()
  35   }
  36 ]
  37
  38 const unblockAccountByAccountValidator = [
  39   param('accountName').exists().withMessage('Should have an account name with host'),
  40
  41   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
  42     logger.debug('Checking unblockAccountByAccountValidator parameters', { parameters: req.params })
  43
  44     if (areValidationErrors(req, res)) return
  45     if (!await doesAccountNameWithHostExist(req.params.accountName, res)) return
  46
  47     const user = res.locals.oauth.token.User
  48     const targetAccount = res.locals.account
  49     if (!await doesUnblockAccountExist(user.Account.id, targetAccount.id, res)) return
  50
  51     return next()
  52   }
  53 ]
  54
  55 const unblockAccountByServerValidator = [
  56   param('accountName').exists().withMessage('Should have an account name with host'),
  57
  58   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
  59     logger.debug('Checking unblockAccountByServerValidator parameters', { parameters: req.params })
  60
  61     if (areValidationErrors(req, res)) return
  62     if (!await doesAccountNameWithHostExist(req.params.accountName, res)) return
  63
  64     const serverActor = await getServerActor()
  65     const targetAccount = res.locals.account
  66     if (!await doesUnblockAccountExist(serverActor.Account.id, targetAccount.id, res)) return
  67
  68     return next()
  69   }
  70 ]
  71
  72 const blockServerValidator = [
  73   body('host').custom(isHostValid).withMessage('Should have a valid host'),
  74
  75   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
  76     logger.debug('Checking serverGetValidator parameters', { parameters: req.body })
  77
  78     if (areValidationErrors(req, res)) return
  79
  80     const host: string = req.body.host
  81
  82     if (host === WEBSERVER.HOST) {
  83       return res.fail({
  84         status: HttpStatusCode.CONFLICT_409,
  85         message: 'You cannot block your own server.'
  86       })
  87     }
  88
  89     const server = await ServerModel.loadOrCreateByHost(host)
  90
  91     res.locals.server = server
  92
  93     return next()
  94   }
  95 ]
  96
  97 const unblockServerByAccountValidator = [
  98   param('host').custom(isHostValid).withMessage('Should have an account name with host'),
  99
 100   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
 101     logger.debug('Checking unblockServerByAccountValidator parameters', { parameters: req.params })
 102
 103     if (areValidationErrors(req, res)) return
 104
 105     const user = res.locals.oauth.token.User
 106     if (!await doesUnblockServerExist(user.Account.id, req.params.host, res)) return
 107
 108     return next()
 109   }
 110 ]
 111
 112 const unblockServerByServerValidator = [
 113   param('host').custom(isHostValid).withMessage('Should have an account name with host'),
 114
 115   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
 116     logger.debug('Checking unblockServerByServerValidator parameters', { parameters: req.params })
 117
 118     if (areValidationErrors(req, res)) return
 119
 120     const serverActor = await getServerActor()
 121     if (!await doesUnblockServerExist(serverActor.Account.id, req.params.host, res)) return
 122
 123     return next()
 124   }
 125 ]
 126
 127 // ---------------------------------------------------------------------------
 128
 129 export {
 130   blockServerValidator,
 131   blockAccountValidator,
 132   unblockAccountByAccountValidator,
 133   unblockServerByAccountValidator,
 134   unblockAccountByServerValidator,
 135   unblockServerByServerValidator
 136 }
 137
 138 // ---------------------------------------------------------------------------
 139
 140 async function doesUnblockAccountExist (accountId: number, targetAccountId: number, res: express.Response) {
 141   const accountBlock = await AccountBlocklistModel.loadByAccountAndTarget(accountId, targetAccountId)
 142   if (!accountBlock) {
 143     res.fail({
 144       status: HttpStatusCode.NOT_FOUND_404,
 145       message: 'Account block entry not found.'
 146     })
 147     return false
 148   }
 149
 150   res.locals.accountBlock = accountBlock
 151   return true
 152 }
 153
 154 async function doesUnblockServerExist (accountId: number, host: string, res: express.Response) {
 155   const serverBlock = await ServerBlocklistModel.loadByAccountAndHost(accountId, host)
 156   if (!serverBlock) {
 157     res.fail({
 158       status: HttpStatusCode.NOT_FOUND_404,
 159       message: 'Server block entry not found.'
 160     })
 161     return false
 162   }
 163
 164   res.locals.serverBlock = serverBlock
 165   return true
 166 }