rez_core 6.5.50 → 6.5.51

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

@@ -1,69 +1,68 @@
-import { BadRequestException, Inject, Injectable } from '@nestjs/common';
-import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
-import { BaseEntity } from '../../meta/entity/base-entity.entity';
+import { Injectable } from '@nestjs/common';
 import { UserData } from '../entity/user.entity';
 import { Role } from '../entity/role.entity';
-import { ENTITYTYPE_ROLE, STATUS_INACTIVE } from 'src/constant/global.constant';
+import { STATUS_INACTIVE } from 'src/constant/global.constant';
 import { RoleRepository } from '../repository/role.repository';
-import { EntityManager, Repository } from 'typeorm';
+import { Repository } from 'typeorm';
 import { InjectRepository } from '@nestjs/typeorm';
 import { ModuleAccess } from '../../module/entity/module-access.entity';
-import { ServiceResult } from 'src/dtos/response';
-import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
-import { UserRoleMappingRepository } from '../repository/user-role-mapping.repository';
 import { UserRoleMapping } from '../entity/user-role-mapping.entity';
+import { plainToInstance } from 'class-transformer';
+import { StatusConstant } from '../../../constant/status.constant';
 
 @Injectable()
-export class RoleService extends EntityServiceImpl {
+export class RoleService {
   constructor(
     private readonly roleRepository: RoleRepository,
-    private readonly entityManager: EntityManager,
     @InjectRepository(ModuleAccess)
     private readonly moduleAccessRepo: Repository<ModuleAccess>,
-    @Inject('ListMasterService')
-    private readonly listMasterService: ListMasterService,
     @InjectRepository(UserRoleMapping)
     private readonly userRoleMappingRepo: Repository<UserRoleMapping>,
   ) {
-    super();
   }
 
-  async createEntity(
-    entityData: BaseEntity,
-    loggedInUser: UserData,
-  ): Promise<ServiceResult<BaseEntity>> {
-    const role = entityData as Role;
+  async createRole(
+    role: Role,
+    loggedInUser: any,
+  ) {
 
     // if level_type and level_id are not provided, use loggedInUser's values
-    role.level_type = entityData.level_type || loggedInUser.level_type;
-    role.level_id = entityData.level_id || loggedInUser.level_id;
-    role.appcode = entityData.appcode || loggedInUser.appcode;
+    role.level_type = role.level_type || loggedInUser.level_type;
+    role.level_id = role.level_id || loggedInUser.level_id;
+    role.created_by = loggedInUser.id;
+    role.enterprise_id = loggedInUser.enterprise_id;
+    role.app_id = role.app_id || loggedInUser.app_id;
 
     if (
       await this.roleRepository.isRoleNameWithLevelExists(role.name, {
-        organization_id: loggedInUser?.organization_id || undefined,
-        level_type: entityData.level_type || loggedInUser?.level_type,
+        enterprise_id: loggedInUser.enterprise_id,
+        level_type: role.level_type || loggedInUser?.level_type,
         level_id:
-          parseInt(entityData.level_id) ||
+          parseInt(role.level_id) ||
           parseInt(loggedInUser?.level_id || '', 10),
       })
     ) {
       return { success: false, error: 'Role name already exists.' };
     }
 
+    if(!role.code) {
+      const maxId = await this.roleRepository.findMaxIdRecord();
+      if(maxId && maxId.id) {
+        role.code = `ROL${maxId.id + 1}`;
+      } else {
+        role.code = `ROL1`;
+      }
+    }
+
     const sourceRole = role.copy_from_role_id
-      ? await this.getEntityData(
-          ENTITYTYPE_ROLE,
-          role.copy_from_role_id,
-          loggedInUser,
-        )
+      ? await this.roleRepository.findById(role.copy_from_role_id)
       : null;
 
     if (role.copy_from_role_id && !sourceRole) {
       return { success: false, error: 'Source role not found.' };
     }
-
-    const savedRole = await super.createEntity(role, loggedInUser);
+    role.status = StatusConstant.ACTIVE;
+    const savedRole = await this.roleRepository.saveRole(role);
     if (sourceRole) {
       const sourcePermissions = await this.moduleAccessRepo.find({
         where: { role_code: sourceRole.code },
@@ -72,11 +71,11 @@ export class RoleService extends EntityServiceImpl {
       const clonedPermissions = sourcePermissions.map((perm) =>
         this.moduleAccessRepo.create({
           role_code: savedRole.code,
-          module_code: perm.module_code,
           action_type: perm.action_type,
           access_flag: perm.access_flag,
           level_type: perm.level_type,
           appcode: perm.appcode,
+          module_id: perm.module_id
         }),
       );
 
@@ -85,40 +84,31 @@ export class RoleService extends EntityServiceImpl {
     return { success: true, data: savedRole };
   }
 
-  async updateEntity(
-    entityData: BaseEntity,
+  async updateRole(
+    id: number,
+    role: Role,
     loggedInUser: UserData,
-  ): Promise<ServiceResult<BaseEntity>> {
-    if (!entityData.name) {
+  ) {
+    if (!role.name) {
       return { success: false, error: 'Role name is required' };
     }
-    const role = entityData as Role;
 
-    const resolveStatus = await this.listMasterService.getResolvedListCode(
-      STATUS_INACTIVE,
-      loggedInUser?.organization_id || 0,
-    );
-
-    if (entityData.status == resolveStatus.id) {
+    if (role.status == STATUS_INACTIVE) {
       //get role by id
-      const existingRole = await this.getEntityData(
-        ENTITYTYPE_ROLE,
-        entityData.id,
-        loggedInUser,
-      );
+      const existingRole = await this.roleRepository.findById(id);
 
       if (!existingRole) {
         return { success: false, error: 'Role not found' };
       }
 
       const associatedUsers = await this.userRoleMappingRepo
-        .createQueryBuilder("map")
-        .innerJoin("sso_user", "usr", "map.user_id = usr.id")
-        .where("usr.status::text = :status", { status: String(resolveStatus.id) })
-        .andWhere("map.role_id::text = :roleId", {
+        .createQueryBuilder('map')
+        .innerJoin('sso_user', 'usr', 'map.user_id = usr.id')
+        .where('usr.status::text = :status', { status: StatusConstant.INACTIVE })
+        .andWhere('map.role_id::text = :roleId', {
           roleId: String(existingRole?.id),
         })
-        .select("map") // same as SELECT map.*
+        .select('map') // same as SELECT map.*
         .getRawMany();
 
       if (associatedUsers.length > 0) {
@@ -137,9 +127,9 @@ export class RoleService extends EntityServiceImpl {
     }
 
     if (
-      await this.roleRepository.isRoleNameExists(entityData.name, {
-        excludeRoleId: entityData.id,
-        organization_id: loggedInUser?.organization_id,
+      await this.roleRepository.isRoleNameExists(role.name, {
+        excludeRoleId: role.id,
+        enterprise_id: loggedInUser?.enterprise_id,
       })
     ) {
       return {
@@ -149,14 +139,13 @@ export class RoleService extends EntityServiceImpl {
     }
 
     const { copy_from_role_id, ...persistableData } = role;
-    const updatedRole = await super.updateEntity(persistableData, loggedInUser);
+
+    const entity = plainToInstance(Role, persistableData);
+    const updatedRole = await this.roleRepository.updateRole(id, entity);
 
     if (role.copy_from_role_id) {
-      const sourceRole = await this.getEntityData(
-        ENTITYTYPE_ROLE,
-        role.copy_from_role_id,
-        loggedInUser,
-      );
+
+      const sourceRole = await this.roleRepository.findById(role.copy_from_role_id);
 
       if (!sourceRole) {
         return {
@@ -174,7 +163,7 @@ export class RoleService extends EntityServiceImpl {
       const clonedPermissions = sourcePermissions.map((perm) =>
         this.moduleAccessRepo.create({
           role_code: role.code,
-          module_code: perm.module_code,
+          module_id: perm.module_id,
           action_type: perm.action_type,
           access_flag: perm.access_flag,
           appcode: perm.appcode,
@@ -194,4 +183,16 @@ export class RoleService extends EntityServiceImpl {
   }): Promise<Role[] | null> {
     return await this.roleRepository.find(data);
   }
+
+  async findByCode(code: string) {
+    return await this.roleRepository.findByCode(code);
+  }
+
+  async findById(id: number) {
+    return await this.roleRepository.findById(id);
+  }
+
+  async find(options: any): Promise<Role[]> {
+    return await this.roleRepository.findRoles(options);
+  }
 }

package/src/module/user/service/user-role-mapping.service.ts

@@ -7,7 +7,7 @@ import { UserRoleMapping } from '../entity/user-role-mapping.entity';
 export class UserRoleMappingService {
   constructor(
     private readonly userRoleMappingRepository: UserRoleMappingRepository,
-  ) {}
+  ) { }
 
   async assignUserRole(userRoleMapping: UserRoleMapping) {
     const existing = await this.userRoleMappingRepository.findByUserIdAndRoleId(
@@ -95,4 +95,26 @@ export class UserRoleMappingService {
       levelId,
     );
   }
+
+  async find(options: any): Promise<UserRoleMapping[]> {
+    return await this.userRoleMappingRepository.find(options);
+  }
+
+  async create(data: any, loggedInUser: any) {
+    // Assuming data maps to UserRoleMapping or needs transformation
+    // Based on usage in controller: this.roleMappingService.createEntity(data.userRoleMappingData, data.loggedInUserData)
+
+    // If data is already a UserRoleMapping object or similar
+    // We might need to adjust this based on actual DTO structure, but for now passing it through or saving
+
+    // If it's a direct save:
+    // return await this.userRoleMappingRepository.save(data);
+
+    // However, assignUserRole seems to be the main method for creating/assigning. 
+    // Let's use assignUserRole if data matches, or save if it's a raw entity.
+    // The controller passes `data.userRoleMappingData`.
+
+    // Let's assume it's a UserRoleMapping compatible object.
+    return await this.assignUserRole(data);
+  }
 }

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

@@ -4,8 +4,7 @@ import { BadRequestException, Injectable } from '@nestjs/common';
 import { UserSessionRepository } from '../repository/userSession.repository';
 import { JwtAuthService } from 'src/module/auth/services/jwt.service';
 import { ConfigService } from '@nestjs/config';
-import { UserRoleMappingService } from './user-role-mapping.service';
-import { DataSource, Repository } from 'typeorm';
+import { Repository } from 'typeorm';
 import { UserRoleMapping } from '../entity/user-role-mapping.entity';
 import { UserData } from '../entity/user.entity';
 import { InjectRepository } from '@nestjs/typeorm';
@@ -20,18 +19,18 @@ export class UserSessionService {
     private configService: ConfigService,
     @InjectRepository(UserData)
     private readonly userDataRepository: Repository<UserData>,
-    @InjectRepository(UserRoleMapping)
-    private readonly userRoleMappingRepository: Repository<UserRoleMapping>,
     private readonly reflectionHelper: ReflectionHelper,
-  ) {}
-  async createSession(user, appcode?: string, accessInfo?: any) {
+  ) {
+  }
+
+  async createSession(user, app_id?: number, accessInfo?: any, appcode?: string) {
     const sessionToken = this.clockIDGenService.idGenerator('SES');
 
     const userSession: any = new UserSession();
     userSession.user_id = user.id;
     userSession.session_key = sessionToken;
     userSession.is_session_loggedout = 0;
-    userSession.login_time = new Date();
+    // userSession.login_time = new Date(); -- Changed login_time to be auto generated by typeorm
 
     const expiryTokenInHours = this.configService.get('TOKEN_EXPIRY') || 1;
     userSession.expiry_date = new Date(
@@ -43,10 +42,11 @@ export class UserSessionService {
     const payload: any = {
       id: user.id,
       sessionToken,
-      appcode,
+      app_id,
       email_id: user.email_id,
       organization_id: user.organization_id,
       enterprise_id: user.enterprise_id,
+      appcode,
     };
 
     // ✅ Add role access details
@@ -57,7 +57,6 @@ export class UserSessionService {
 
     const accessToken = this.jwtAuthService.generateJwt(payload);
 
-    userSession.access_token = accessToken;
     await this.userSessionRepository.saveSession(userSession);
 
     return accessToken;
@@ -71,6 +70,10 @@ export class UserSessionService {
     await this.userSessionRepository.saveSession(userSession);
   }
 
+  async fetchUserFcmToken(user_id: number) {
+    return await this.userSessionRepository.fetchUserFcmToken(user_id);
+  };
+
 
   async switchCurrentLevelService(
     currentUser: any,
@@ -103,12 +106,12 @@ export class UserSessionService {
       });
     }
 
-    if (getUserDetails?.organization_id == 1 && payload.level_type == 'ORG') {
+    if (getUserDetails?.enterprise_id == 1 && payload.level_type == 'ORG') {
       payload.organization_id = payload.level_id;
     }
 
     await this.userDataRepository.update(currentUser.id, {
-      last_app_access: data.appcode,
+      last_app_access_id: data.app_id,
       last_level_type: data.level_type,
       last_level_id: data.level_id,
     });

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

@@ -1,65 +1,45 @@
-import { RoleService } from './role.service';
-import {
-  BadRequestException,
-  ForbiddenException,
-  Inject,
-  Injectable,
-} from '@nestjs/common';
-import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
+import { BadRequestException, Injectable } from '@nestjs/common';
 import { UserData } from '../entity/user.entity';
-import { BaseEntity } from '../../meta/entity/base-entity.entity';
 import { UserRepository } from '../repository/user.repository';
-import { EncryptUtilService } from '../../../utils/service/encryptUtil.service';
-import { ClockIDGenService } from '../../../utils/service/clockIDGenUtil.service';
-import {
-  ENTITYTYPE_ROLE,
-  STATUS_ACTIVE,
-  INVITATION_STATUS_SENT,
-} from '../../../constant/global.constant';
+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 { EntityManager, Repository } from 'typeorm';
-import { UpdateUserDto } from '../dto/update-user.dto';
 import { ConfigService } from '@nestjs/config';
-// import { UserAppMappingService } from 'src/module/meta/service/user-app-mapping.service';
-import { ServiceResult } from 'src/dtos/response.dto';
-import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
-import { OrganizationRepository } from 'src/module/enterprise/repository/organization.repository';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Action } from 'src/module/workflow-automation/interface/action.interface';
 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 extends EntityServiceImpl implements Action {
+export class UserService {
   constructor(
     private userRepository: UserRepository,
     private userRoleMappingService: UserRoleMappingService,
-    private readonly clockIDGenService: ClockIDGenService,
+    private roleRepo: RoleRepository,
     private configService: ConfigService,
-    private readonly organizationRepository: OrganizationRepository,
-    // private readonly userAppMappingService: UserAppMappingService,
-    @Inject('RoleService') private readonly roleService: RoleService,
-    @Inject('ListMasterService')
-    private readonly listMasterService: ListMasterService,
+    private readonly enterpriseRepository: EnterpriseRepository,
+    private readonly reflectionHelper: ReflectionHelper
   ) {
-    super();
   }
 
   masterKey = this.configService.get('MASTER_KEY') || '';
   masterIv = this.configService.get('MASTER_IV') || '';
 
-  async createEntity(
-    entityData: BaseEntity,
-    loggedInUser: UserData | null,
-    manager?: EntityManager,
-  ): Promise<ServiceResult<BaseEntity>> {
-    const userData = entityData as CreateUserDto;
+  async createUser(
+    entityData: CreateUserDto,
+    loggedInUser: UserData,
+  ) {
+    const userData = entityData;
 
     let existingUser = await this.userRepository.findByEmailId(
       userData.email_id,
-      loggedInUser?.organization_id,
+      loggedInUser?.enterprise_id,
     );
     if (existingUser) {
       return { success: false, error: 'User with this email already exists' };
@@ -67,43 +47,46 @@ export class UserService extends EntityServiceImpl implements Action {
 
     existingUser = await this.userRepository.findByMobile(
       userData.mobile,
-      loggedInUser?.organization_id,
+      loggedInUser?.enterprise_id,
     );
     if (existingUser) {
       return { success: false, error: 'User with this mobile already exists' };
     }
 
-    const resolveStatus = await this.listMasterService.getResolvedListCode(
-      STATUS_ACTIVE,
-      loggedInUser?.organization_id || 0,
-    );
-
-    const resolvedInvitationStatus =
-      await this.listMasterService.getResolvedListCode(
-        INVITATION_STATUS_SENT,
-        loggedInUser?.organization_id || 0,
-      );
+    if(!userData.code) {
+      const maxId = await this.userRepository.findMaxIdRecord();
+      if(maxId && maxId.id) {
+        userData.code = `USR${maxId.id + 1}`;
+      } else {
+        userData.code = `USR1`;
+      }
+    }
 
-    userData.name =
-      (userData.first_name || '') + ' ' + (userData.last_name || '');
     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 = resolvedInvitationStatus.id;
-    userData.status = resolveStatus.id || 'ACTIVE';
+    userData.invitation_status = INVITATION_STATUS_SENT;
+    userData.status = StatusConstant.ACTIVE;
 
-    const savedData = await super.createEntity(userData, loggedInUser);
+    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) ||
@@ -113,13 +96,19 @@ export class UserService extends EntityServiceImpl implements Action {
       ) {
         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.organization_id = loggedInUser?.organization_id || 0;
+        userRoleMapping.app_id = appMaster.id
+        userRoleMapping.enterprise_id = loggedInUser?.enterprise_id || 0;
         insertPromises.push(
           this.userRoleMappingService.assignUserRole(userRoleMapping),
         );
@@ -139,15 +128,10 @@ export class UserService extends EntityServiceImpl implements Action {
   }
 
   name: string = 'UserService';
-  async execute(payload: any): Promise<any> {
-    console.log('payload', payload);
-  }
 
-  async getEntityData(
-    entityType: string,
+  async getUserData(
     id: number,
-    loggedInUser?: UserData,
-  ): Promise<BaseEntity | null> {
+  ) {
     const user = await this.userRepository.findById(id);
     if (user) {
       const userRoleMappings: UserRoleMapping[] | null =
@@ -158,11 +142,7 @@ export class UserService extends EntityServiceImpl implements Action {
         for (const i in userRoleMappings) {
           const userRoleMapping = userRoleMappings[i];
           const roleId = userRoleMapping.role_id;
-          const role = await super.getEntityData(
-            ENTITYTYPE_ROLE,
-            roleId,
-            loggedInUser,
-          );
+          const role = await this.roleRepo.findById(roleId);
           roles.push(role);
         }
         userDto.roles = roles;
@@ -172,13 +152,13 @@ export class UserService extends EntityServiceImpl implements Action {
     return null;
   }
 
-  async updateEntity(
-    entityData: BaseEntity,
+  async updateUser(
+    id: number,
+    userDto: UpdateUserDto,
     loggedInUserData: UserData,
-  ): Promise<ServiceResult<BaseEntity>> {
-    const userDto = entityData as UpdateUserDto;
+  ) {
 
-    const existingUser = await this.userRepository.findById(entityData.id);
+    const existingUser = await this.userRepository.findById(id);
 
     if (!existingUser) {
       return { success: false, error: 'User not found' };
@@ -208,10 +188,7 @@ export class UserService extends EntityServiceImpl implements Action {
     const updatedUserData = { ...userDto } as any;
     delete updatedUserData.access;
 
-    const savedData = await super.updateEntity(
-      updatedUserData,
-      loggedInUserData,
-    );
+    const savedData = await this.userRepository.updateUser(id, updatedUserData);
 
     // Handle updated access levels
     if (userDto.access && userDto.access.length > 0) {
@@ -235,12 +212,11 @@ export class UserService extends EntityServiceImpl implements Action {
         }
 
         for (const levelId of level_ids) {
-          const userRoleMapping = new UserRoleMapping(savedData.id, role_id);
+          const userRoleMapping = new UserRoleMapping(id, role_id);
           userRoleMapping.level_type = level_type;
           userRoleMapping.level_id = String(levelId);
           userRoleMapping.appcode = app_code;
-          userRoleMapping.organization_id =
-            loggedInUserData?.organization_id || 0;
+          userRoleMapping.enterprise_id = loggedInUserData.enterprise_id;
 
           insertPromises.push(
             this.userRoleMappingService.assignUserRole(userRoleMapping),
@@ -261,9 +237,10 @@ export class UserService extends EntityServiceImpl implements Action {
 
   async findByEmailId(
     email_id: string,
-    organization_id?: number,
+    enterprise_id?: number,
+    getLastApp?: boolean,
   ): Promise<UserData | null> {
-    return await this.userRepository.findByEmailId(email_id, organization_id);
+    return await this.userRepository.findByEmailId(email_id, enterprise_id, getLastApp);
   }
 
   async findByMobile(
@@ -278,14 +255,14 @@ export class UserService extends EntityServiceImpl implements Action {
     );
   }
 
-  async setDefaultLastAccess(userId: number, appcode: string): Promise<void> {
+  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 = appcode;
+    user.last_app_access_id = app_id;
 
     await this.userRepository.saveUser(user); // This persists the updated field
   }
@@ -294,7 +271,7 @@ export class UserService extends EntityServiceImpl implements Action {
     userId: number,
     levelType: string,
     levelId: string,
-    appcode: string,
+    app_id: number,
   ): Promise<void> {
     const user = await this.userRepository.findById(userId);
 
@@ -304,7 +281,7 @@ export class UserService extends EntityServiceImpl implements Action {
 
     user.last_level_type = levelType;
     user.last_level_id = levelId;
-    user.last_app_access = appcode;
+    user.last_app_access_id = app_id;
 
     await this.userRepository.saveUser(user); // This persists the updated field
   }
@@ -319,15 +296,15 @@ export class UserService extends EntityServiceImpl implements Action {
       return { success: false, message: 'Email and Subdomain is required' };
     }
 
-    let organization;
+    let enterprise;
 
     if (subdomain) {
-      organization =
-        await this.organizationRepository.findOrganizationBySubdomain(
+      enterprise =
+        await this.enterpriseRepository.findEnterpriseBySubdomain(
           subdomain,
         );
 
-      if (!organization) {
+      if (!enterprise) {
         // throw new BadRequestException('Organization not found.');
         return {
           success: false,
@@ -339,14 +316,14 @@ export class UserService extends EntityServiceImpl implements Action {
     // 🔹 Step 2: Find the user by email + organization check
     const user = await this.userRepository.findByEmailId(
       email_id,
-      organization?.id,
+      enterprise?.id,
     );
 
-    if (!user || (organization && user.organization_id !== organization.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 organization.',
+        message: 'User not found in enterprise.',
       };
     }
 
@@ -365,4 +342,8 @@ export class UserService extends EntityServiceImpl implements Action {
       };
     }
   }
+
+  async find(options: any): Promise<UserData[]> {
+    return await this.userRepository.find(options);
+  }
 }