Refactor activation code handling and user space verification

src/invite-user/controllers/invite-user.controller.ts

@@ -76,9 +76,7 @@ export class InviteUserController {
   async activationCodeController(
     @Body() activateCodeDto: ActivateCodeDto,
   ): Promise<BaseResponseDto> {
-    return await this.inviteUserService.activationCodeController(
+    return await this.inviteUserService.activationCode(activateCodeDto);
-      activateCodeDto,
-    );
   }
   @ApiBearerAuth()
   @UseGuards(JwtAuthGuard)

src/invite-user/invite-user.module.ts

@@ -23,12 +23,14 @@ import { SpaceModelRepository } from '@app/common/modules/space-model';
 import { CommunityRepository } from '@app/common/modules/community/repositories';
 import { ProjectRepository } from '@app/common/modules/project/repositiories';
 import { TuyaService } from '@app/common/integrations/tuya/services/tuya.service';
-import { UserSpaceService } from 'src/users/services';
+import { UserService, UserSpaceService } from 'src/users/services';
 import { UserDevicePermissionService } from 'src/user-device-permission/services';
 import { DeviceUserPermissionRepository } from '@app/common/modules/device/repositories';
 import { PermissionTypeRepository } from '@app/common/modules/permission/repositories';
 import { ProjectUserService } from 'src/project/services/project-user.service';
 import { RoleTypeRepository } from '@app/common/modules/role-type/repositories';
+import { RegionRepository } from '@app/common/modules/region/repositories';
+import { TimeZoneRepository } from '@app/common/modules/timezone/repositories';
 
 @Module({
   imports: [ConfigModule, InviteUserRepositoryModule],
@@ -55,6 +57,9 @@ import { RoleTypeRepository } from '@app/common/modules/role-type/repositories';
     ProjectUserService,
     RoleTypeRepository,
     InviteSpaceRepository,
+    UserService,
+    RegionRepository,
+    TimeZoneRepository,
   ],
   exports: [InviteUserService],
 })

src/invite-user/services/invite-user.service.ts

@@ -29,6 +29,7 @@ import {
   UpdateUserInvitationDto,
 } from '../dtos/update.invite-user.dto';
 import { RoleTypeRepository } from '@app/common/modules/role-type/repositories';
+import { InviteUserEntity } from '@app/common/modules/Invite-user/entities';
 
 @Injectable()
 export class InviteUserService {
@@ -188,76 +189,35 @@ export class InviteUserService {
       );
     }
   }
