Refactor middleware to guards for type checking

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<boolean> {
+    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',
+      });
+    }
+  }
+}

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<boolean> {
+    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',
+      });
+    }
+  }
+}

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<boolean> {
+    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',
+      });
+    }
+  }
+}

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<boolean> {
+    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',
+      });
+    }
+  }
+}