@nestjs/common#BadRequestException TypeScript Examples

handleDuplicateSite = (err) => {
  // Unique Violation: A site already exists at these coordinates
  if (err.code === '23505') {
    throw new BadRequestException('A site already exists at these coordinates');
  }

  logger.error('An unexpected error occurred', err);
  throw new InternalServerErrorException('An unexpected error occurred');
}

@Get('/block/:roundNumber')
  @HttpCode(HttpStatus.OK)
  public async getBlock(@Param() { roundNumber }: PathRountNumber) {
    try {
      return await this.service.getBlock(Number(roundNumber));
    } catch (e) {
      if (['Array', 'ValidationError'].includes(e.constructor.name)) {
        throw new BadRequestException(e);
      }
      if (e.constructor.name === 'TatumError' || e.constructor.name === AlgoError.name) {
        throw e;
      }
      throw new AlgoError(`Unexpected error occurred. Reason: ${e.message || e.response?.data || e}`, 'algo.error');
    }
  }

@ApiOperation({ summary: 'Create a user' })
  @ApiBody({ type: User, description: 'User information' })
  @ApiCreatedResponse({ description: 'The user was created successfully' })
  @ApiBadRequestResponse({ description: 'The user could not be created' })
  @ApiForbiddenResponse({ description: 'You do not have the necessary role to perform this action' })
  @UseGuards(RolesGuard)
  @Roles(DefaultRole.Admin)
  @Post()
  @HttpCode(HttpStatus.CREATED)
  async addUser(
    @Body() user: User
  ): Promise<void> {
    try {
      user.role = new Role({ id: DefaultRole.User })
      await this.userService.addUser(user)
    } catch (error) {
      /**
       * Validate database exceptions
       */
      switch(error.code) {
        case POSTGRES.UNIQUE_VIOLATION:
          throw new BadRequestException(ERRORS.UNIQUE_VIOLATION)
        default:
          this.logger.error(error.message, 'ADD_USER')
          throw new BadRequestException(error.message)
      }
    }
  }

@Catch(BadRequestException)
export class HttpExceptionFilter implements ExceptionFilter {
    constructor(public reflector: Reflector) {}

    catch(exception: BadRequestException, host: ArgumentsHost) {
        const ctx = host.switchToHttp();
        const response = ctx.getResponse<Response>();
        let statusCode = exception.getStatus();
        const r = <any>exception.getResponse();

        if (_.isArray(r.message) && r.message[0] instanceof ValidationError) {
            statusCode = HttpStatus.UNPROCESSABLE_ENTITY;
            const validationErrors = <ValidationError[]>r.message;
            this._validationFilter(validationErrors);
        }

        r.statusCode = statusCode;
        r.error = STATUS_CODES[statusCode];

        response.status(statusCode).json(r);
    }

    private _validationFilter(validationErrors: ValidationError[]) {
        for (const validationError of validationErrors) {
            for (const [constraintKey, constraint] of Object.entries(
                validationError.constraints,
            )) {
                if (!constraint) {
                    // convert error message to error.fields.{key} syntax for i18n translation
                    validationError.constraints[constraintKey] =
                        'error.fields.' + _.snakeCase(constraintKey);
                }
            }
            if (!_.isEmpty(validationError.children)) {
                this._validationFilter(validationError.children);
            }
        }
    }
}

@ApiOperation({ summary: 'Add new users' })
  @ApiBody({ type: User, isArray: true, description: 'Info of the users' })
  @ApiCreatedResponse({ description: 'The users were created successfully' })
  @ApiBadRequestResponse({ description: 'The users could not be created' })
  @ApiForbiddenResponse({ description: 'You do not have the necessary role to perform this action' })
  @UseGuards(RolesGuard)
  @Roles(DefaultRole.Admin)
  @Post('bulk')
  @HttpCode(HttpStatus.CREATED)
  async createBulk(
    @Body(new ParseArrayPipe({ items: User })) users: User[]
  ): Promise<void> {
    try {
      await this.userService.addUsers(users)
    } catch (error) {
      /**
       * Validate database exceptions
       */
      switch(error.code) {
        case POSTGRES.UNIQUE_VIOLATION:
          throw new BadRequestException(ERRORS.UNIQUE_VIOLATION)
        default:
          this.logger.error(error.message, 'ADD_USERS')
          throw new BadRequestException(error.message)
      }
    }
  }

