finished refactor vistitor password device

libs/common/src/constants/device-type.enum.ts

@@ -0,0 +1,3 @@
+export enum DeviceTypeEnum {
+  DOOR_LOCK = 'DOOR_LOCK',
+}

src/device/controllers/device-project.controller.ts

@@ -1,11 +1,11 @@
 import { DeviceService } from '../services/device.service';
-import { Controller, Get, Param, UseGuards } from '@nestjs/common';
+import { Controller, Get, Param, Query, UseGuards } from '@nestjs/common';
 import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
 import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
 import { ControllerRoute } from '@app/common/constants/controller-route';
 import { PermissionsGuard } from 'src/guards/permissions.guard';
 import { Permissions } from 'src/decorators/permissions.decorator';
-import { ProjectParam } from '../dtos';
+import { GetDoorLockDevices, ProjectParam } from '../dtos';
 
 @ApiTags('Device Module')
 @Controller({
@@ -23,7 +23,10 @@ export class DeviceProjectController {
     summary: ControllerRoute.DEVICE.ACTIONS.GET_ALL_DEVICES_SUMMARY,
     description: ControllerRoute.DEVICE.ACTIONS.GET_ALL_DEVICES_DESCRIPTION,
   })
-  async getAllDevices(@Param() param: ProjectParam) {
+  async getAllDevices(
-    return await this.deviceService.getAllDevices(param);
+    @Param() param: ProjectParam,
+    @Query() query: GetDoorLockDevices,
+  ) {
+    return await this.deviceService.getAllDevices(param, query);
   }
 }

src/device/dtos/get.device.dto.ts

@@ -1,5 +1,6 @@
+import { DeviceTypeEnum } from '@app/common/constants/device-type.enum';
 import { ApiProperty } from '@nestjs/swagger';
-import { IsNotEmpty, IsOptional, IsString } from 'class-validator';
+import { IsEnum, IsNotEmpty, IsOptional, IsString } from 'class-validator';
 
 export class GetDeviceBySpaceUuidDto {
   @ApiProperty({
@@ -33,3 +34,13 @@ export class GetDeviceLogsDto {
   @IsOptional()
   public endTime: string;
 }
+export class GetDoorLockDevices {
+  @ApiProperty({
+    description: 'Device Type',
+    enum: DeviceTypeEnum,
+    required: false,
+  })
+  @IsEnum(DeviceTypeEnum)
+  @IsOptional()
+  public deviceType: DeviceTypeEnum;
+}

src/device/services/device.service.ts

@@ -31,6 +31,7 @@ import {
 import {
   GetDeviceBySpaceUuidDto,
   GetDeviceLogsDto,
+  GetDoorLockDevices,
 } from '../dtos/get.device.dto';
 import {
   BatchControlDevicesDto,
@@ -63,6 +64,7 @@ import { SpaceEntity } from '@app/common/modules/space/entities/space.entity';
 import { ProjectRepository } from '@app/common/modules/project/repositiories';
 import { ProjectParam } from '../dtos';
 import { BatchDeviceTypeEnum } from '@app/common/constants/batch-device.enum';
+import { DeviceTypeEnum } from '@app/common/constants/device-type.enum';
 
 @Injectable()
 export class DeviceService {
@@ -980,10 +982,15 @@ export class DeviceService {
     }
   }
 
-  async getAllDevices(param: ProjectParam): Promise<BaseResponseDto> {
+  async getAllDevices(
+    param: ProjectParam,
+    query: GetDoorLockDevices,
+  ): Promise<BaseResponseDto> {
     try {
       await this.validateProject(param.projectUuid);
-
+      if (query.deviceType === DeviceTypeEnum.DOOR_LOCK) {
+        return await this.getDoorLockDevices(param.projectUuid);
+      } else if (!query.deviceType) {
         const devices = await this.deviceRepository.find({
           where: {
             isActive: true,
@@ -1097,7 +1104,8 @@ export class DeviceService {
           .filter((result) => result.status === DeviceStatuses.FULLFILLED)
           .map(
             (result) =>
-            (result as PromiseFulfilledResult<GetDeviceDetailsInterface>).value,
+              (result as PromiseFulfilledResult<GetDeviceDetailsInterface>)
+                .value,
           );
 
         return new SuccessResponseDto({
@@ -1105,6 +1113,7 @@ export class DeviceService {
           data: fulfilledDevices,
           statusCode: HttpStatus.OK,
         });
+      }
     } catch (error) {
       throw new HttpException(
         error.message || 'Internal server error',
@@ -1650,4 +1659,60 @@ export class DeviceService {
       { spaceDevice: targetSpace },
     );
   }
+  async getDoorLockDevices(projectUuid: string) {
+    await this.validateProject(projectUuid);
+
+    const devices = await this.deviceRepository.find({
+      where: {
+        productDevice: {
+          prodType: ProductType.DL,
+        },
+        spaceDevice: {
+          spaceName: Not(ORPHAN_SPACE_NAME),
+          community: {
+            project: {
+              uuid: projectUuid,
+            },
+          },
+        },
+        isActive: true,
+      },
+      relations: ['productDevice', 'spaceDevice'],
+    });
+
+    const devicesData = await Promise.all(
+      devices?.map(async (device) => {
+        try {
+          const deviceDetails = await this.getDeviceDetailsByDeviceIdTuya(
+            device.deviceTuyaUuid,
+          );
+          return {
+            productUuid: device.productDevice.uuid,
+            productType: device.productDevice.prodType,
+            ...deviceDetails,
+            uuid: device.uuid,
+            spaceName: device.spaceDevice.spaceName,
+          } as GetDeviceDetailsInterface;
+        } catch (error) {
+          console.error(
+            `Error fetching details for device ${device.deviceTuyaUuid}:`,
+            error,
+          );
+          // Return null to indicate the error
+          return null;
+        }
+      }),
+    );
+
+    // Filter out null values to only include successful device data
+    const filteredDevicesData = devicesData.filter(
+      (deviceData) => deviceData !== null,
+    );
+
+    return new SuccessResponseDto({
+      message: 'Successfully retrieved all pass devices',
+      data: filteredDevicesData,
+      statusCode: HttpStatus.OK,
+    });
+  }
 }

src/vistor-password/controllers/visitor-password.controller.ts

@@ -1,13 +1,5 @@
 import { VisitorPasswordService } from '../services/visitor-password.service';
-import {
+import { Body, Controller, Post, UseGuards, Req, Get } from '@nestjs/common';
-  Body,
-  Controller,
-  Post,
-  HttpStatus,
-  UseGuards,
-  Req,
-  Get,
-} from '@nestjs/common';
 import { ApiTags, ApiBearerAuth, ApiOperation } from '@nestjs/swagger';
 import { AddDoorLockTemporaryPasswordDto } from '../dtos/temp-pass.dto';
 import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
@@ -40,16 +32,12 @@ export class VisitorPasswordController {
     @Req() req: any,
   ) {
     const userUuid = req.user.uuid;
-    const temporaryPasswords =
+    const projectUuid = req.user.project.uuid;
-      await this.visitorPasswordService.handleTemporaryPassword(
+    return await this.visitorPasswordService.handleTemporaryPassword(
       addDoorLockTemporaryPasswordDto,
       userUuid,
+      projectUuid,
     );
-
-    return {
-      statusCode: HttpStatus.CREATED,
-      data: temporaryPasswords,
-    };
   }
   @ApiBearerAuth()
   @UseGuards(PermissionsGuard)
@@ -65,19 +53,4 @@ export class VisitorPasswordController {
     const projectUuid = req.user.project.uuid;
     return await this.visitorPasswordService.getPasswords(projectUuid);
   }
-
-  @ApiBearerAuth()
-  @UseGuards(PermissionsGuard)
-  @Permissions('VISITOR_PASSWORD_VIEW')
-  @Get('/devices')
-  @ApiOperation({
-    summary:
-      ControllerRoute.VISITOR_PASSWORD.ACTIONS.GET_VISITOR_DEVICES_SUMMARY,
-    description:
-      ControllerRoute.VISITOR_PASSWORD.ACTIONS.GET_VISITOR_DEVICES_DESCRIPTION,
-  })
-  async GetVisitorDevices(@Req() req: any) {
-    const projectUuid = req.user.project.uuid;
-    return await this.visitorPasswordService.getAllPassDevices(projectUuid);
-  }
 }

src/vistor-password/services/visitor-password.service.ts

@@ -18,7 +18,6 @@ import { AddDoorLockTemporaryPasswordDto } from '../dtos';
 import { EmailService } from '@app/common/util/email.service';
 import { PasswordEncryptionService } from 'src/door-lock/services/encryption.services';
 import { DoorLockService } from 'src/door-lock/services';
-import { GetDeviceDetailsInterface } from 'src/device/interfaces/get.device.interface';
 import { DeviceService } from 'src/device/services';
 import { DeviceStatuses } from '@app/common/constants/device-status.enum';
 import {
@@ -32,6 +31,9 @@ import {
 } from '@app/common/constants/hours-minutes.enum';
 import { ProjectRepository } from '@app/common/modules/project/repositiories';
 import { VisitorPasswordEnum } from '@app/common/constants/visitor-password.enum';
+import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
+import { Not } from 'typeorm';
+import { ORPHAN_SPACE_NAME } from '@app/common/constants/orphan-constant';
 
 @Injectable()
 export class VisitorPasswordService {
@@ -58,43 +60,65 @@ export class VisitorPasswordService {
   async handleTemporaryPassword(
     addDoorLockTemporaryPasswordDto: AddDoorLockTemporaryPasswordDto,
     userUuid: string,
+    projectUuid: string,
   ) {
     const { operationType } = addDoorLockTemporaryPasswordDto;
 
+    let result;
+
     switch (operationType) {
       case VisitorPasswordEnum.ONLINE_ONE_TIME:
-        return this.addOnlineTemporaryPasswordOneTime(
+        result = await this.addOnlineTemporaryPasswordOneTime(
           addDoorLockTemporaryPasswordDto,
           userUuid,
+          projectUuid,
         );
+        break;
       case VisitorPasswordEnum.ONLINE_MULTIPLE_TIME:
-        return this.addOnlineTemporaryPasswordMultipleTime(
+        result = await this.addOnlineTemporaryPasswordMultipleTime(
           addDoorLockTemporaryPasswordDto,
           userUuid,
+          projectUuid,
         );
+        break;
       case VisitorPasswordEnum.OFFLINE_ONE_TIME:
-        return this.addOfflineOneTimeTemporaryPassword(
+        result = await this.addOfflineOneTimeTemporaryPassword(
           addDoorLockTemporaryPasswordDto,
           userUuid,
+          projectUuid,
         );
+        break;
       case VisitorPasswordEnum.OFFLINE_MULTIPLE_TIME:
-        return this.addOfflineMultipleTimeTemporaryPassword(
+        result = await this.addOfflineMultipleTimeTemporaryPassword(
           addDoorLockTemporaryPasswordDto,
           userUuid,
+          projectUuid,
         );
+        break;
       default:
         throw new BadRequestException('Invalid operation type');
     }
+
+    return new SuccessResponseDto({
+      message: `Successfully created new ${operationType.toLowerCase()} visitor password`,
+      data: result,
+      statusCode: HttpStatus.CREATED,
+    });
   }
   async addOfflineMultipleTimeTemporaryPassword(
     addDoorLockOfflineMultipleDto: AddDoorLockTemporaryPasswordDto,
     userUuid: string,
+    projectUuid: string,
   ) {
     try {
       const deviceResults = await Promise.allSettled(
         addDoorLockOfflineMultipleDto.devicesUuid.map(async (deviceUuid) => {
           try {
-            const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
+            const deviceDetails = await this.getDeviceByDeviceUuid(
+              deviceUuid,
+              true,
+              projectUuid,
+            );
 
             if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
               throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
@@ -210,12 +234,17 @@ export class VisitorPasswordService {
   async addOfflineOneTimeTemporaryPassword(
     addDoorLockOfflineOneTimeDto: AddDoorLockTemporaryPasswordDto,
     userUuid: string,
+    projectUuid: string,
   ) {
     try {
       const deviceResults = await Promise.allSettled(
         addDoorLockOfflineOneTimeDto.devicesUuid.map(async (deviceUuid) => {
           try {
-            const deviceDetails = await this.getDeviceByDeviceUuid(deviceUuid);
+            const deviceDetails = await this.getDeviceByDeviceUuid(
+              deviceUuid,
+              true,
+              projectUuid,
+            );
 
             if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
               throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
@@ -361,6 +390,7 @@ export class VisitorPasswordService {
   async addOnlineTemporaryPasswordMultipleTime(
     addDoorLockOnlineMultipleDto: AddDoorLockTemporaryPasswordDto,
     userUuid: string,
+    projectUuid: string,
   ) {
     try {
       const deviceResults = await Promise.allSettled(
@@ -369,6 +399,7 @@ export class VisitorPasswordService {
             const passwordData = await this.getTicketAndEncryptedPassword(
               deviceUuid,
               addDoorLockOnlineMultipleDto.password,
+              projectUuid,
             );
 
             if (
@@ -486,6 +517,7 @@ export class VisitorPasswordService {
           prodType: ProductType.DL,
         },
         spaceDevice: {
+          spaceName: Not(ORPHAN_SPACE_NAME),
           community: {
             project: {
               uuid: projectUuid,
@@ -495,6 +527,7 @@ export class VisitorPasswordService {
         isActive: true,
       },
     });
+
     const data = [];
     deviceIds.forEach((deviceId) => {
       data.push(
@@ -524,62 +557,21 @@ export class VisitorPasswordService {
           .catch(() => {}),
       );
     });
-    return (await Promise.all(data)).flat().filter((datum) => {
+    const result = (await Promise.all(data)).flat().filter((datum) => {
       return datum != null;
     });
-  }
 
-  async getAllPassDevices(projectUuid: string) {
+    return new SuccessResponseDto({
-    await this.validateProject(projectUuid);
+      message: 'Successfully retrieved temporary passwords',
-
+      data: result,
-    const devices = await this.deviceRepository.find({
+      statusCode: HttpStatus.OK,
-      where: {
-        productDevice: {
-          prodType: ProductType.DL,
-        },
-        spaceDevice: {
-          community: {
-            project: {
-              uuid: projectUuid,
-            },
-          },
-        },
-        isActive: true,
-      },
-
-      relations: ['productDevice', 'spaceDevice'],
     });
-    const devicesData = await Promise.all(
-      devices?.map(async (device) => {
-        try {
-          const deviceDetails =
-            await this.deviceService.getDeviceDetailsByDeviceIdTuya(
-              device.deviceTuyaUuid,
-            );
-          return {
-            productUuid: device.productDevice.uuid,
-            productType: device.productDevice.prodType,
-            ...deviceDetails,
-            uuid: device.uuid,
-            spaceName: device.spaceDevice.spaceName,
-          } as GetDeviceDetailsInterface;
-        } catch (error) {
-          console.error(
-            `Error fetching details for device ${device.deviceTuyaUuid}:`,
-            error,
-          );
-          // Return null or a specific value to indicate the error
-          return null;
-        }
-      }),
-    );
-    // Filter out null values to only include successful device data
-    return devicesData.filter((deviceData) => deviceData !== null);
   }
 
   async addOnlineTemporaryPasswordOneTime(
     addDoorLockOnlineOneTimeDto: AddDoorLockTemporaryPasswordDto,
     userUuid: string,
+    projectUuid: string,
   ) {
     try {
       const deviceResults = await Promise.allSettled(
@@ -588,6 +580,7 @@ export class VisitorPasswordService {
             const passwordData = await this.getTicketAndEncryptedPassword(
               deviceUuid,
               addDoorLockOnlineOneTimeDto.password,
+              projectUuid,
             );
 
             if (
@@ -698,9 +691,14 @@ export class VisitorPasswordService {
   async getTicketAndEncryptedPassword(
     doorLockUuid: string,
     passwordPlan: string,
+    projectUuid: string,
   ) {
     try {
-      const deviceDetails = await this.getDeviceByDeviceUuid(doorLockUuid);
+      const deviceDetails = await this.getDeviceByDeviceUuid(
+        doorLockUuid,
+        true,
+        projectUuid,
+      );
 
       if (!deviceDetails || !deviceDetails.deviceTuyaUuid) {
         throw new HttpException('Device Not Found', HttpStatus.NOT_FOUND);
@@ -919,10 +917,19 @@ export class VisitorPasswordService {
   async getDeviceByDeviceUuid(
     deviceUuid: string,
     withProductDevice: boolean = true,
+    projectUuid: string,
   ) {
     try {
       return await this.deviceRepository.findOne({
         where: {
+          spaceDevice: {
+            spaceName: Not(ORPHAN_SPACE_NAME),
+            community: {
+              project: {
+                uuid: projectUuid,
+              },
+            },
+          },
           uuid: deviceUuid,
           isActive: true,
         },