rez_core 7.0.0 → 7.0.1

package/src/module/user/service/user.service.ts

@@ -1,349 +0,0 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
-import { UserData } from '../entity/user.entity';
-import { UserRepository } from '../repository/user.repository';
-import { INVITATION_STATUS_SENT } from '../../../constant/global.constant';
-import { CreateUserDto } from '../dto/create-user.dto';
-import { UserRoleMappingService } from './user-role-mapping.service';
-import { UserRoleMapping } from '../entity/user-role-mapping.entity';
-import { ConfigService } from '@nestjs/config';
-import { ActionHandler } from 'src/module/workflow-automation/interface/action.decorator';
-import { EncryptUtilService } from '../../../utils/service/encryptUtil.service';
-import { plainToInstance } from 'class-transformer';
-import { UpdateUserDto } from '../dto/update-user.dto';
-import { EnterpriseRepository } from 'src/module/enterprise/repository/enterprise.repository';
-import { StatusConstant } from '../../../constant/status.constant';
-import { RoleRepository } from '../repository/role.repository';
-import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
-
-@Injectable()
-@ActionHandler('User')
-export class UserService {
-  constructor(
-    private userRepository: UserRepository,
-    private userRoleMappingService: UserRoleMappingService,
-    private roleRepo: RoleRepository,
-    private configService: ConfigService,
-    private readonly enterpriseRepository: EnterpriseRepository,
-    private readonly reflectionHelper: ReflectionHelper
-  ) {
-  }
-
-  masterKey = this.configService.get('MASTER_KEY') || '';
-  masterIv = this.configService.get('MASTER_IV') || '';
-
-  async createUser(
-    entityData: CreateUserDto,
-    loggedInUser: UserData,
-  ) {
-    const userData = entityData;
-
-    let existingUser = await this.userRepository.findByEmailId(
-      userData.email_id,
-      loggedInUser?.enterprise_id,
-    );
-    if (existingUser) {
-      return { success: false, error: 'User with this email already exists' };
-    }
-
-    existingUser = await this.userRepository.findByMobile(
-      userData.mobile,
-      loggedInUser?.enterprise_id,
-    );
-    if (existingUser) {
-      return { success: false, error: 'User with this mobile already exists' };
-    }
-
-    if(!userData.code) {
-      const maxId = await this.userRepository.findMaxIdRecord();
-      if(maxId && maxId.id) {
-        userData.code = `USR${maxId.id + 1}`;
-      } else {
-        userData.code = `USR1`;
-      }
-    }
-
-    userData.password = EncryptUtilService.encryptGCM(
-      userData.password || 'Admin@123',
-      this.masterKey,
-      this.masterIv,
-    );
-
-    userData.enterprise_id = loggedInUser.enterprise_id;
-    userData.level_type = loggedInUser.level_type;
-    userData.level_id = loggedInUser.level_id;
-
-    userData.is_firstlogin = 1;
-    userData.roles = [];
-    userData.invitation_status = INVITATION_STATUS_SENT;
-    userData.status = StatusConstant.ACTIVE;
-
-    const entity = plainToInstance(UserData, userData);
-    entity.created_by = loggedInUser.created_by;
-
-    const savedData = await this.userRepository.saveUser(entity);
-
-    const insertPromises: Promise<UserRoleMapping | void | null | undefined>[] =
-      [];
-
-    for (const entry of userData.access || []) {
-      const { level_type, level_ids, app_code, role_id } = entry;
-      if (
-        !level_type ||
-        !Array.isArray(level_ids) ||
-        !level_ids.length ||
-        !app_code ||
-        !role_id
-      ) {
-        return { success: false, error: 'Invalid access level entry' };
-      }
-      const appMasterRepo = this.reflectionHelper.getRepoService('AppMaster');
-      const appMaster = await appMasterRepo.findOne({
-        where: {
-          code: app_code
-        }
-      })
-      for (const levelId of level_ids) {
-        const userRoleMapping = new UserRoleMapping(savedData.id, role_id);
-        userRoleMapping.level_type = level_type;
-        userRoleMapping.level_id = String(levelId);
-        userRoleMapping.appcode = app_code;
-        userRoleMapping.app_id = appMaster.id
-        userRoleMapping.enterprise_id = loggedInUser?.enterprise_id || 0;
-        insertPromises.push(
-          this.userRoleMappingService.assignUserRole(userRoleMapping),
-        );
-      }
-    }
-
-    try {
-      if (insertPromises.length > 0) {
-        await Promise.all(insertPromises);
-      }
-    } catch (error) {
-      console.error('Error adding access levels:', error);
-      return { success: false, error: 'Failed to add access levels' };
-    }
-
-    return { success: true, data: savedData };
-  }
-
-  name: string = 'UserService';
-
-  async getUserData(
-    id: number,
-  ) {
-    const user = await this.userRepository.findById(id);
-    if (user) {
-      const userRoleMappings: UserRoleMapping[] | null =
-        await this.userRoleMappingService.findByUserId(id);
-      if (userRoleMappings) {
-        const userDto = user as unknown as CreateUserDto;
-        const roles: any[] = [];
-        for (const i in userRoleMappings) {
-          const userRoleMapping = userRoleMappings[i];
-          const roleId = userRoleMapping.role_id;
-          const role = await this.roleRepo.findById(roleId);
-          roles.push(role);
-        }
-        userDto.roles = roles;
-      }
-      return user;
-    }
-    return null;
-  }
-
-  async updateUser(
-    id: number,
-    userDto: UpdateUserDto,
-    loggedInUserData: UserData,
-  ) {
-
-    const existingUser = await this.userRepository.findById(id);
-
-    if (!existingUser) {
-      return { success: false, error: 'User not found' };
-    }
-
-    if (userDto.password) {
-      const decryptedPassword = EncryptUtilService.decryptGCM(
-        existingUser.password,
-        this.masterKey,
-        this.masterIv,
-      );
-
-      if (decryptedPassword === userDto.password) {
-        return {
-          success: false,
-          error: 'New password cannot be the same as the current password',
-        };
-      }
-
-      userDto.password = EncryptUtilService.encryptGCM(
-        userDto.password,
-        this.masterKey,
-        this.masterIv,
-      );
-    }
-
-    const updatedUserData = { ...userDto } as any;
-    delete updatedUserData.access;
-
-    const savedData = await this.userRepository.updateUser(id, updatedUserData);
-
-    // Handle updated access levels
-    if (userDto.access && userDto.access.length > 0) {
-      if (loggedInUserData.level_type == 'ORG') {
-        await this.userRoleMappingService.deleteByUserId(existingUser.id);
-      } else {
-        await this.userRoleMappingService.deleteByUserId(
-          existingUser.id,
-          loggedInUserData.level_type,
-          loggedInUserData.level_id,
-        );
-      }
-
-      const insertPromises: any[] = [];
-
-      for (const entry of userDto.access) {
-        const { level_type, level_ids, app_code, role_id } = entry;
-
-        if (!level_type || !app_code || !role_id || !Array.isArray(level_ids)) {
-          return { success: false, error: 'Invalid access level entry' };
-        }
-
-        for (const levelId of level_ids) {
-          const userRoleMapping = new UserRoleMapping(id, role_id);
-          userRoleMapping.level_type = level_type;
-          userRoleMapping.level_id = String(levelId);
-          userRoleMapping.appcode = app_code;
-          userRoleMapping.enterprise_id = loggedInUserData.enterprise_id;
-
-          insertPromises.push(
-            this.userRoleMappingService.assignUserRole(userRoleMapping),
-          );
-        }
-      }
-
-      try {
-        await Promise.all(insertPromises);
-      } catch (error) {
-        console.error('Error updating access levels:', error);
-        return { success: false, error: 'Failed to update access levels' };
-      }
-    }
-
-    return { success: true, data: savedData };
-  }
-
-  async findByEmailId(
-    email_id: string,
-    enterprise_id?: number,
-    getLastApp?: boolean,
-  ): Promise<UserData | null> {
-    return await this.userRepository.findByEmailId(email_id, enterprise_id, getLastApp);
-  }
-
-  async findByMobile(
-    mobile: string,
-    organization_id?: number,
-    appCode?: string,
-  ): Promise<UserData | null> {
-    return await this.userRepository.findByMobile(
-      mobile,
-      organization_id,
-      appCode,
-    );
-  }
-
-  async setDefaultLastAccess(userId: number, app_id: number): Promise<void> {
-    const user = await this.userRepository.findById(userId);
-
-    if (!user) {
-      throw new BadRequestException('User not found');
-    }
-
-    user.last_app_access_id = app_id;
-
-    await this.userRepository.saveUser(user); // This persists the updated field
-  }
-
-  async setLastLevelTypeAndId(
-    userId: number,
-    levelType: string,
-    levelId: string,
-    app_id: number,
-  ): Promise<void> {
-    const user = await this.userRepository.findById(userId);
-
-    if (!user) {
-      throw new BadRequestException('User not found');
-    }
-
-    user.last_level_type = levelType;
-    user.last_level_id = levelId;
-    user.last_app_access_id = app_id;
-
-    await this.userRepository.saveUser(user); // This persists the updated field
-  }
-
-  async checkEmailExists(data: {
-    email_id: string;
-    subdomain: string;
-  }): Promise<any> {
-    const { email_id, subdomain } = data;
-
-    if (!email_id || !subdomain) {
-      return { success: false, message: 'Email and Subdomain is required' };
-    }
-
-    let enterprise;
-
-    if (subdomain) {
-      enterprise =
-        await this.enterpriseRepository.findEnterpriseBySubdomain(
-          subdomain,
-        );
-
-      if (!enterprise) {
-        // throw new BadRequestException('Organization not found.');
-        return {
-          success: false,
-          message: 'Organization not found.',
-        };
-      }
-    }
-
-    // 🔹 Step 2: Find the user by email + organization check
-    const user = await this.userRepository.findByEmailId(
-      email_id,
-      enterprise?.id,
-    );
-
-    if (!user || (enterprise && user.enterprise_id !== enterprise.id)) {
-      // throw new BadRequestException('User not found in organization.');
-      return {
-        success: false,
-        message: 'User not found in enterprise.',
-      };
-    }
-
-    if (user) {
-      return {
-        success: true,
-        message:
-          'An account already exists for this email address. Login or use a different email address to sign up.',
-        userId: user.id,
-      };
-    } else {
-      // throw new ForbiddenException('No account found with this email address.');
-      return {
-        success: false,
-        message: 'No account found with this email address.',
-      };
-    }
-  }
-
-  async find(options: any): Promise<UserData[]> {
-    return await this.userRepository.find(options);
-  }
-}

