@nestjs/common#NotFoundException TypeScript Examples

@ApiOkResponse({
    schema: {
      type: 'object',
      properties: {
        data: {
          $ref: getSchemaPath(User),
        },
      },
    },
    description: '200. Success. Returns a user',
  })
  @ApiNotFoundResponse({
    description: '404. NotFoundException. User was not found',
  })
  @ApiUnauthorizedResponse({
    schema: {
      type: 'object',
      example: {
        message: 'string',
      },
    },
    description: '401. UnauthorizedException.',
  })
  @ApiParam({ name: 'id', type: String })
  @Get(':id')
  @Serialize(UserResponseDto)
  @Auth()
  async getById(
    @Param('id', ParseObjectIdPipe) id: Types.ObjectId,
  ): Promise<User> {
    const foundUser = await this.usersService.getVerifiedUserById(id);

    if (!foundUser) {
      throw new NotFoundException('The user does not exist');
    }

    return foundUser;
  }

getSite = async (
  siteId: number,
  siteRepository: Repository<Site>,
  relations?: string[],
) => {
  const site = await siteRepository.findOne(siteId, { relations });

  if (!site) {
    throw new NotFoundException(`Site with id ${siteId} does not exist`);
  }

  return site;
}

// constructor(private readonly logger: MyLogger) {
  //   super();
  // }

  async findWithCard(id: number): Promise<User> {
    const user = await this.findOne(id, { relations: ['card'] });
    if (!user) throw new NotFoundException();
    return user;
  }

/**
   * @author Nada AbdElmaboud <[email protected]>
   * @description add board to user
   * @param {string} userId - the id of the user
   * @param {string} boardId - the id of the board
   * @returns  {Promise<boolean>}
   */
  async addBoardtoUser(userId, boardId) {
    if (
      (await this.ValidationService.checkMongooseID([userId, boardId])) == 0
    ) {
      throw new BadRequestException('not valid id');
    }
    boardId = mongoose.Types.ObjectId(boardId);
    userId = mongoose.Types.ObjectId(userId);
    let board = await this.boardModel.findById(boardId, {
      name: 1,
      createdAt: 1,
    });
    let user = await this.userModel.findById(userId, {
      boards: 1,
      sortType: 1,
    });
    if (!board) throw new NotFoundException();
    if (!user) throw new NotFoundException();
    let id = mongoose.Types.ObjectId(boardId);
    user.boards.push({
      boardId: id,
      name: board.name,
      createdAt: board.createdAt,
      isJoined: false,
      createdOrjoined: 'created',
    });
    await user.save().catch(err => {
      console.log(err);
    });
    return true;
  }

async getOnePrefectureById(
    requestAdminUser: RequestAdminUser,
    prefectureId: number
  ): Promise<Prefecture> {
    // Fetch resource and perform ACL check.
    const prefecture = await this.prefecturesRepository.findOneById(prefectureId)
    if (!prefecture) {
      throw new NotFoundException('Could not find prefecture with this id')
    }
    if (!canUserAccessResource(requestAdminUser.userAccessKey, prefecture)) {
      throw new UnauthorizedException('User does not have access on this resource')
    }

    return prefecture
  }

async findOrThrow(userId: number): Promise<UserPoints> {
    const record = await this.prisma.userPoints.findUnique({
      where: {
        user_id: userId,
      },
    });

    if (!record) {
      throw new NotFoundException();
    }

    return record;
  }

findById(id: string, withPosts = false): Observable<User> {
    const userQuery = this.userModel.findOne({ _id: id });
    if (withPosts) {
      userQuery.populate('posts');
    }
    return from(userQuery.exec()).pipe(
      mergeMap((p) => (p ? of(p) : EMPTY)),
      throwIfEmpty(() => new NotFoundException(`user:${id} was not found`)),
    );
  }

public assertAbility(user: AuthorizableUser, action: string, subject: Subject): void {
    if (!this.hasAbility(user, action, subject)) {
      const userAbilities = this.abilityFactory.createForUser(user, Ability);
      const relatedRules = userAbilities.rulesFor(action, typeof subject === 'object' ? subject.constructor : subject);
      if (relatedRules.some((rule) => rule.conditions)) {
        throw new NotFoundException();
      }
      throw new UnauthorizedException();
    }
  }

