rez_core 6.5.46 → 6.5.50

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

@@ -1,43 +1,65 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
+import { RoleService } from './role.service';
+import {
+  BadRequestException,
+  ForbiddenException,
+  Inject,
+  Injectable,
+} from '@nestjs/common';
+import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
 import { UserData } from '../entity/user.entity';
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
 import { UserRepository } from '../repository/user.repository';
-import { INVITATION_STATUS_SENT } from '../../../constant/global.constant';
+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 { 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';
 
 @Injectable()
 @ActionHandler('User')
-export class UserService {
+export class UserService extends EntityServiceImpl implements Action {
   constructor(
     private userRepository: UserRepository,
     private userRoleMappingService: UserRoleMappingService,
-    private roleRepo: RoleRepository,
+    private readonly clockIDGenService: ClockIDGenService,
     private configService: ConfigService,
-    private readonly enterpriseRepository: EnterpriseRepository,
+    private readonly organizationRepository: OrganizationRepository,
+    // private readonly userAppMappingService: UserAppMappingService,
+    @Inject('RoleService') private readonly roleService: RoleService,
+    @Inject('ListMasterService')
+    private readonly listMasterService: ListMasterService,
   ) {
+    super();
   }
 
   masterKey = this.configService.get('MASTER_KEY') || '';
   masterIv = this.configService.get('MASTER_IV') || '';
 
-  async createUser(
-    entityData: CreateUserDto,
-    loggedInUser: UserData,
-  ) {
-    const userData = entityData;
+  async createEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData | null,
+    manager?: EntityManager,
+  ): Promise<ServiceResult<BaseEntity>> {
+    const userData = entityData as CreateUserDto;
 
     let existingUser = await this.userRepository.findByEmailId(
       userData.email_id,
-      loggedInUser?.enterprise_id,
+      loggedInUser?.organization_id,
     );
     if (existingUser) {
       return { success: false, error: 'User with this email already exists' };
@@ -45,40 +67,36 @@ export class UserService {
 
     existingUser = await this.userRepository.findByMobile(
       userData.mobile,
-      loggedInUser?.enterprise_id,
+      loggedInUser?.organization_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`;
-      }
-    }
+    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,
+      );
+
+    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 = INVITATION_STATUS_SENT;
-    userData.status = StatusConstant.ACTIVE;
-
-    const entity = plainToInstance(UserData, userData);
-    entity.created_by = loggedInUser.created_by;
+    userData.invitation_status = resolvedInvitationStatus.id;
+    userData.status = resolveStatus.id || 'ACTIVE';
 
-    const savedData = await this.userRepository.saveUser(entity);
+    const savedData = await super.createEntity(userData, loggedInUser);
 
     const insertPromises: Promise<UserRoleMapping | void | null | undefined>[] =
       [];
@@ -101,7 +119,7 @@ export class UserService {
         userRoleMapping.level_type = level_type;
         userRoleMapping.level_id = String(levelId);
         userRoleMapping.appcode = app_code;
-        userRoleMapping.enterprise_id = loggedInUser?.enterprise_id || 0;
+        userRoleMapping.organization_id = loggedInUser?.organization_id || 0;
         insertPromises.push(
           this.userRoleMappingService.assignUserRole(userRoleMapping),
         );
@@ -121,10 +139,15 @@ export class UserService {
   }
 
   name: string = 'UserService';
+  async execute(payload: any): Promise<any> {
+    console.log('payload', payload);
+  }
 
-  async getUserData(
+  async getEntityData(
+    entityType: string,
     id: number,
-  ) {
+    loggedInUser?: UserData,
+  ): Promise<BaseEntity | null> {
     const user = await this.userRepository.findById(id);
     if (user) {
       const userRoleMappings: UserRoleMapping[] | null =
@@ -135,7 +158,11 @@ export class UserService {
         for (const i in userRoleMappings) {
           const userRoleMapping = userRoleMappings[i];
           const roleId = userRoleMapping.role_id;
-          const role = await this.roleRepo.findById(roleId);
+          const role = await super.getEntityData(
+            ENTITYTYPE_ROLE,
+            roleId,
+            loggedInUser,
+          );
           roles.push(role);
         }
         userDto.roles = roles;
@@ -145,13 +172,13 @@ export class UserService {
     return null;
   }
 
-  async updateUser(
-    id: number,
-    userDto: UpdateUserDto,
+  async updateEntity(
+    entityData: BaseEntity,
     loggedInUserData: UserData,
-  ) {
+  ): Promise<ServiceResult<BaseEntity>> {
+    const userDto = entityData as UpdateUserDto;
 
-    const existingUser = await this.userRepository.findById(id);
+    const existingUser = await this.userRepository.findById(entityData.id);
 
     if (!existingUser) {
       return { success: false, error: 'User not found' };
@@ -181,7 +208,10 @@ export class UserService {
     const updatedUserData = { ...userDto } as any;
     delete updatedUserData.access;
 
-    const savedData = await this.userRepository.updateUser(id, updatedUserData);
+    const savedData = await super.updateEntity(
+      updatedUserData,
+      loggedInUserData,
+    );
 
     // Handle updated access levels
     if (userDto.access && userDto.access.length > 0) {
@@ -205,11 +235,12 @@ export class UserService {
         }
 
         for (const levelId of level_ids) {
-          const userRoleMapping = new UserRoleMapping(id, role_id);
+          const userRoleMapping = new UserRoleMapping(savedData.id, role_id);
           userRoleMapping.level_type = level_type;
           userRoleMapping.level_id = String(levelId);
           userRoleMapping.appcode = app_code;
-          userRoleMapping.enterprise_id = loggedInUserData.enterprise_id;
+          userRoleMapping.organization_id =
+            loggedInUserData?.organization_id || 0;
 
           insertPromises.push(
             this.userRoleMappingService.assignUserRole(userRoleMapping),
@@ -230,10 +261,9 @@ export class UserService {
 
   async findByEmailId(
     email_id: string,
-    enterprise_id?: number,
-    getLastApp?: boolean,
+    organization_id?: number,
   ): Promise<UserData | null> {
-    return await this.userRepository.findByEmailId(email_id, enterprise_id, getLastApp);
+    return await this.userRepository.findByEmailId(email_id, organization_id);
   }
 
   async findByMobile(
@@ -248,14 +278,14 @@ export class UserService {
     );
   }
 
-  async setDefaultLastAccess(userId: number, app_id: number): Promise<void> {
+  async setDefaultLastAccess(userId: number, appcode: string): Promise<void> {
     const user = await this.userRepository.findById(userId);
 
     if (!user) {
       throw new BadRequestException('User not found');
     }
 
-    user.last_app_access_id = app_id;
+    user.last_app_access = appcode;
 
     await this.userRepository.saveUser(user); // This persists the updated field
   }
@@ -264,7 +294,7 @@ export class UserService {
     userId: number,
     levelType: string,
     levelId: string,
-    app_id: number,
+    appcode: string,
   ): Promise<void> {
     const user = await this.userRepository.findById(userId);
 
@@ -274,7 +304,7 @@ export class UserService {
 
     user.last_level_type = levelType;
     user.last_level_id = levelId;
-    user.last_app_access_id = app_id;
+    user.last_app_access = appcode;
 
     await this.userRepository.saveUser(user); // This persists the updated field
   }
@@ -289,15 +319,15 @@ export class UserService {
       return { success: false, message: 'Email and Subdomain is required' };
     }
 
-    let enterprise;
+    let organization;
 
     if (subdomain) {
-      enterprise =
-        await this.enterpriseRepository.findEnterpriseBySubdomain(
+      organization =
+        await this.organizationRepository.findOrganizationBySubdomain(
           subdomain,
         );
 
-      if (!enterprise) {
+      if (!organization) {
         // throw new BadRequestException('Organization not found.');
         return {
           success: false,
@@ -309,14 +339,14 @@ export class UserService {
     // 🔹 Step 2: Find the user by email + organization check
     const user = await this.userRepository.findByEmailId(
       email_id,
-      enterprise?.id,
+      organization?.id,
     );
 
-    if (!user || (enterprise && user.enterprise_id !== enterprise.id)) {
+    if (!user || (organization && user.organization_id !== organization.id)) {
       // throw new BadRequestException('User not found in organization.');
       return {
         success: false,
-        message: 'User not found in enterprise.',
+        message: 'User not found in organization.',
       };
     }
 
@@ -335,8 +365,4 @@ export class UserService {
       };
     }
   }
-
-  async find(options: any): Promise<UserData[]> {
-    return await this.userRepository.find(options);
-  }
 }

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

@@ -23,7 +23,6 @@ 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: [
@@ -35,8 +34,11 @@ import { EnterpriseData } from '../enterprise/entity/enterprise.entity';
       ModuleAccess,
     ]),
     forwardRef(() => AuthModule),
+    EntityModule,
     UtilsModule,
-    forwardRef(() => EnterpriseModule)
+    ListMasterModule,
+    IntegrationModule,
+    forwardRef(() => EnterpriseModule),
   ],
   providers: [
     { provide: 'UserService', useClass: UserService },
@@ -57,8 +59,7 @@ import { EnterpriseData } from '../enterprise/entity/enterprise.entity';
     UserRoleMappingService,
     RoleRepository,
     LoginService,
-    UserRoleMappingRepository
   ],
   controllers: [LoginController, UserController],
 })
-export class UserModule { }
+export class UserModule {}

package/src/module/workflow/repository/action-data.repository.ts

@@ -51,6 +51,7 @@ export class ActionDataRepository extends EntityServiceImpl {
           action_id: act.id,
           sequence: act.sequence,
           name: act.name,
+          organization_id: loggedInUser.organization_id,
           enterprise_id: loggedInUser.enterprise_id,
           mapped_entity_id,
           mapped_entity_type,
@@ -115,6 +116,7 @@ export class ActionDataRepository extends EntityServiceImpl {
               this.reflectionHelper.getRepoService('EntityRelationData');
 
             await entityRelationDataRepo.save({
+              organization_id: loggedInUser.organization_id,
               enterprise_id: loggedInUser.enterprise_id,
               source_entity_id: createdEntity.mapped_entity_id,
               source_entity_type: createdEntity.mapped_entity_type,
@@ -187,7 +189,7 @@ export class ActionDataRepository extends EntityServiceImpl {
   }
 
   async resubmitAction(
-    loggedInUser: UserData,
+    organization_id: number,
     mapped_entity_type: string,
     mapped_entity_id: number,
     stage_id: number,
@@ -196,7 +198,7 @@ export class ActionDataRepository extends EntityServiceImpl {
     // Get the current active action
     const currentAction = await this.actionDataRepo.findOne({
       where: {
-        enterprise_id: loggedInUser.enterprise_id,
+        organization_id,
         stage_id,
         mapped_entity_id,
         mapped_entity_type,
@@ -213,7 +215,7 @@ export class ActionDataRepository extends EntityServiceImpl {
     // Find the immediate previous action in the sequence
     const previousAction = await this.actionDataRepo.findOne({
       where: {
-        enterprise_id: loggedInUser.enterprise_id,
+        organization_id,
         stage_id,
         mapped_entity_id,
         mapped_entity_type,
@@ -230,7 +232,7 @@ export class ActionDataRepository extends EntityServiceImpl {
     // Unset current action
     currentAction.is_current = null as any;
     currentAction.modified_date = new Date();
-    currentAction.modified_by = loggedInUser.id;
+    currentAction.modified_by = organization_id;
     currentAction.start_time = null as any;
     currentAction.resubmit_count = (currentAction.resubmit_count ?? 0) + 1;
 
@@ -239,7 +241,7 @@ export class ActionDataRepository extends EntityServiceImpl {
     // Mark previous action as current again
     previousAction.is_current = 'Y';
     previousAction.modified_date = new Date();
-    previousAction.modified_by = loggedInUser.id;
+    previousAction.modified_by = organization_id;
     previousAction.end_time = null as any; // Reset end time
     previousAction.is_done = false;
     await this.actionDataRepo.update(previousAction.id, previousAction);
@@ -266,7 +268,7 @@ export class ActionDataRepository extends EntityServiceImpl {
         const listMasterItem = await listMasterItemRepo.findOne({
           where: {
             code: 'in_progress',
-            enterprise_id: loggedInUser.enterprise_id,
+            organization_id: organization_id,
             listtype: 'TKST',
           },
         });

package/src/module/workflow/repository/action.repository.ts

@@ -8,12 +8,12 @@ export class ActionRepository {
   constructor(private readonly reflectionHelper: ReflectionHelper) {}
 
   async getReasonCode(loggedInUser: UserData): Promise<any> {
-    const { enterprise_id } = loggedInUser;
+    const { organization_id } = loggedInUser;
     const listMasterRepo =
       this.reflectionHelper.getRepoService('ListMasterData');
     const result = await listMasterRepo.find({
       where: {
-        enterprise_id,
+        organization_id,
         source: 'master',
       },
     });
@@ -27,7 +27,7 @@ export class ActionRepository {
   }
 
   async defaultReasonCode(list_type: string, loggedInUser: UserData) {
-    const { enterprise_id } = loggedInUser;
+    const { organization_id } = loggedInUser;
     if (!list_type) {
       throw new BadRequestException('list_type is required');
     }
@@ -38,7 +38,7 @@ export class ActionRepository {
     const result = await listMasterItemsRepo.find({
       where: {
         listtype: list_type,
-        enterprise_id,
+        organization_id,
       },
     });
 
@@ -50,7 +50,7 @@ export class ActionRepository {
   }
 
   async getActions(loggedInUser: UserData, stage_id: number) {
-    const { enterprise_id } = loggedInUser;
+    const { organization_id } = loggedInUser;
 
     const workflowStageActionRepo =
       this.reflectionHelper.getRepoService('StageActionMapping');
@@ -88,7 +88,7 @@ export class ActionRepository {
       const templates = await workflowCommTemplateRepo.find({
         where: {
           code: In(templateCodes),
-          enterprise_id: enterprise_id,
+          organization_id: organization_id,
         },
       });
 
@@ -148,10 +148,10 @@ export class ActionRepository {
         'ar',
         `ar.id::text = a.action_requirement 
       AND ar.listtype = 'ACRQ' 
-      AND ar.enterprise_id = :entId`,
-        { entId: enterprise_id },
+      AND ar.organization_id = :orgId`,
+        { orgId: organization_id },
       )
-      .where('a.enterprise_id = :entId', { entId: enterprise_id })
+      .where('a.organization_id = :orgId', { orgId: organization_id })
       .andWhere('a.id::text IN (:...actionIds)', { actionIds })
       .getRawMany();
 
@@ -218,7 +218,7 @@ export class ActionRepository {
   }
 
   async getAction(
-    enterprise_id: number,
+    organization_id: number,
     stage_id: number,
     mapped_entity_id: number,
     mapped_entity_type: string,
@@ -268,7 +268,7 @@ export class ActionRepository {
         'ac',
         'ac.id = a.action_category::bigint',
       )
-      .where('a.enterprise_id = :entId', { entId: enterprise_id })
+      .where('a.organization_id = :orgId', { orgId: organization_id })
       .andWhere('a.id IN (:...actionIds)', { actionIds })
       .orderBy('a.sequence', 'ASC')
       .getRawMany();

package/src/module/workflow/repository/form-master.repository.ts

@@ -8,12 +8,12 @@ export class FormMasterRepository {
     private readonly reflectionHelper: ReflectionHelper,
   ) {}
 
-  async getForms(enterprise_id: number, source_entity_type: string) {
+  async getForms(organization_id: number, source_entity_type: string) {
 
     const viewMasterRepo = this.reflectionHelper.getRepoService('ViewMaster');
     const forms = await viewMasterRepo.find({
       where: {
-        enterprise_id,
+        organization_id,
         mapped_entity_type: source_entity_type
       }
     });

package/src/module/workflow/service/action-data.service.ts

@@ -3,7 +3,6 @@ import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.s
 import { UserData } from 'src/module/user/entity/user.entity';
 import { DataSource } from 'typeorm';
 import { ActionDataRepository } from '../repository/action-data.repository';
-import { log } from 'console';
 
 @Injectable()
 export class ActionDataService extends EntityServiceImpl {
@@ -51,9 +50,9 @@ export class ActionDataService extends EntityServiceImpl {
     stage_id: number,
     action_id: number,
   ) {
-  
+    const { organization_id } = loggedInUser;
     return this.actionDataRepo.resubmitAction(
-      loggedInUser,
+      organization_id,
       mapped_entity_type,
       mapped_entity_id,
       stage_id,

package/src/module/workflow/service/action.service.ts

@@ -291,9 +291,9 @@ export class ActionService extends EntityServiceImpl {
     mapped_entity_id: number,
     mapped_entity_type: string,
   ) {
-    const { enterprise_id } = loggedInUser;
+    const { organization_id } = loggedInUser;
     return this.actionRepository.getAction(
-      enterprise_id,
+      organization_id,
       stage_id,
       mapped_entity_id,
       mapped_entity_type,

package/src/module/workflow/service/comm-template.service.ts

@@ -75,7 +75,9 @@ export class CommTemplateService extends EntityServiceImpl {
         entity_type: templateData.entity_type,
         template_id: tempData.id,
         media_id: attachment,
+        organization_id: loggedInUser.organization_id,
         enterprise_id: loggedInUser.enterprise_id,
+        appcode: loggedInUser.appcode,
         level_id: loggedInUser.level_id,
         level_type: loggedInUser.level_type,
       }));

package/src/module/workflow/service/entity-modification.service.ts

@@ -17,6 +17,7 @@ export class EntityModificationService extends EntityServiceImpl {
   async logModification(modificationData: any, loggedInUser: UserData) {
     const { mapped_entity_type, mapped_entity_id, attribute_key } =
       modificationData;
+    const { organization_id } = loggedInUser;
 
     if (!mapped_entity_type || !mapped_entity_id || !attribute_key) {
       throw new BadRequestException(

package/src/module/workflow/service/form-master.service.ts

@@ -10,9 +10,9 @@ export class FormMasterService extends EntityServiceImpl {
   }
 
   async getForms(loggedInUser: UserData, source_entity_type: string) {
-    const { enterprise_id } = loggedInUser;
+    const { organization_id } = loggedInUser;
     return this.formMasterRepository.getForms(
-      enterprise_id,
+      organization_id,
       source_entity_type,
     );
   }

package/src/module/workflow/service/populate-workflow.service.ts

@@ -2,7 +2,7 @@ import { create } from 'domain';
 import { CommTemplate } from './../entity/comm-template.entity';
 import { ActionCategory } from './../entity/action-category.entity';
 import { DataSource } from 'typeorm';
-import { PopulateMetaService } from '../../enterprise/service/populate-meta.service';
+import { PopulateMetaService } from './../../meta/service/populate-meta.service';
 import { Inject, Injectable } from '@nestjs/common';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { WorkflowService } from './workflow.service';

package/src/module/workflow/service/task.service.ts

@@ -208,6 +208,7 @@ export class TaskService extends EntityServiceImpl {
           description: `${updatedEntity.code} was marked as completed`,
           category: ACTIVITY_CATEGORIES.TASK,
           action: 'completed',
+          appcode: loggedInUser.appcode,
         };
 
         await this.activityLogService.logActivity(
@@ -222,6 +223,7 @@ export class TaskService extends EntityServiceImpl {
           description: `${updatedEntity.code} was edited`,
           category: ACTIVITY_CATEGORIES.TASK,
           action: 'edit',
+          appcode: loggedInUser.appcode,
         };
 
         await this.activityLogService.logActivity(editLogData, loggedInUser);
@@ -497,6 +499,7 @@ export class TaskService extends EntityServiceImpl {
         description: `${task.name} was deleted`,
         category: ACTIVITY_CATEGORIES.TASK,
         action: 'delete',
+        appcode: loggedInUser.appcode,
       };
 
       await this.activityLogService.logActivity(logData, loggedInUser);

package/src/module/workflow/service/workflow-meta.service.ts

@@ -190,6 +190,7 @@ export class WorkflowMetaService extends EntityServiceImpl {
         status: firstStage.status,
         current_user_id: loggedInUser.id,
         stage_action_mapping_id: firstStage.id,
+        organization_id: loggedInUser.organization_id,
         enterprise_id: loggedInUser.enterprise_id,
         stage_group_id: stageGroup.id,
         stage_id: firstStage.id,
@@ -249,6 +250,7 @@ export class WorkflowMetaService extends EntityServiceImpl {
               description: `Stage Group changed from ${currentStage.stage_group_name} to ${nextStage.stage_group_name}.`,
               action: 'completed',
               category: ACTIVITY_CATEGORIES.STAGEGROUP,
+              appcode: loggedInUser.appcode,
             },
             loggedInUser,
           );
@@ -274,6 +276,7 @@ export class WorkflowMetaService extends EntityServiceImpl {
         status: nextStage.status,
         current_user_id: loggedInUser.id,
         stage_action_mapping_id: nextStage.id,
+        organization_id: loggedInUser.organization_id,
         enterprise_id: loggedInUser.enterprise_id,
         start_date: now,
         stage_group_id: nextStage?.stage_group_id,
@@ -298,6 +301,7 @@ export class WorkflowMetaService extends EntityServiceImpl {
             description: `Stage changed from ${currentStage.name} to ${nextStage.name}.`,
             action: 'status',
             category: ACTIVITY_CATEGORIES.STAGE,
+            appcode: loggedInUser.appcode,
           },
           loggedInUser,
         );
@@ -543,7 +547,7 @@ export class WorkflowMetaService extends EntityServiceImpl {
     stage_id: number,
     actions: any[],
   ): Promise<number> {
-    const { enterprise_id, level_id, level_type } = loggedInUser;
+    const { organization_id, level_id, level_type } = loggedInUser;
 
     let owners = [] as any;
 
@@ -579,7 +583,8 @@ export class WorkflowMetaService extends EntityServiceImpl {
     const lastRow = await leadRepo
       .createQueryBuilder("cl")
       .select("cl.lead_owner", "lead_owner")
-      .where("cl.level_id = :levelId", { levelId: Number(level_id) })
+      .where("cl.organization_id = :orgId", { orgId: organization_id })
+      .andWhere("cl.level_id = :levelId", { levelId: Number(level_id) })
       .andWhere("cl.level_type = :levelType", { levelType: level_type })
       .andWhere("cl.lead_owner IN (:...owners)", { owners: userIds })
       .orderBy("cl.created_date", "DESC")