export class FileNotImageException extends BadRequestException {
  constructor(message?: string | object | any, error?: string) {
    if (message) {
      super(message, error);
    } else {
      super('error.file.not_image');
    }
  }
}

public async verifyMatchingService({ settings }: any): Promise<boolean> {
		if (settings.matchingService !== 'spotify') {
			return true;
		}

		if (!settings.spotifyClientId || !settings.spotifyClientSecret) {
			throw new BadRequestException('Please fill in all fields')
		}

		const spotifyApi = new Spotify({
			clientId: settings.spotifyClientId,
			clientSecret: settings.spotifyClientSecret
		});

		try {
			const { body: { access_token: accessToken } } = await spotifyApi.clientCredentialsGrant();
			spotifyApi.setAccessToken(accessToken);
		} catch (e) {
			throw new BadRequestException('Invalid spotify credentials')
		}

		return spotifyApi.searchTracks('Shygirl - SLIME')
			.then(() => true)
			.catch(() => {
				throw new BadRequestException('Invalid spotify credentials')
			})
	}

async transform(value, metadata: ArgumentMetadata) {
    if (!value) {
      throw new BadRequestException('No data submitted');
    }

    const { metatype } = metadata;
    if (!metatype || !this.toValidate(metatype)) {
      return value;
    }
    const object = plainToClass(metatype, value);
    const errors = await validate(object);
    if (errors.length > 0) {
      throw new BadRequestException(this.buildError(errors), 'Input data validation failed');
    }
    return value;
  }

@Post()
  @Roles(Role.TA, Role.PROFESSOR)
  async createAlert(
    @Body() body: CreateAlertParams,
  ): Promise<CreateAlertResponse> {
    const { alertType, courseId, payload, targetUserId } = body;

    if (!this.alertsService.assertPayloadType(alertType, payload)) {
      throw new BadRequestException(
        ERROR_MESSAGES.alertController.incorrectPayload,
      );
    }

    const anotherAlert = await AlertModel.findOne({
      where: {
        alertType,
        userId: targetUserId,
        resolved: null,
      },
    });

    // If the same user already has an alert for this then don't create a new one
    if (anotherAlert) {
      throw new BadRequestException(
        ERROR_MESSAGES.alertController.duplicateAlert,
      );
    }

    const alert = await AlertModel.create({
      alertType,
      sent: new Date(),
      userId: targetUserId,
      courseId,
      payload,
    }).save();

    return alert;
  }

/**
     * Get the Tenant information from the request header
     *
     * @private
     * @static
     * @param {boolean} isFastifyAdaptor
     * @param {Request} req
     * @returns
     * @memberof TenancyCoreModule
     */
    private static getTenantFromSubdomain(isFastifyAdaptor: boolean, req: Request) {
        let tenantId = '';

        if (isFastifyAdaptor) { // For Fastify
            const subdomains = this.getSubdomainsForFastify(req);

            if (subdomains instanceof Array && subdomains.length > 0) {
                tenantId = subdomains[subdomains.length - 1];
            }
        } else { // For Express - Default
            // Check for multi-level subdomains and return only the first name
            if (req.subdomains instanceof Array && req.subdomains.length > 0) {
                tenantId = req.subdomains[req.subdomains.length - 1];
            }
        }

        // Validate if tenant identifier token is present
        if (this.isEmpty(tenantId)) {
            throw new BadRequestException(`Tenant ID is mandatory`);
        }

        return tenantId;
    }

@Patch(':alertId')
  @Roles(Role.STUDENT, Role.TA, Role.PROFESSOR)
  async closeAlert(@Param('alertId') alertId: number): Promise<void> {
    const alert = await AlertModel.findOne({
      where: {
        id: alertId,
      },
    });

    if (!alert) {
      throw new BadRequestException(
        ERROR_MESSAGES.alertController.notActiveAlert,
      );
    }

    alert.resolved = new Date();
    await alert.save();
  }