// Delete Enrolled Course of User
  async deleteEnrolledCourse(courseId: Schema.Types.ObjectId): Promise<any> {
    let deletedFrom;
    try {
      const user = await this.userModel.findOne({
        email: this.request['user']['email'],
      });
      if (user) {
        const userId = user.id;
        deletedFrom = await this.enrolledModel.findOneAndRemove({
          studentId: userId,
          courseId: courseId,
        });
        if (deletedFrom) {
          return deletedFrom;
        } else {
          throw new NotFoundException('not found');
        }
      } else {
        throw new NotFoundException('User not found');
      }
    } catch (e) {
      throw new InternalServerErrorException(e);
    }
  }

@Put(':trackId/reactivate')
  @UseGuards(JwtAuthGuard, RolesGuard)
  @Roles(UserRole.ADMIN)
  @ApiResponse({ status: HttpStatus.OK })
  @ApiBearerAuth()
  async enableTrack(@Param('trackId') trackId: string): Promise<void> {
    const track = await this.trackService.findByIdAsync(trackId);

    if (!track) throw new NotFoundException(`Track with ${trackId} not found`);

    await this.trackService.activateTrack(trackId);
  }

@Post(':name/comments')
  @Header('Content-Type', 'application/json')
  async createOrganizationComment(@Param('name') name: string, @Body() comment: CommentDto): Promise<Comment> {
    this.logger.info('OrganizationController#createOrganizationComment.call', name)

    const organization: Organization = await this.organizationsService
      .findByName({
        name
      })
      .toPromise()

    if (!organization) throw new NotFoundException('NOT_FOUND', 'Organization not found.')

    const result: Comment = await this.commentsService
      .create({
        ...comment,
        organization: organization.id
      })
      .toPromise()

    this.logger.info('OrganizationController#createOrganizationComment.result', result)

    return result
  }

async reset(resetPasswordDto: ResetPasswordDto, isValidToken): Promise<User> {
    let { password_1 } = resetPasswordDto;
    password_1 = await bcrypt.hashSync(password_1, 10);
    const user = await this.userModel.findOneAndUpdate(isValidToken.id, { password: password_1 });
    if (user === null) {
      throw new NotFoundException('user not found');
    } else {
      return user;
    }
  }

public async validateUser(
    email: string,
    password: string,
  ): Promise<null | UserInterface> {
    const user = await this.usersRepository.getVerifiedUserByEmail(email) as UserDocument;

    if (!user) {
      throw new NotFoundException('The item does not exist');
    }

    const passwordCompared = await bcrypt.compare(password, user.password);

    if (passwordCompared) {
      return {
        _id: user._id,
        email: user.email,
        role: user.role,
      };
    }

    return null;
  }

//   @Put(':id')
  //   @UsePipes(ValidationPipe)
  //   update(@Param('id') id: string, @Body() updateApplicationDto: UpdateApplicationDto) {
  //     return this.applicationService.update(+id, updateApplicationDto);
  //   }

  @Delete(':id')
  @UsePipes(ValidationPipe)
  async remove(@Request() req, @Param('id') id: string) {
    const user: AuthorizedUser = req.user;
    const application = await this.applicationService.findOneById(id);
    if (application === null) {
      throw new NotFoundException();
    }
    if (String(application.admin) !== user.id) {
      throw new UnauthorizedException();
    }
    await application.remove();
    return 'removed';
  }

private async validateEntityInApp(
    entityId: string,
    appId: string
  ): Promise<void> {
    if (!this.entityService.isEntityInSameApp(entityId, appId)) {
      throw new NotFoundException(
        `Can't find persistent entity with ID ${entityId} in ${appId}`
      );
    }
  }

/**
   * 유저 Id에 해당하는 유저 정보를 반환한다.
   *
   * @param {number} id - 유저 Id
   * @returns {Promise<User>}
   * @private
   */
  private async findUserById(id: number): Promise<User> {
    const user = await this.userRepository.findOne({
      where: { id: id },
    });

    if (isEmpty(user) === true) {
      throw new NotFoundException(Message.NOT_FOUND_USER);
    }

    return user;
  }