package/src/module/user/user.module.ts

@@ -1,64 +0,0 @@
-import { forwardRef, Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { UserData } from './entity/user.entity';
-import { UserService } from './service/user.service';
-import { UtilsModule } from '../../utils/utils.module';
-import { EntityModule } from '../meta/entity.module';
-import { UserRepository } from './repository/user.repository';
-import { UserSessionService } from './service/user-session.service';
-import { UserSession } from './entity/user-session.entity';
-import { LoginController } from './controller/login.controller';
-import { LoginService } from './service/login.service';
-import { UserSessionRepository } from './repository/userSession.repository';
-import { JwtService } from '@nestjs/jwt';
-import { AuthModule } from '../auth/auth.module';
-import { UserController } from './controller/user.controller';
-import { Role } from './entity/role.entity';
-import { RoleService } from './service/role.service';
-import { UserRoleMapping } from './entity/user-role-mapping.entity';
-import { UserRoleMappingRepository } from './repository/user-role-mapping.repository';
-import { UserRoleMappingService } from './service/user-role-mapping.service';
-import { RoleRepository } from './repository/role.repository';
-import { ModuleAccess } from '../module/entity/module-access.entity';
-import { EnterpriseModule } from '../enterprise/enterprise.module';
-import { ListMasterModule } from '../listmaster/listmaster.module';
-import { IntegrationModule } from '../integration/integration.module';
-import { EnterpriseData } from '../enterprise/entity/enterprise.entity';
-
-@Module({
-  imports: [
-    TypeOrmModule.forFeature([
-      UserData,
-      UserSession,
-      Role,
-      UserRoleMapping,
-      ModuleAccess,
-    ]),
-    forwardRef(() => AuthModule),
-    UtilsModule,
-    forwardRef(() => EnterpriseModule)
-  ],
-  providers: [
-    { provide: 'UserService', useClass: UserService },
-    { provide: 'RoleService', useClass: RoleService },
-    UserRepository,
-    UserSessionService,
-    LoginService,
-    UserSessionRepository,
-    JwtService,
-    UserRoleMappingRepository,
-    UserRoleMappingService,
-    RoleRepository,
-  ],
-  exports: [
-    'UserService',
-    UserSessionService,
-    'RoleService',
-    UserRoleMappingService,
-    RoleRepository,
-    LoginService,
-    UserRoleMappingRepository
-  ],
-  controllers: [LoginController, UserController],
-})
-export class UserModule { }