/**
   * @author Aya Abohadima <[email protected]>
   * @description check if this user follow this user id
   * @param {Object} user - user he follow
   * @param {String} userId - id of user followed
   * @returns {boolean}
   */
  async checkFollowUser(user, userId) {
    if ((await this.ValidationService.checkMongooseID([userId])) === 0)
      throw new HttpException('there is not correct id ', HttpStatus.FORBIDDEN);
    if (!user) throw new BadRequestException('not user');
    if (!user.following)
      await this.userModel.updateOne({ _id: user._id }, { following: [] });
    for (let i = 0; i < user.following.length; i++)
      if (String(userId) === String(user.following[i])) return true;
    return false;
  }

// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
  async setupData(
    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
    request: any,
  ): Promise<{ courseId: number; user: UserModel }> {
    let queueId;

    if (request.params.questionId) {
      const question = await QuestionModel.findOne(request.params.questionId);
      if (!question) {
        throw new NotFoundException(
          ERROR_MESSAGES.questionRoleGuard.questionNotFound,
        );
      }
      queueId = question.queueId;
    } else if (request.body.queueId) {
      // If you are creating a new question
      queueId = request.body.queueId;
    } else {
      throw new BadRequestException(
        ERROR_MESSAGES.questionRoleGuard.queueOfQuestionNotFound,
      );
    }

    const queue = await QueueModel.findOne(queueId);

    // You cannot interact with a question in a nonexistent queue
    if (!queue) {
      throw new NotFoundException(
        ERROR_MESSAGES.questionRoleGuard.queueDoesNotExist,
      );
    }
    const courseId = queue.courseId;
    const user = await UserModel.findOne(request.user.userId, {
      relations: ['courses'],
    });

    return { courseId, user };
  }

/**
   * @author Nada AbdElmaboud <[email protected]>
   * @description report a pin by a user
   * @param {string} pinId - the id of the pin
   * @param {string} userId - the id of the user
   * @param {string} reason - reason why the pin has been reported
   * @returns  {Promise<boolean>}
   */
  async reportPin(userId, pinId, reason): Promise<boolean> {
    if ((await this.ValidationService.checkMongooseID([pinId, userId])) == 0) {
      throw new BadRequestException('not valid id');
    }
    let user = await this.userModel.findById(userId, { userName: 1, email: 1 });
    if (!user) {
      throw new BadRequestException('not valid user');
    }
    await this.EmailService.sendEmail(
      process.env.EMAIL,
      {
        pinId: pinId,
        userId: userId,
        userName: user.userName,
        email: user.email,
        reason: reason,
      },
      'report',
      '',
    );
    return true;
  }

throwError(e: BlockchainError): void {
        if (['Array', 'ValidationError'].includes(e.constructor.name)) {
            throw new BadRequestException(e);
        }
        if (e.constructor.name === 'TatumError') {
            throw e;
        }
        throw new AdaError(
            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
            // @ts-ignore
            `Unexpected error occurred. Reason: ${e.message?.message || e.response?.data || e.message || e}`,
            'ada.error',
        );
    }

/**
   * @author Nada AbdElmaboud <[email protected]>
   * @description get user saved pins
   * @param {string} userId - the id of the user
   * @returns  {Promise<Array<object>>}
   */
  async getCurrentUserSavedPins(userId): Promise<Array<object>> {
    if ((await this.ValidationService.checkMongooseID([userId])) == 0) {
      throw new BadRequestException('not valid id');
    }
    let user = await this.userModel.findById(userId, { savedPins: 1 }).lean();
    if (!user) throw new NotFoundException('no such user');
    let retPins = [];
    for (var i = 0; i < user.savedPins.length; i++) {
      let pinFound = await this.pinModel
        .findById(user.savedPins[i].pinId, {
          imageId: 1,
          imageHeight: 1,
          imageWidth: 1,
          topic: 1,
        })
        .lean();
      if (pinFound) {
        retPins.push(pinFound);
      }
    }
    return retPins;
  }