-  async activationCodeController(
+  async activationCode(dto: ActivateCodeDto): Promise<BaseResponseDto> {
-    dto: ActivateCodeDto,
-  ): Promise<BaseResponseDto> {
-    try {
     const { activationCode, userUuid } = dto;
-      const user = await this.userRepository.findOne({
-        where: { uuid: userUuid, isActive: true, isUserVerified: true },
-      });
 
-      if (!user) {
+    try {
-        throw new HttpException('User not found', HttpStatus.NOT_FOUND);
+      const user = await this.getUser(userUuid);
-      }
+
-      const { email } = user;
       const invitedUser = await this.inviteUserRepository.findOne({
         where: {
-          email,
+          email: user.email,
-          invitationCode: activationCode,
           status: UserStatusEnum.INVITED,
           isActive: true,
         },
         relations: ['project', 'spaces.space.community', 'roleType'],
       });
 
-      if (!invitedUser) {
+      if (invitedUser) {
+        if (invitedUser.invitationCode !== activationCode) {
           throw new HttpException(
             'Invalid activation code',
             HttpStatus.BAD_REQUEST,
           );
         }
 
-      for (const invitedSpace of invitedUser.spaces) {
+        // Handle invited user with valid activation code
-        try {
+        await this.handleInvitedUser(user, invitedUser);
-          const deviceUUIDs =
+      } else {
-            await this.userSpaceService.getDeviceUUIDsForSpace(
+        // Handle case for non-invited user
-              invitedSpace.space.uuid,
+        await this.handleNonInvitedUser(activationCode, userUuid);
-            );
-
-          await this.userSpaceService.addUserPermissionsToDevices(
-            userUuid,
-            deviceUUIDs,
-          );
-
-          await this.spaceUserService.associateUserToSpace({
-            communityUuid: invitedSpace.space.community.uuid,
-            spaceUuid: invitedSpace.space.uuid,
-            userUuid: user.uuid,
-            projectUuid: invitedUser.project.uuid,
-          });
-        } catch (spaceError) {
-          console.error(
-            `Error processing space ${invitedSpace.space.uuid}:`,
-            spaceError,
-          );
-          // Skip to the next space
-          continue;
       }
-      }
-
-      await this.inviteUserRepository.update(
-        { uuid: invitedUser.uuid },
-        { status: UserStatusEnum.ACTIVE },
-      );
-      await this.userRepository.update(
-        { uuid: userUuid },
-        {
-          project: { uuid: invitedUser.project.uuid },
-          inviteUser: { uuid: invitedUser.uuid },
-          roleType: { uuid: invitedUser.roleType.uuid },
-        },
-      );
       return new SuccessResponseDto({
         statusCode: HttpStatus.OK,
         success: true,
@@ -272,6 +232,73 @@ export class InviteUserService {
       );
     }
   }
+
+  private async getUser(userUuid: string): Promise<UserEntity> {
+    const user = await this.userRepository.findOne({
+      where: { uuid: userUuid, isActive: true, isUserVerified: true },
+    });
+
+    if (!user) {
+      throw new HttpException('User not found', HttpStatus.NOT_FOUND);
+    }
+    return user;
+  }
+
+  private async handleNonInvitedUser(
+    activationCode: string,
+    userUuid: string,
+  ): Promise<void> {
+    await this.userSpaceService.verifyCodeAndAddUserSpace(
+      { inviteCode: activationCode },
+      userUuid,
+    );
+  }
+
+  private async handleInvitedUser(
+    user: UserEntity,
+    invitedUser: InviteUserEntity,
+  ): Promise<void> {
+    for (const invitedSpace of invitedUser.spaces) {
+      try {
+        const deviceUUIDs = await this.userSpaceService.getDeviceUUIDsForSpace(
+          invitedSpace.space.uuid,
+        );
+
+        await this.userSpaceService.addUserPermissionsToDevices(
+          user.uuid,
+          deviceUUIDs,
+        );
+
+        await this.spaceUserService.associateUserToSpace({
+          communityUuid: invitedSpace.space.community.uuid,
+          spaceUuid: invitedSpace.space.uuid,
+          userUuid: user.uuid,
+          projectUuid: invitedUser.project.uuid,
+        });
+      } catch (spaceError) {
+        console.error(
+          `Error processing space ${invitedSpace.space.uuid}:`,
+          spaceError,
+        );
+        continue; // Skip to the next space
+      }
+    }
+
+    // Update invited user and associated user data
+    await this.inviteUserRepository.update(
+      { uuid: invitedUser.uuid },
+      { status: UserStatusEnum.ACTIVE },
+    );
+    await this.userRepository.update(
+      { uuid: user.uuid },
+      {
+        project: { uuid: invitedUser.project.uuid },
+        inviteUser: { uuid: invitedUser.uuid },
+        roleType: { uuid: invitedUser.roleType.uuid },
+      },
+    );
+  }
+
   async updateUserInvitation(
     dto: UpdateUserInvitationDto,
     invitedUserUuid: string,

src/users/controllers/user-space.controller.ts

@@ -1,20 +1,11 @@
 import { ControllerRoute } from '@app/common/constants/controller-route';
 import { EnableDisableStatusEnum } from '@app/common/constants/days.enum';
-import {
+import { Controller, Get, Param, UseGuards } from '@nestjs/common';
-  Body,
-  Controller,
-  Get,
-  HttpException,
-  HttpStatus,
-  Param,
-  Post,
-  UseGuards,
-} from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 import { UserSpaceService } from '../services';
 import { JwtAuthGuard } from '@app/common/guards/jwt.auth.guard';
 import { BaseResponseDto } from '@app/common/dto/base.response.dto';
-import { AddUserSpaceUsingCodeDto, UserParamDto } from '../dtos';
+import { UserParamDto } from '../dtos';
 
 @ApiTags('User Module')
 @Controller({
@@ -36,36 +27,4 @@ export class UserSpaceController {
   ): Promise<BaseResponseDto> {
     return this.userSpaceService.getSpacesForUser(params.userUuid);
   }
-
-  @ApiBearerAuth()
-  @UseGuards(JwtAuthGuard)
-  @Post('/verify-code')
-  @ApiOperation({
-    summary:
-      ControllerRoute.USER_SPACE.ACTIONS.VERIFY_CODE_AND_ADD_USER_SPACE_SUMMARY,
-    description:
-      ControllerRoute.USER_SPACE.ACTIONS
-        .VERIFY_CODE_AND_ADD_USER_SPACE_DESCRIPTION,
-  })
-  async verifyCodeAndAddUserSpace(
-    @Body() dto: AddUserSpaceUsingCodeDto,
-    @Param() params: UserParamDto,
-  ) {
-    try {
-      await this.userSpaceService.verifyCodeAndAddUserSpace(
-        dto,
-        params.userUuid,
-      );
-      return {
-        statusCode: HttpStatus.CREATED,
-        success: true,
-        message: 'user space added successfully',
-      };
-    } catch (error) {
-      throw new HttpException(
-        error.message || 'Internal server error',
-        error.status || HttpStatus.INTERNAL_SERVER_ERROR,
-      );
-    }
-  }
 }

src/users/services/user-space.service.ts

@@ -1,4 +1,9 @@
-import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
+import {
+  BadRequestException,
+  HttpException,
+  HttpStatus,
+  Injectable,
+} from '@nestjs/common';
 import { UserSpaceRepository } from '@app/common/modules/user/repositories';
 import { SuccessResponseDto } from '@app/common/dto/success.response.dto';
 import { BaseResponseDto } from '@app/common/dto/base.response.dto';
@@ -11,6 +16,10 @@ import { CommonErrorCodes } from '@app/common/constants/error-codes.enum';
 import { UserDevicePermissionService } from 'src/user-device-permission/services';
 import { PermissionType } from '@app/common/constants/permission-type.enum';
 import { InviteSpaceEntity } from '@app/common/modules/space/entities/invite-space.entity';
+import { UserService } from './user.service';
+import { RoleType } from '@app/common/constants/role.type.enum';
+import { InviteUserRepository } from '@app/common/modules/Invite-user/repositiories';
+import { UserStatusEnum } from '@app/common/constants/user-status.enum';
 
 @Injectable()
 export class UserSpaceService {
@@ -18,6 +27,8 @@ export class UserSpaceService {
     private readonly userSpaceRepository: UserSpaceRepository,
     private readonly spaceRepository: SpaceRepository,
     private readonly inviteSpaceRepository: InviteSpaceRepository,
+    private readonly userService: UserService,
+    private readonly inviteUserRepository: InviteUserRepository,
     private readonly userDevicePermissionService: UserDevicePermissionService,
   ) {}
 
@@ -41,17 +52,24 @@ export class UserSpaceService {
     params: AddUserSpaceUsingCodeDto,
     userUuid: string,
   ) {
+    const { inviteCode } = params;
     try {
-      const inviteSpace = await this.findInviteSpaceByInviteCode(
+      const inviteSpace = await this.findInviteSpaceByInviteCode(inviteCode);
-        params.inviteCode,
+      const user = await this.userService.getUserDetailsByUserUuid(
+        userUuid,
+        true,
       );
-
+      await this.checkSpaceMemberRole(user);
       await this.addUserToSpace(userUuid, inviteSpace.space.uuid);
 
       const deviceUUIDs = await this.getDeviceUUIDsForSpace(inviteSpace.uuid);
 
       await this.addUserPermissionsToDevices(userUuid, deviceUUIDs);
-
+      await this.addUserAsActiveInvitation(
+        user,
+        inviteSpace.space.uuid,
+        inviteCode,
+      );
       await this.clearSpaceInvitationCode(inviteSpace.uuid);
     } catch (err) {
       if (err instanceof HttpException) {
@@ -64,7 +82,20 @@ export class UserSpaceService {
       }
     }
   }
-
+  private async checkSpaceMemberRole(user: any) {
+    try {
+      if (user.role.type !== RoleType.SPACE_MEMBER) {
+        throw new BadRequestException(
+          'You have to be a space member to join this space',
+        );
+      }
+    } catch (err) {
+      throw new HttpException(
+        err.message || 'User not found',
+        err.status || HttpStatus.NOT_FOUND,
+      );
+    }
+  }
   private async findInviteSpaceByInviteCode(
     inviteCode: string,
   ): Promise<InviteSpaceEntity> {
@@ -90,7 +121,47 @@ export class UserSpaceService {
       { isActive: false },
     );
   }
+  async getProjectBySpaceUuid(spaceUuid: string) {
+    try {
+      const project = await this.spaceRepository.findOne({
+        where: {
+          uuid: spaceUuid,
+        },
+        relations: ['community.project'],
+      });
+      return project;
+    } catch (error) {
+      throw new HttpException('Space not found', HttpStatus.NOT_FOUND);
+    }
+  }
+  private async addUserAsActiveInvitation(
+    user: any,
+    spaceUuid: string,
+    inviteCode: string,
+  ) {
+    try {
+      const space = await this.getProjectBySpaceUuid(spaceUuid);
 
+      const inviteUser = this.inviteUserRepository.create({
+        firstName: user.firstName,
+        lastName: user.lastName,
+        email: user.email,
+        jobTitle: null,
+        phoneNumber: null,
+        roleType: { uuid: user.role.uuid },
+        status: UserStatusEnum.ACTIVE,
+        invitationCode: inviteCode,
+        invitedBy: RoleType.SPACE_OWNER,
+        project: { uuid: space.community.project.uuid },
+      });
+      await this.inviteUserRepository.save(inviteUser);
+    } catch (err) {
+      throw new HttpException(
+        err.message || 'Internal Server Error',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+  }
   private async addUserToSpace(userUuid: string, spaceUuid: string) {
     try {
       const user = await this.addUserSpace({ userUuid, spaceUuid });

src/users/services/user.service.ts

@@ -23,13 +23,15 @@ export class UserService {
     private readonly regionRepository: RegionRepository,
     private readonly timeZoneRepository: TimeZoneRepository,
   ) {}
-  async getUserDetailsByUserUuid(userUuid: string) {
+  async getUserDetailsByUserUuid(userUuid: string, withRole = false) {
     try {
       const user = await this.userRepository.findOne({
         where: {
           uuid: userUuid,
         },
-        relations: ['region', 'timezone'],
+        ...(withRole
+          ? { relations: ['roleType'] }
+          : { relations: ['region', 'timezone'] }),
       });
       if (!user) {
         throw new BadRequestException('Invalid room UUID');
@@ -39,13 +41,14 @@ export class UserService {
       const cleanedProfilePicture = removeBase64Prefix(user.profilePicture);
 
       return {
-        uuid: user.uuid,
+        uuid: user?.uuid,
-        email: user.email,
+        email: user?.email,
-        firstName: user.firstName,
+        firstName: user?.firstName,
-        lastName: user.lastName,
+        lastName: user?.lastName,
         profilePicture: cleanedProfilePicture,
-        region: user.region,
+        region: user?.region,
-        timeZone: user.timezone,
+        timeZone: user?.timezone,
+        ...(withRole && { role: user?.roleType }),
       };
     } catch (err) {
       if (err instanceof BadRequestException) {

src/users/user.module.ts

@@ -19,6 +19,7 @@ import {
 import { UserDevicePermissionService } from 'src/user-device-permission/services';
 import { DeviceUserPermissionRepository } from '@app/common/modules/device/repositories';
 import { PermissionTypeRepository } from '@app/common/modules/permission/repositories';
+import { InviteUserRepository } from '@app/common/modules/Invite-user/repositiories';
 
 @Module({
   imports: [ConfigModule, CommunityModule],
@@ -36,6 +37,7 @@ import { PermissionTypeRepository } from '@app/common/modules/permission/reposit
     PermissionTypeRepository,
     UserSpaceService,
     InviteSpaceRepository,
+    InviteUserRepository,
   ],
   exports: [UserService],
 })