From 99aca8cf01a830f8e9fbc2925a8deb9b9ca127d1 Mon Sep 17 00:00:00 2001 From: faris Aljohari <83524184+farisaljohari@users.noreply.github.com> Date: Sun, 14 Apr 2024 13:13:56 +0300 Subject: [PATCH] Refactor middleware to guards for type checking --- src/building/building.module.ts | 17 +---- .../controllers/building.controller.ts | 3 +- src/building/services/building.service.ts | 9 ++- src/floor/controllers/floor.controller.ts | 3 +- src/floor/floor.module.ts | 17 +---- src/guards/building.type.guard.ts | 66 +++++++++++++++++ src/guards/community.type.guard.ts | 67 +++++++++++++++++ src/guards/floor.type.guard.ts | 66 +++++++++++++++++ src/guards/unit.type.guard.ts | 66 +++++++++++++++++ src/middleware/CheckBuildingTypeMiddleware.ts | 74 ------------------- .../CheckCommunityTypeMiddleware.ts | 74 ------------------- src/middleware/CheckFloorTypeMiddleware.ts | 74 ------------------- src/middleware/CheckUnitTypeMiddleware.ts | 74 ------------------- src/room/controllers/room.controller.ts | 3 +- src/room/room.module.ts | 17 +---- src/unit/controllers/unit.controller.ts | 3 +- src/unit/unit.module.ts | 17 +---- 17 files changed, 289 insertions(+), 361 deletions(-) create mode 100644 src/guards/building.type.guard.ts create mode 100644 src/guards/community.type.guard.ts create mode 100644 src/guards/floor.type.guard.ts create mode 100644 src/guards/unit.type.guard.ts delete mode 100644 src/middleware/CheckBuildingTypeMiddleware.ts delete mode 100644 src/middleware/CheckCommunityTypeMiddleware.ts delete mode 100644 src/middleware/CheckFloorTypeMiddleware.ts delete mode 100644 src/middleware/CheckUnitTypeMiddleware.ts diff --git a/src/building/building.module.ts b/src/building/building.module.ts index 2bdeb7e..7574f81 100644 --- a/src/building/building.module.ts +++ b/src/building/building.module.ts @@ -1,9 +1,4 @@ -import { - MiddlewareConsumer, - Module, - NestModule, - RequestMethod, -} from '@nestjs/common'; +import { Module } from '@nestjs/common'; import { BuildingService } from './services/building.service'; import { BuildingController } from './controllers/building.controller'; import { ConfigModule } from '@nestjs/config'; @@ -11,7 +6,6 @@ import { SpaceRepositoryModule } from '@app/common/modules/space/space.repositor import { SpaceRepository } from '@app/common/modules/space/repositories'; import { SpaceTypeRepositoryModule } from '@app/common/modules/space-type/space.type.repository.module'; import { SpaceTypeRepository } from '@app/common/modules/space-type/repositories'; -import { CheckCommunityTypeMiddleware } from 'src/middleware/CheckCommunityTypeMiddleware'; @Module({ imports: [ConfigModule, SpaceRepositoryModule, SpaceTypeRepositoryModule], @@ -19,11 +13,4 @@ import { CheckCommunityTypeMiddleware } from 'src/middleware/CheckCommunityTypeM providers: [BuildingService, SpaceRepository, SpaceTypeRepository], exports: [BuildingService], }) -export class BuildingModule implements NestModule { - configure(consumer: MiddlewareConsumer) { - consumer.apply(CheckCommunityTypeMiddleware).forRoutes({ - path: '/building', - method: RequestMethod.POST, - }); - } -} +export class BuildingModule {} diff --git a/src/building/controllers/building.controller.ts b/src/building/controllers/building.controller.ts index 81365fb..ec4a616 100644 --- a/src/building/controllers/building.controller.ts +++ b/src/building/controllers/building.controller.ts @@ -16,6 +16,7 @@ import { JwtAuthGuard } from '../../../libs/common/src/guards/jwt.auth.guard'; import { AddBuildingDto } from '../dtos/add.building.dto'; import { GetBuildingChildDto } from '../dtos/get.building.dto'; import { UpdateBuildingNameDto } from '../dtos/update.building.dto'; +import { CheckCommunityTypeGuard } from 'src/guards/community.type.guard'; @ApiTags('Building Module') @Controller({ @@ -26,7 +27,7 @@ export class BuildingController { constructor(private readonly buildingService: BuildingService) {} @ApiBearerAuth() - @UseGuards(JwtAuthGuard) + @UseGuards(JwtAuthGuard, CheckCommunityTypeGuard) @Post() async addBuilding(@Body() addBuildingDto: AddBuildingDto) { try { diff --git a/src/building/services/building.service.ts b/src/building/services/building.service.ts index 62081e8..7bfd33c 100644 --- a/src/building/services/building.service.ts +++ b/src/building/services/building.service.ts @@ -32,13 +32,20 @@ export class BuildingService { }, }); + if (!spaceType) { + throw new BadRequestException('Invalid building UUID'); + } await this.spaceRepository.save({ spaceName: addBuildingDto.buildingName, parent: { uuid: addBuildingDto.communityUuid }, spaceType: { uuid: spaceType.uuid }, }); } catch (err) { - throw new HttpException(err.message, HttpStatus.INTERNAL_SERVER_ERROR); + if (err instanceof BadRequestException) { + throw err; // Re-throw BadRequestException + } else { + throw new HttpException('Building not found', HttpStatus.NOT_FOUND); + } } } diff --git a/src/floor/controllers/floor.controller.ts b/src/floor/controllers/floor.controller.ts index 87ac04a..5c1021a 100644 --- a/src/floor/controllers/floor.controller.ts +++ b/src/floor/controllers/floor.controller.ts @@ -16,6 +16,7 @@ import { JwtAuthGuard } from '../../../libs/common/src/guards/jwt.auth.guard'; import { AddFloorDto } from '../dtos/add.floor.dto'; import { GetFloorChildDto } from '../dtos/get.floor.dto'; import { UpdateFloorNameDto } from '../dtos/update.floor.dto'; +import { CheckBuildingTypeGuard } from 'src/guards/building.type.guard'; @ApiTags('Floor Module') @Controller({ @@ -26,7 +27,7 @@ export class FloorController { constructor(private readonly floorService: FloorService) {} @ApiBearerAuth() - @UseGuards(JwtAuthGuard) + @UseGuards(JwtAuthGuard, CheckBuildingTypeGuard) @Post() async addFloor(@Body() addFloorDto: AddFloorDto) { try { diff --git a/src/floor/floor.module.ts b/src/floor/floor.module.ts index 199f876..7085659 100644 --- a/src/floor/floor.module.ts +++ b/src/floor/floor.module.ts @@ -1,9 +1,4 @@ -import { - MiddlewareConsumer, - Module, - NestModule, - RequestMethod, -} from '@nestjs/common'; +import { Module } from '@nestjs/common'; import { FloorService } from './services/floor.service'; import { FloorController } from './controllers/floor.controller'; import { ConfigModule } from '@nestjs/config'; @@ -11,7 +6,6 @@ import { SpaceRepositoryModule } from '@app/common/modules/space/space.repositor import { SpaceRepository } from '@app/common/modules/space/repositories'; import { SpaceTypeRepositoryModule } from '@app/common/modules/space-type/space.type.repository.module'; import { SpaceTypeRepository } from '@app/common/modules/space-type/repositories'; -import { CheckBuildingTypeMiddleware } from 'src/middleware/CheckBuildingTypeMiddleware'; @Module({ imports: [ConfigModule, SpaceRepositoryModule, SpaceTypeRepositoryModule], @@ -19,11 +13,4 @@ import { CheckBuildingTypeMiddleware } from 'src/middleware/CheckBuildingTypeMid providers: [FloorService, SpaceRepository, SpaceTypeRepository], exports: [FloorService], }) -export class FloorModule implements NestModule { - configure(consumer: MiddlewareConsumer) { - consumer.apply(CheckBuildingTypeMiddleware).forRoutes({ - path: '/floor', - method: RequestMethod.POST, - }); - } -} +export class FloorModule {} diff --git a/src/guards/building.type.guard.ts b/src/guards/building.type.guard.ts new file mode 100644 index 0000000..1e36d9f --- /dev/null +++ b/src/guards/building.type.guard.ts @@ -0,0 +1,66 @@ +import { SpaceRepository } from '@app/common/modules/space/repositories'; +import { + Injectable, + CanActivate, + HttpStatus, + BadRequestException, + ExecutionContext, +} from '@nestjs/common'; + +@Injectable() +export class CheckBuildingTypeGuard implements CanActivate { + constructor(private readonly spaceRepository: SpaceRepository) {} + + async canActivate(context: ExecutionContext): Promise { + const req = context.switchToHttp().getRequest(); + + try { + const { floorName, buildingUuid } = req.body; + + if (!floorName) { + throw new BadRequestException('floorName is required'); + } + + if (!buildingUuid) { + throw new BadRequestException('buildingUuid is required'); + } + + await this.checkBuildingIsBuildingType(buildingUuid); + + return true; + } catch (error) { + this.handleGuardError(error, context); + return false; + } + } + + async checkBuildingIsBuildingType(buildingUuid: string) { + const buildingData = await this.spaceRepository.findOne({ + where: { uuid: buildingUuid }, + relations: ['spaceType'], + }); + if ( + !buildingData || + !buildingData.spaceType || + buildingData.spaceType.type !== 'building' + ) { + throw new BadRequestException('Invalid building UUID'); + } + } + + private handleGuardError(error: Error, context: ExecutionContext) { + const response = context.switchToHttp().getResponse(); + console.error(error); + + if (error instanceof BadRequestException) { + response + .status(HttpStatus.BAD_REQUEST) + .json({ statusCode: HttpStatus.BAD_REQUEST, message: error.message }); + } else { + response.status(HttpStatus.NOT_FOUND).json({ + statusCode: HttpStatus.NOT_FOUND, + message: 'Building not found', + }); + } + } +} diff --git a/src/guards/community.type.guard.ts b/src/guards/community.type.guard.ts new file mode 100644 index 0000000..e8212f4 --- /dev/null +++ b/src/guards/community.type.guard.ts @@ -0,0 +1,67 @@ +import { + CanActivate, + ExecutionContext, + Injectable, + HttpStatus, +} from '@nestjs/common'; +import { SpaceRepository } from '@app/common/modules/space/repositories'; +import { BadRequestException } from '@nestjs/common'; + +@Injectable() +export class CheckCommunityTypeGuard implements CanActivate { + constructor(private readonly spaceRepository: SpaceRepository) {} + + async canActivate(context: ExecutionContext): Promise { + const req = context.switchToHttp().getRequest(); + + try { + const { buildingName, communityUuid } = req.body; + + if (!buildingName) { + throw new BadRequestException('buildingName is required'); + } + + if (!communityUuid) { + throw new BadRequestException('communityUuid is required'); + } + + await this.checkCommunityIsCommunityType(communityUuid); + + return true; + } catch (error) { + this.handleGuardError(error, context); + return false; + } + } + + private async checkCommunityIsCommunityType(communityUuid: string) { + const communityData = await this.spaceRepository.findOne({ + where: { uuid: communityUuid }, + relations: ['spaceType'], + }); + + if ( + !communityData || + !communityData.spaceType || + communityData.spaceType.type !== 'community' + ) { + throw new BadRequestException('Invalid community UUID'); + } + } + + private handleGuardError(error: Error, context: ExecutionContext) { + const response = context.switchToHttp().getResponse(); + console.error(error); + + if (error instanceof BadRequestException) { + response + .status(HttpStatus.BAD_REQUEST) + .json({ statusCode: HttpStatus.BAD_REQUEST, message: error.message }); + } else { + response.status(HttpStatus.NOT_FOUND).json({ + statusCode: HttpStatus.NOT_FOUND, + message: 'Community not found', + }); + } + } +} diff --git a/src/guards/floor.type.guard.ts b/src/guards/floor.type.guard.ts new file mode 100644 index 0000000..8064cb2 --- /dev/null +++ b/src/guards/floor.type.guard.ts @@ -0,0 +1,66 @@ +import { SpaceRepository } from '@app/common/modules/space/repositories'; +import { + Injectable, + CanActivate, + HttpStatus, + ExecutionContext, + BadRequestException, +} from '@nestjs/common'; + +@Injectable() +export class CheckFloorTypeGuard implements CanActivate { + constructor(private readonly spaceRepository: SpaceRepository) {} + + async canActivate(context: ExecutionContext): Promise { + const req = context.switchToHttp().getRequest(); + try { + const { unitName, floorUuid } = req.body; + + if (!unitName) { + throw new BadRequestException('unitName is required'); + } + + if (!floorUuid) { + throw new BadRequestException('floorUuid is required'); + } + + await this.checkFloorIsFloorType(floorUuid); + + return true; + } catch (error) { + this.handleGuardError(error, context); + return false; + } + } + + async checkFloorIsFloorType(floorUuid: string) { + const floorData = await this.spaceRepository.findOne({ + where: { uuid: floorUuid }, + relations: ['spaceType'], + }); + + if ( + !floorData || + !floorData.spaceType || + floorData.spaceType.type !== 'floor' + ) { + throw new BadRequestException('Invalid floor UUID'); + } + } + + private handleGuardError(error: Error, context: ExecutionContext) { + const response = context.switchToHttp().getResponse(); + console.error(error); + + if (error instanceof BadRequestException) { + response + .status(HttpStatus.BAD_REQUEST) + .json({ statusCode: HttpStatus.BAD_REQUEST, message: error.message }); + } else { + response.status(HttpStatus.NOT_FOUND).json({ + statusCode: HttpStatus.NOT_FOUND, + message: 'Floor not found', + }); + } + } +} diff --git a/src/guards/unit.type.guard.ts b/src/guards/unit.type.guard.ts new file mode 100644 index 0000000..f1e292f --- /dev/null +++ b/src/guards/unit.type.guard.ts @@ -0,0 +1,66 @@ +import { SpaceRepository } from '@app/common/modules/space/repositories'; +import { + Injectable, + CanActivate, + HttpStatus, + BadRequestException, + ExecutionContext, +} from '@nestjs/common'; + +@Injectable() +export class CheckUnitTypeGuard implements CanActivate { + constructor(private readonly spaceRepository: SpaceRepository) {} + + async canActivate(context: ExecutionContext): Promise { + const req = context.switchToHttp().getRequest(); + try { + const { roomName, unitUuid } = req.body; + + if (!roomName) { + throw new BadRequestException('roomName is required'); + } + + if (!unitUuid) { + throw new BadRequestException('unitUuid is required'); + } + + await this.checkFloorIsFloorType(unitUuid); + + return true; + } catch (error) { + this.handleGuardError(error, context); + return false; + } + } + + async checkFloorIsFloorType(unitUuid: string) { + const unitData = await this.spaceRepository.findOne({ + where: { uuid: unitUuid }, + relations: ['spaceType'], + }); + + if ( + !unitData || + !unitData.spaceType || + unitData.spaceType.type !== 'unit' + ) { + throw new BadRequestException('Invalid unit UUID'); + } + } + + private handleGuardError(error: Error, context: ExecutionContext) { + const response = context.switchToHttp().getResponse(); + console.error(error); + + if (error instanceof BadRequestException) { + response + .status(HttpStatus.BAD_REQUEST) + .json({ statusCode: HttpStatus.BAD_REQUEST, message: error.message }); + } else { + response.status(HttpStatus.NOT_FOUND).json({ + statusCode: HttpStatus.NOT_FOUND, + message: 'Unit not found', + }); + } + } +} diff --git a/src/middleware/CheckBuildingTypeMiddleware.ts b/src/middleware/CheckBuildingTypeMiddleware.ts deleted file mode 100644 index 170cb9b..0000000 --- a/src/middleware/CheckBuildingTypeMiddleware.ts +++ /dev/null @@ -1,74 +0,0 @@ -import { SpaceRepository } from '@app/common/modules/space/repositories'; -import { - Injectable, - NestMiddleware, - HttpStatus, - HttpException, -} from '@nestjs/common'; -import { Request, Response, NextFunction } from 'express'; - -@Injectable() -export class CheckBuildingTypeMiddleware implements NestMiddleware { - constructor(private readonly spaceRepository: SpaceRepository) {} - - async use(req: Request, res: Response, next: NextFunction) { - try { - // Destructure request body for cleaner code - const { floorName, buildingUuid } = req.body; - - // Guard clauses for early return - if (!floorName) { - return res.status(HttpStatus.BAD_REQUEST).json({ - statusCode: HttpStatus.BAD_REQUEST, - message: 'floorName is required', - }); - } - - if (!buildingUuid) { - return res.status(HttpStatus.BAD_REQUEST).json({ - statusCode: HttpStatus.BAD_REQUEST, - message: 'buildingUuid is required', - }); - } - - // Call function to check if building is a building - await this.checkBuildingIsBuildingType(buildingUuid); - - // Call next middleware - next(); - } catch (error) { - // Handle errors - this.handleMiddlewareError(error, res); - } - } - - async checkBuildingIsBuildingType(buildingUuid: string) { - const buildingData = await this.spaceRepository.findOne({ - where: { uuid: buildingUuid }, - relations: ['spaceType'], - }); - - // Throw error if building not found - if (!buildingData) { - throw new HttpException('Building not found', HttpStatus.NOT_FOUND); - } - - // Throw error if building is not of type 'building' - if (buildingData.spaceType.type !== 'building') { - throw new HttpException( - "buildingUuid is not of type 'building'", - HttpStatus.BAD_REQUEST, - ); - } - } - - // Function to handle middleware errors - private handleMiddlewareError(error: Error, res: Response) { - const status = - error instanceof HttpException - ? error.getStatus() - : HttpStatus.INTERNAL_SERVER_ERROR; - const message = error.message || 'Internal server error'; - res.status(status).json({ statusCode: status, message }); - } -} diff --git a/src/middleware/CheckCommunityTypeMiddleware.ts b/src/middleware/CheckCommunityTypeMiddleware.ts deleted file mode 100644 index 3eef679..0000000 --- a/src/middleware/CheckCommunityTypeMiddleware.ts +++ /dev/null @@ -1,74 +0,0 @@ -import { SpaceRepository } from '@app/common/modules/space/repositories'; -import { - Injectable, - NestMiddleware, - HttpStatus, - HttpException, -} from '@nestjs/common'; -import { Request, Response, NextFunction } from 'express'; - -@Injectable() -export class CheckCommunityTypeMiddleware implements NestMiddleware { - constructor(private readonly spaceRepository: SpaceRepository) {} - - async use(req: Request, res: Response, next: NextFunction) { - try { - // Destructure request body for cleaner code - const { buildingName, communityUuid } = req.body; - - // Guard clauses for early return - if (!buildingName) { - return res.status(HttpStatus.BAD_REQUEST).json({ - statusCode: HttpStatus.BAD_REQUEST, - message: 'buildingName is required', - }); - } - - if (!communityUuid) { - return res.status(HttpStatus.BAD_REQUEST).json({ - statusCode: HttpStatus.BAD_REQUEST, - message: 'communityUuid is required', - }); - } - - // Call function to check if community is a building - await this.checkCommunityIsCommunityType(communityUuid); - - // Call next middleware - next(); - } catch (error) { - // Handle errors - this.handleMiddlewareError(error, res); - } - } - - async checkCommunityIsCommunityType(communityUuid: string) { - const communityData = await this.spaceRepository.findOne({ - where: { uuid: communityUuid }, - relations: ['spaceType'], - }); - - // Throw error if community not found - if (!communityData) { - throw new HttpException('Community not found', HttpStatus.NOT_FOUND); - } - - // Throw error if community is not of type 'community' - if (communityData.spaceType.type !== 'community') { - throw new HttpException( - "communityUuid is not of type 'community'", - HttpStatus.BAD_REQUEST, - ); - } - } - - // Function to handle middleware errors - private handleMiddlewareError(error: Error, res: Response) { - const status = - error instanceof HttpException - ? error.getStatus() - : HttpStatus.INTERNAL_SERVER_ERROR; - const message = error.message || 'Internal server error'; - res.status(status).json({ statusCode: status, message }); - } -} diff --git a/src/middleware/CheckFloorTypeMiddleware.ts b/src/middleware/CheckFloorTypeMiddleware.ts deleted file mode 100644 index e096750..0000000 --- a/src/middleware/CheckFloorTypeMiddleware.ts +++ /dev/null @@ -1,74 +0,0 @@ -import { SpaceRepository } from '@app/common/modules/space/repositories'; -import { - Injectable, - NestMiddleware, - HttpStatus, - HttpException, -} from '@nestjs/common'; -import { Request, Response, NextFunction } from 'express'; - -@Injectable() -export class CheckFloorTypeMiddleware implements NestMiddleware { - constructor(private readonly spaceRepository: SpaceRepository) {} - - async use(req: Request, res: Response, next: NextFunction) { - try { - // Destructure request body for cleaner code - const { unitName, floorUuid } = req.body; - - // Guard clauses for early return - if (!unitName) { - return res.status(HttpStatus.BAD_REQUEST).json({ - statusCode: HttpStatus.BAD_REQUEST, - message: 'unitName is required', - }); - } - - if (!floorUuid) { - return res.status(HttpStatus.BAD_REQUEST).json({ - statusCode: HttpStatus.BAD_REQUEST, - message: 'floorUuid is required', - }); - } - - // Call function to check if floor is a floor - await this.checkFloorIsFloorType(floorUuid); - - // Call next middleware - next(); - } catch (error) { - // Handle errors - this.handleMiddlewareError(error, res); - } - } - - async checkFloorIsFloorType(floorUuid: string) { - const floorData = await this.spaceRepository.findOne({ - where: { uuid: floorUuid }, - relations: ['spaceType'], - }); - - // Throw error if floor not found - if (!floorData) { - throw new HttpException('Floor not found', HttpStatus.NOT_FOUND); - } - - // Throw error if floor is not of type 'floor' - if (floorData.spaceType.type !== 'floor') { - throw new HttpException( - "floorUuid is not of type 'floor'", - HttpStatus.BAD_REQUEST, - ); - } - } - - // Function to handle middleware errors - private handleMiddlewareError(error: Error, res: Response) { - const status = - error instanceof HttpException - ? error.getStatus() - : HttpStatus.INTERNAL_SERVER_ERROR; - const message = error.message || 'Internal server error'; - res.status(status).json({ statusCode: status, message }); - } -} diff --git a/src/middleware/CheckUnitTypeMiddleware.ts b/src/middleware/CheckUnitTypeMiddleware.ts deleted file mode 100644 index 7f5ba6a..0000000 --- a/src/middleware/CheckUnitTypeMiddleware.ts +++ /dev/null @@ -1,74 +0,0 @@ -import { SpaceRepository } from '@app/common/modules/space/repositories'; -import { - Injectable, - NestMiddleware, - HttpStatus, - HttpException, -} from '@nestjs/common'; -import { Request, Response, NextFunction } from 'express'; - -@Injectable() -export class CheckUnitTypeMiddleware implements NestMiddleware { - constructor(private readonly spaceRepository: SpaceRepository) {} - - async use(req: Request, res: Response, next: NextFunction) { - try { - // Destructure request body for cleaner code - const { roomName, unitUuid } = req.body; - - // Guard clauses for early return - if (!roomName) { - return res.status(HttpStatus.BAD_REQUEST).json({ - statusCode: HttpStatus.BAD_REQUEST, - message: 'roomName is required', - }); - } - - if (!unitUuid) { - return res.status(HttpStatus.BAD_REQUEST).json({ - statusCode: HttpStatus.BAD_REQUEST, - message: 'unitUuid is required', - }); - } - - // Call function to check if unit is a unit - await this.checkFloorIsFloorType(unitUuid); - - // Call next middleware - next(); - } catch (error) { - // Handle errors - this.handleMiddlewareError(error, res); - } - } - - async checkFloorIsFloorType(unitUuid: string) { - const unitData = await this.spaceRepository.findOne({ - where: { uuid: unitUuid }, - relations: ['spaceType'], - }); - - // Throw error if unit not found - if (!unitData) { - throw new HttpException('Floor not found', HttpStatus.NOT_FOUND); - } - - // Throw error if unit is not of type 'unit' - if (unitData.spaceType.type !== 'unit') { - throw new HttpException( - "unitUuid is not of type 'unit'", - HttpStatus.BAD_REQUEST, - ); - } - } - - // Function to handle middleware errors - private handleMiddlewareError(error: Error, res: Response) { - const status = - error instanceof HttpException - ? error.getStatus() - : HttpStatus.INTERNAL_SERVER_ERROR; - const message = error.message || 'Internal server error'; - res.status(status).json({ statusCode: status, message }); - } -} diff --git a/src/room/controllers/room.controller.ts b/src/room/controllers/room.controller.ts index 43f6bd8..b0e4e3f 100644 --- a/src/room/controllers/room.controller.ts +++ b/src/room/controllers/room.controller.ts @@ -14,6 +14,7 @@ import { ApiTags, ApiBearerAuth } from '@nestjs/swagger'; import { JwtAuthGuard } from '../../../libs/common/src/guards/jwt.auth.guard'; import { AddRoomDto } from '../dtos/add.room.dto'; import { UpdateRoomNameDto } from '../dtos/update.room.dto'; +import { CheckUnitTypeGuard } from 'src/guards/unit.type.guard'; @ApiTags('Room Module') @Controller({ @@ -24,7 +25,7 @@ export class RoomController { constructor(private readonly roomService: RoomService) {} @ApiBearerAuth() - @UseGuards(JwtAuthGuard) + @UseGuards(JwtAuthGuard, CheckUnitTypeGuard) @Post() async addRoom(@Body() addRoomDto: AddRoomDto) { try { diff --git a/src/room/room.module.ts b/src/room/room.module.ts index 660fbec..8411cd4 100644 --- a/src/room/room.module.ts +++ b/src/room/room.module.ts @@ -1,9 +1,4 @@ -import { - MiddlewareConsumer, - Module, - NestModule, - RequestMethod, -} from '@nestjs/common'; +import { Module } from '@nestjs/common'; import { RoomService } from './services/room.service'; import { RoomController } from './controllers/room.controller'; import { ConfigModule } from '@nestjs/config'; @@ -11,7 +6,6 @@ import { SpaceRepositoryModule } from '@app/common/modules/space/space.repositor import { SpaceRepository } from '@app/common/modules/space/repositories'; import { SpaceTypeRepositoryModule } from '@app/common/modules/space-type/space.type.repository.module'; import { SpaceTypeRepository } from '@app/common/modules/space-type/repositories'; -import { CheckUnitTypeMiddleware } from 'src/middleware/CheckUnitTypeMiddleware'; @Module({ imports: [ConfigModule, SpaceRepositoryModule, SpaceTypeRepositoryModule], @@ -19,11 +13,4 @@ import { CheckUnitTypeMiddleware } from 'src/middleware/CheckUnitTypeMiddleware' providers: [RoomService, SpaceRepository, SpaceTypeRepository], exports: [RoomService], }) -export class RoomModule implements NestModule { - configure(consumer: MiddlewareConsumer) { - consumer.apply(CheckUnitTypeMiddleware).forRoutes({ - path: '/room', - method: RequestMethod.POST, - }); - } -} +export class RoomModule {} diff --git a/src/unit/controllers/unit.controller.ts b/src/unit/controllers/unit.controller.ts index f56b9c7..f36a510 100644 --- a/src/unit/controllers/unit.controller.ts +++ b/src/unit/controllers/unit.controller.ts @@ -16,6 +16,7 @@ import { JwtAuthGuard } from '../../../libs/common/src/guards/jwt.auth.guard'; import { AddUnitDto } from '../dtos/add.unit.dto'; import { GetUnitChildDto } from '../dtos/get.unit.dto'; import { UpdateUnitNameDto } from '../dtos/update.unit.dto'; +import { CheckFloorTypeGuard } from 'src/guards/floor.type.guard'; @ApiTags('Unit Module') @Controller({ @@ -26,7 +27,7 @@ export class UnitController { constructor(private readonly unitService: UnitService) {} @ApiBearerAuth() - @UseGuards(JwtAuthGuard) + @UseGuards(JwtAuthGuard, CheckFloorTypeGuard) @Post() async addUnit(@Body() addUnitDto: AddUnitDto) { try { diff --git a/src/unit/unit.module.ts b/src/unit/unit.module.ts index 0ebee41..eaf571f 100644 --- a/src/unit/unit.module.ts +++ b/src/unit/unit.module.ts @@ -1,9 +1,4 @@ -import { - MiddlewareConsumer, - Module, - NestModule, - RequestMethod, -} from '@nestjs/common'; +import { Module } from '@nestjs/common'; import { UnitService } from './services/unit.service'; import { UnitController } from './controllers/unit.controller'; import { ConfigModule } from '@nestjs/config'; @@ -11,7 +6,6 @@ import { SpaceRepositoryModule } from '@app/common/modules/space/space.repositor import { SpaceRepository } from '@app/common/modules/space/repositories'; import { SpaceTypeRepositoryModule } from '@app/common/modules/space-type/space.type.repository.module'; import { SpaceTypeRepository } from '@app/common/modules/space-type/repositories'; -import { CheckFloorTypeMiddleware } from 'src/middleware/CheckFloorTypeMiddleware'; @Module({ imports: [ConfigModule, SpaceRepositoryModule, SpaceTypeRepositoryModule], @@ -19,11 +13,4 @@ import { CheckFloorTypeMiddleware } from 'src/middleware/CheckFloorTypeMiddlewar providers: [UnitService, SpaceRepository, SpaceTypeRepository], exports: [UnitService], }) -export class UnitModule implements NestModule { - configure(consumer: MiddlewareConsumer) { - consumer.apply(CheckFloorTypeMiddleware).forRoutes({ - path: '/unit', - method: RequestMethod.POST, - }); - } -} +export class UnitModule {}