@Get('/transactions/:from/:to')
  public async getPayTransactions(@Param() {from, to}: PathFromTo, @Query() {limit, next}: Pagination) {
    try {
      return await this.service.getPayTransactions(from, to, limit, next);
    } catch (e) {
      if (['Array', 'ValidationError'].includes(e.constructor.name)) {
        throw new BadRequestException(e);
      }
      if (e.constructor.name === 'TatumError' || e.constructor.name === AlgoError.name) {
        throw e;
      }
      throw new AlgoError(`Unexpected error occurred. Reason: ${e.message || e.response?.data || e}`, 'algo.error');
    }
  }

/**
   * @author Nada AbdElmaboud <[email protected]>
   * @description get user pins
   * @param {string} userId - the id of the user
   * @param {boolean} ifMe - flag indicates if current user or another user
   * @param {number} limit - the limit of user pins returned
   * @returns  {Promise<Array<object>}
   */
  async getCurrentUserPins(userId, ifMe, limit, isFollow): Promise<Array<pin>> {
    if ((await this.ValidationService.checkMongooseID([userId])) == 0) {
      throw new BadRequestException('not valid Id');
    }
    let user;
    if (ifMe == true)
      user = await this.userModel.findById(userId, { pins: 1 }).lean();
    else user = await this.userModel.findById(userId, { pins: 1, email: 1 });

    if (!user) throw new BadRequestException('no such user');
    if (!ifMe && !isFollow && user.email == process.env.ADMIN_EMAIL) {
      return [];
    }
    let retPins = [];
    if (!limit || limit > user.pins.length) limit = user.pins.length;
    for (var i = user.pins.length - 1; i >= user.pins.length - limit; i--) {
      let pinFound = await this.pinModel.findById(user.pins[i].pinId, {
        _id: 1,
        imageId: 1,
        imageWidth: 1,
        imageHeight: 1,
        title: 1,
        topic: 1,
      });
      if (pinFound) {
        retPins.push(pinFound);
      }
    }
    return retPins;
  }

@Get('/node/indexer/:key/*')
  @HttpCode(HttpStatus.OK)
  public async nodeGetIndexer(@Req() req: Request, @Param() param: { key: string }) {
    try {
      return await this.service.nodeMethod(req, param.key, AlgoNodeType.INDEXER);
    } catch (e) {
      if (['Array', 'ValidationError'].includes(e.constructor.name)) {
        throw new BadRequestException(e);
      }
      if (e.constructor.name === 'TatumError' || e.constructor.name === AlgoError.name) {
        throw e;
      }
      throw new AlgoError(`Unexpected error occurred. Reason: ${e.message?.message || e.response?.data || e.message || e}`, 'Algo.error');
    }
  }

/**
   * @author Nada AbdElmaboud <[email protected]>
   * @description upload an image file to google drive
   * @param {string} fileName - the id of the file
   * @param {string} mimeType - the type of the file
   * @param {Buffer} stream - the buffer of the file data
   * @returns  {Promise<Array<object>>}
   */
  async uploadFile(fileName, mimeType, stream) {
    const readable = new Readable();
    readable._read = () => {};
    readable.push(stream);
    readable.push(null);
    var fileMetadata = {
      name: fileName,
    };
    var media = {
      mimeType: mimeType,
      body: readable,
    };
    let res = await this.drive.files.create({
      resource: fileMetadata,
      media: media,
      fields: 'id',
    });
    if (res) {
      return [{ id: res.data.id }];
    } else {
      throw new BadRequestException();
    }
  }

@Post('/node/indexer/:key/*')
  @HttpCode(HttpStatus.OK)
  public async nodePostIndexer(@Req() req: Request, @Param() param: { key: string }) {
    try {
      return await this.service.nodeMethod(req, param.key, AlgoNodeType.INDEXER);
    } catch (e) {
      if (['Array', 'ValidationError'].includes(e.constructor.name)) {
        throw new BadRequestException(e);
      }
      if (e.constructor.name === 'TatumError' || e.constructor.name === AlgoError.name) {
        throw e;
      }
      throw new AlgoError(`Unexpected error occurred. Reason: ${e.message?.message || e.response?.data || e.message || e}`, 'Algo.error');
    }
  }

/**
   * @author Nada AbdElmaboud <[email protected]>
   * @description check if board has section
   * @param {board} board
   * @param {string} sectionId - the id of the section
   * @returns  {Promise<boolean>}
   */
  async checkBoardHasSection(board, sectionId): Promise<Boolean> {
    if ((await this.ValidationService.checkMongooseID([sectionId])) == 0) {
      throw new BadRequestException('not valid section id');
    }
    for (let i = 0; i < board.sections.length; i++) {
      if (String(board.sections[i]._id) == String(sectionId)) {
        return true;
      }
    }
    return false;
  }

@Post('/broadcast')
  @HttpCode(HttpStatus.OK)
  public async broadcast(@Body() body: BroadcastTx) {
    try {
      return await this.service.broadcast(body.txData, body.signatureId);
    } catch (e) {
      if (['Array', 'ValidationError'].includes(e.constructor.name)) {
        throw new BadRequestException(e);
      }
      if (e.constructor.name === 'TatumError' || e.constructor.name === AlgoError.name) {
        throw e;
      }
      throw new AlgoError(`Unexpected error occurred. Reason: ${e.message || e.response?.data || e}`, 'algo.error');
    }
  }

async useCard(id: number): Promise<Card> {
    const card = await this.findOne(id);
    if (!card) throw new NotFoundException();
    if (card.getStatus()) throw new BadRequestException();
    const usingCard = (
      await this.find({
        where: { using: true, type: card.getType() },
      })
    ).length;
    if (usingCard >= 150 && card.getType() == 0)
      throw new BadRequestException();
    if (usingCard >= 150 && card.getType() == 1)
      throw new BadRequestException();
    card.useCard();
    await this.save(card);
    return card;
  }

@Post('/broadcast')
  @HttpCode(HttpStatus.OK)
  public async broadcast(@Body() body: BroadcastTx) {
    try {
      return await this.service.broadcast(body.txData, body.signatureId);
    } catch (e) {
      if (['Array', 'ValidationError'].includes(e.constructor.name)) {
        throw new BadRequestException(e);
      }
      if (e.constructor.name === 'TatumError' || e.constructor.name === KcsError.name) {
        throw e;
      }
      throw new KcsError(`Unexpected error occurred. Reason: ${e.message?.message || e.response?.data || e.message || e}`, 'kcs.error');
    }
  }

async setCard(id: number, card: Card): Promise<User> {
    // this.logger.log('setting Card Start');
    // this.logger.log('_id, cardId : ', id, card.getId());
    const user = await this.findWithCard(id);
    if (user.getCard()) throw new BadRequestException();
    user.cardSet(card);
    await this.save(user);
    return user;
  }

@Post('/gas')
  @HttpCode(HttpStatus.OK)
  public async estimateGas(@Body() body: EstimateGas) {
    try {
      return await this.service.estimateGas(body);
    } catch (e) {
      if (['Array', 'ValidationError'].includes(e.constructor.name)) {
        throw new BadRequestException(e);
      }
      if (e.constructor.name === 'TatumError' || e.constructor.name === KcsError.name) {
        throw e;
      }
      throw new KcsError(`Unexpected error occurred. Reason: ${e.message?.message || e.response?.data || e.message || e}`, 'kcs.error');
    }
  }

async create(id: number, type: number) {
    const user = await this.userRepository.findOne(id);
    const exist = await this.waitingRepository.find({
      relations: ['user'],
      where: { user: { _id: id }, deleteType: null },
    });
    if (exist.length > 0) throw new BadRequestException();
    const waiting = new Waiting(user, type);
    this.waitingRepository.save(waiting);
  }

@Post('/transaction')
  @HttpCode(HttpStatus.OK)
  public async sendTransaction(@Body() body: TransferErc20) {
    try {
      return await this.service.sendKCS(body);
    } catch (e) {
      if (['Array', 'ValidationError'].includes(e.constructor.name)) {
        throw new BadRequestException(e);
      }
      if (e.constructor.name === 'TatumError' || e.constructor.name === KcsError.name) {
        throw e;
      }
      throw new KcsError(`Unexpected error occurred. Reason: ${e.message?.message || e.response?.data || e.message || e}`, 'kcs.error');
    }
  }