rez_core 5.0.89 → 5.0.91

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

@@ -1,6 +1,6 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { DataSource, Repository } from 'typeorm';
+import { Repository } from 'typeorm';
 import { CommTemplate } from '../entity/comm-template.entity';
 import { TemplateAttach } from '../entity/template-attach-mapper.entity';
 import { MediaDataService } from 'src/module/meta/service/media-data.service';
@@ -14,9 +14,9 @@ export class CommTemplateRepository {
     @InjectRepository(TemplateAttach)
     private readonly templateAttachEntity: Repository<TemplateAttach>,
     private readonly mediaDataService: MediaDataService,
-    private readonly dataSource: DataSource,
     private readonly reflectionHelper: ReflectionHelper,
-  ) {}
+  ) {
+  }
 
   async getAllCommTemplate(
     entity_type: string,
@@ -35,21 +35,27 @@ export class CommTemplateRepository {
         where: {
           id: action_id,
           organization_id: organization_id,
-        }
-      })
+        },
+      });
 
       if (!actionResult) {
         throw new Error('Invalid action_id');
       }
 
       is_template = actionResult.is_template;
-      await this.dataSource.query(
-        `UPDATE frm_wf_comm_template
-     SET is_template = $1
-     WHERE mapped_entity_type = $2
-       AND organization_id = $3 AND level_id = $4 AND level_type=$5`,
-        [is_template, entity_type, organization_id, level_id, level_type],
-      );
+      await this.commTemplateRepository.find({
+        where: {},
+      });
+
+      await this.commTemplateRepository
+        .createQueryBuilder()
+        .update()
+        .set({ is_template: Boolean(is_template) })
+        .where('mapped_entity_type = :entityType', { entity_type })
+        .andWhere('organization_id = :orgId', { orgId: organization_id })
+        .andWhere('level_id = :levelId', { levelId: level_id })
+        .andWhere('level_type = :levelType', { levelType: level_type })
+        .execute();
     }
 
     const whereCondition: any = {
@@ -145,7 +151,7 @@ export class CommTemplateRepository {
   async findByCodeAndLevelIdAndLevelTypeAndAppCode(code: string, level_id: string,
                                                    level_type: string, appcode: string) {
     return await this.commTemplateRepository.findOne({
-      where: {code, level_id, level_type, appcode}
+      where: { code, level_id, level_type, appcode },
     });
   }
 }

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

@@ -1,36 +1,27 @@
-import {
-  BadRequestException,
-  Inject,
-  Injectable,
-  NotFoundException,
-} from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { DataSource, Repository } from 'typeorm';
-import { FormDataEntity } from '../entity/form.entity';
+import { Injectable } from '@nestjs/common';
 import { UserData } from 'src/module/user/entity/user.entity';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 
 @Injectable()
 export class FormMasterRepository {
   constructor(
-    private readonly dataSource: DataSource,
-    // @InjectRepository(FormDataEntity)
-    // private readonly formRepo: Repository<FormDataEntity>,
+    private readonly reflectionHelper: ReflectionHelper,
   ) {}
 
   async getForms(organization_id: number, source_entity_type: string) {
-    const forms = await this.dataSource.query(
-      `SELECT fm.id as fm_id, fm.name as fm_form_name
-       FROM frm_entity_view fm
-       WHERE fm.organization_id = $1 AND fm.mapped_entity_type = $2`,
-      [organization_id, source_entity_type],
-    );
-
-    const formatted = forms.map((form: any) => ({
-      label: form.fm_form_name,
-      value: form.fm_id,
-    }));
 
-    return formatted;
+    const viewMasterRepo = this.reflectionHelper.getRepoService('ViewMaster');
+    const forms = await viewMasterRepo.find({
+      where: {
+        organization_id,
+        mapped_entity_type: source_entity_type
+      }
+    });
+
+    return forms.map((form: any) => ({
+      label: form.name,
+      value: form.id,
+    }));
   }
 
   // to_be_sent

package/src/module/workflow/repository/stage-group.repository.ts

@@ -1,15 +1,10 @@
-import {
-  BadRequestException,
-  Inject,
-  Injectable,
-  NotFoundException,
-} from '@nestjs/common';
+import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
 import { StageGroup } from '../entity/stage-group.entity';
 import { InjectRepository } from '@nestjs/typeorm';
-import { DataSource, In, Repository } from 'typeorm';
-import { MediaDataService } from 'src/module/meta/service/media-data.service';
+import { In, Repository } from 'typeorm';
 import { Stage } from '../entity/stage.entity';
 import { TaskDataEntity } from '../entity/task-data.entity';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 
 @Injectable()
 export class StageGroupRepository {
@@ -20,9 +15,9 @@ export class StageGroupRepository {
     private readonly stageRepository: Repository<Stage>,
     @InjectRepository(TaskDataEntity)
     private readonly taskDataRepo: Repository<TaskDataEntity>,
-    private readonly dataSource: DataSource,
-    private readonly mediaDataService: MediaDataService,
-  ) {}
+    private readonly reflectionHelper: ReflectionHelper,
+  ) {
+  }
 
   async getAllStageGroup(workflow_id: number, organization_id: number) {
     if (!workflow_id) {
@@ -93,12 +88,12 @@ export class StageGroupRepository {
     const stagesRaw: any[] = await this.stageRepository.find({
       where: {
         stage_group_id: In(stageGroupIds),
-        organization_id: loggedInUser.organization_id
+        organization_id: loggedInUser.organization_id,
       },
       order: {
         sequence: 'ASC',
-      }
-    })
+      },
+    });
 
     const stageIds = stagesRaw.map((s) => Number(s.id));
 
@@ -109,52 +104,46 @@ export class StageGroupRepository {
     // -------------------------------------------------------------
     // STEP 3: Task Counts (Postgres-safe)
     // -------------------------------------------------------------
-    const stagePlaceholders = stageIds
-      .map((_, idx) => `$${idx + 1}`)
-      .join(", ");
-
-    const params_task = [...stageIds];
-
-    const taskCounts = await this.dataSource.query(
-      `
-      SELECT stage_id, COUNT(*) AS task_count
-      FROM frm_wf_task_data
-      WHERE stage_id IN (${stagePlaceholders})
-        AND is_system = FALSE
-        AND mapped_entity_id = ${lead_id}
-      GROUP BY stage_id
-    `,
-      params_task,
-    );
+
+    const taskCounts = await this.taskDataRepo
+      .createQueryBuilder('t')
+      .select('t.stage_id', 'stage_id')
+      .addSelect('COUNT(*)', 'task_count')
+      .where('t.stage_id IN (:...stageIds)', { stageIds })
+      .andWhere('t.is_system = false')
+      .andWhere('t.mapped_entity_id = :leadId', { leadId: lead_id })
+      .groupBy('t.stage_id')
+      .getRawMany();
 
     // -------------------------------------------------------------
     // STEP 4: Meeting Counts
     // -------------------------------------------------------------
-    const meetingCounts = await this.dataSource.query(
-      `
-      SELECT stage_id, COUNT(*) AS meeting_count
-      FROM crm_lead_meeting
-      WHERE stage_id IN (${stagePlaceholders})
-        AND mapped_entity_id = ${lead_id}
-      GROUP BY stage_id
-    `,
-      params_task,
-    );
+
+    const leadMeetingRepo = this.reflectionHelper.getRepoService('LeadScheduleMeet');
+
+    const meetingCounts = await leadMeetingRepo
+      .createQueryBuilder('m')
+      .select('m.stage_id', 'stage_id')
+      .addSelect('COUNT(*)', 'meeting_count')
+      .where('m.stage_id IN (:...stageIds)', { stageIds })
+      .andWhere('m.mapped_entity_id = :leadId', { leadId: lead_id })
+      .groupBy('m.stage_id')
+      .getRawMany();
 
     // -------------------------------------------------------------
     // STEP 5: Send Communication Counts
     // -------------------------------------------------------------
-    const sendCommCounts = await this.dataSource.query(
-      `
-      SELECT stage_id, COUNT(*) AS send_comm_count
-      FROM crm_lead_communication
-      WHERE stage_id IN (${stagePlaceholders})
-        AND mapped_entity_id = ${lead_id}
-        AND type IN ('SEND','LOG')
-      GROUP BY stage_id
-    `,
-      params_task,
-    );
+    const leadCommunicationRepo = this.reflectionHelper.getRepoService('LeadCommunication');
+
+    const sendCommCounts = await leadCommunicationRepo
+      .createQueryBuilder('c')
+      .select('c.stage_id', 'stage_id')
+      .addSelect('COUNT(*)', 'send_comm_count')
+      .where('c.stage_id IN (:...stageIds)', { stageIds })
+      .andWhere('c.mapped_entity_id = :leadId', { leadId: lead_id })
+      .andWhere('c.type IN (:...types)', { types: ['SEND', 'LOG'] })
+      .groupBy('c.stage_id')
+      .getRawMany();
 
     // Convert to maps
     const taskCountMap = new Map(

package/src/module/workflow/repository/stage-movement.repository.ts

@@ -1,13 +1,13 @@
-import { get } from 'http';
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository, DataSource, MoreThan } from 'typeorm';
+import { MoreThan, Repository } from 'typeorm';
 import { WorkflowLevelMappingEntity } from '../entity/workflow-level-mapping.entity';
 import { StageGroup } from '../entity/stage-group.entity';
 import { Stage } from '../entity/stage.entity';
-import { log } from 'console';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
+import { ActionDataEntity } from '../entity/action-data.entity';
+import { TaskDataEntity } from '../entity/task-data.entity';
 
 @Injectable()
 export class StageMovementRepository {
@@ -18,8 +18,11 @@ export class StageMovementRepository {
     private readonly stageGroupRepo: Repository<StageGroup>,
     @InjectRepository(Stage)
     private readonly stageRepo: Repository<Stage>,
-    private readonly dataSource: DataSource,
     private readonly reflectionHelper: ReflectionHelper,
+    @InjectRepository(ActionDataEntity)
+    private readonly actionDataEntityRepository: Repository<ActionDataEntity>,
+    @InjectRepository(TaskDataEntity)
+    private readonly taskDataEntityRepository: Repository<TaskDataEntity>,
   ) {}
 
   async getFirstStage({
@@ -183,40 +186,40 @@ export class StageMovementRepository {
   }
 
   async getAllActionByStageId(stageId: number): Promise<any> {
-
     const actionRepo = this.reflectionHelper.getRepoService('ActionEntity');
     const result = await actionRepo
-      .createQueryBuilder("a")
+      .createQueryBuilder('a')
       .leftJoin(
-        "frm_wf_stage_action_mapping",
-        "m",
-        "a.id = m.action_id::bigint"
+        'frm_wf_stage_action_mapping',
+        'm',
+        'a.id = m.action_id::bigint',
       )
       .leftJoin(
-        "frm_wf_action_category",
-        "ac",
-        "a.action_category::bigint = ac.id"
+        'frm_wf_action_category',
+        'ac',
+        'a.action_category::bigint = ac.id',
       )
-      .where("m.stage_id::bigint = :stageId", { stageId: Number(stageId) })
+      .where('m.stage_id::bigint = :stageId', { stageId: Number(stageId) })
       .select([
-        "a.*",                     // select all columns from action table
-        "m.id AS mapping_id",
-        "m.stage_id",
-        "ac.code AS action_category_code",
+        'a.*', // select all columns from action table
+        'm.id AS mapping_id',
+        'm.stage_id AS stage_id',
+        'ac.code AS action_category_code',
       ])
-      .orderBy("a.sequence", "ASC")
+      .orderBy('a.sequence', 'ASC')
       .getRawMany();
 
     // Use for..of with await instead of map
-    const actionResourceMappingRepo = this.reflectionHelper.getRepoService('ActionResourcesMapping');
+    const actionResourceMappingRepo = this.reflectionHelper.getRepoService(
+      'ActionResourcesMapping',
+    );
     for (const item of result) {
       if (item.action_category_code === 'SDFM') {
         const actionData = await actionResourceMappingRepo.findOne({
           where: {
-            stg_act_mapping_id: item.mapping_id
-          }
-        })
-
+            stg_act_mapping_id: item.mapping_id,
+          },
+        });
 
         item.form_id = actionData?.form_id || null;
       }
@@ -230,23 +233,23 @@ export class StageMovementRepository {
 
     if (action.length > 0) {
       for (const act of action) {
-        await this.dataSource.query(
-          `INSERT INTO frm_wf_action_data (stage_id, user_id, action_id) VALUES ($1, $2, $3)`,
-          [act.stage_id, loggedInUser.id, act.id],
-        );
+        await this.actionDataEntityRepository.save({
+          stage_id: act.stage_id,
+          user_id: loggedInUser.id,
+          action_id: act.id,
+        });
       }
     }
   }
 
   async saveTaskData(actionData: any, loggedInUser: UserData): Promise<any> {
     // Implement the logic to save task data
-
     if (actionData.length > 0) {
       for (const action of actionData) {
-        await this.dataSource.query(
-          `INSERT INTO frm_wf_task_data (action_id, user_id) VALUES ($1, $2)`,
-          [action.id, loggedInUser.id],
-        );
+        await this.taskDataEntityRepository.save({
+          action_id: action.id,
+          user_id: String(loggedInUser.id),
+        });
       }
     }
   }

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

@@ -1,16 +1,25 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
 import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { UserData } from 'src/module/user/entity/user.entity';
-import { DataSource, EntityManager, Repository } from 'typeorm';
+import { EntityManager, Repository } from 'typeorm';
 import { ActionRepository } from '../repository/action.repository';
 import { ActionEntity } from '../entity/action.entity';
+import { ActionResourcesMapping } from '../entity/action-resources-mapping.entity';
+import { InjectRepository } from '@nestjs/typeorm';
+import { StageActionMapping } from '../entity/stage-action-mapping.entity';
+import { ActionTemplateMapping } from '../entity/action-template-mapping.entity';
 
 @Injectable()
 export class ActionService extends EntityServiceImpl {
   constructor(
-    private readonly dataSource: DataSource,
     private readonly actionRepository: ActionRepository,
+    @InjectRepository(ActionResourcesMapping)
+    private readonly actionResourcesMappingRepository: Repository<ActionResourcesMapping>,
+    @InjectRepository(StageActionMapping)
+    private readonly stageActionMappingRepository: Repository<StageActionMapping>,
+    @InjectRepository(ActionTemplateMapping)
+    private readonly actionTemplateMappingRepository: Repository<ActionTemplateMapping>,
   ) {
     super();
   }
@@ -26,16 +35,25 @@ export class ActionService extends EntityServiceImpl {
       return null;
     }
 
-    const result = await this.dataSource.query(
-      `SELECT template_code, form_id 
-   FROM frm_wf_action_resources_mapping 
-   WHERE stg_act_mapping_id IN (
-     SELECT id 
-     FROM frm_wf_stage_action_mapping 
-     WHERE action_id = $1 AND entity_type = 'WFSA'
-   )`,
-      [actionData.id],
-    );
+    let actionResourceMappingRepo = this.reflectionHelper.getRepoService('ActionResourcesMapping');
+    await actionResourceMappingRepo.find({
+      where: {},
+    });
+
+    const result = await actionResourceMappingRepo
+      .createQueryBuilder('arm')
+      .select([
+        'arm.template_code AS template_code',
+        'arm.form_id AS form_id',
+      ])
+      .where(`arm.stg_act_mapping_id IN (
+      SELECT sam.id 
+      FROM frm_wf_stage_action_mapping sam
+      WHERE sam.action_id = :actionId
+        AND sam.entity_type = 'WFSA'
+      )`)
+      .setParameter('actionId', actionData.id)
+      .getRawMany();
 
     const templates = result
       .filter((t) => t.template_code !== null)
@@ -59,10 +77,10 @@ export class ActionService extends EntityServiceImpl {
     const actionData = entityData as any;
 
     // 🔧 Remove 'template' array before inserting main action
-  const { template, ...actionWithoutTemplates } = actionData;
+    const { template, ...actionWithoutTemplates } = actionData;
 
-  // Step 1: Create main action entity
-  const action = await super.createEntity(actionWithoutTemplates, loggedInUser);
+    // Step 1: Create main action entity
+    const action = await super.createEntity(actionWithoutTemplates, loggedInUser);
 
     // Step 2: Create stage mapping
     const stageActionMapping = {
@@ -100,10 +118,10 @@ export class ActionService extends EntityServiceImpl {
       }
     }
 
-    await this.dataSource.query(
-      `DELETE FROM frm_wf_action_resources_mapping WHERE stg_act_mapping_id = $1 AND type = 'form'`,
-      [stageActionMappingData.id],
-    );
+    await this.actionResourcesMappingRepository.delete({
+      stg_act_mapping_id: stageActionMappingData.id,
+      type: 'form',
+    });
 
     if (actionData.form) {
       const resourceMapping = {
@@ -140,17 +158,19 @@ export class ActionService extends EntityServiceImpl {
       throw new Error('Action not found or could not be updated');
     }
 
-    const stageMapID = await this.dataSource.query(
-      `SELECT id FROM frm_wf_stage_action_mapping WHERE action_id = $1 AND entity_type = 'WFSA'`,
-      [action.id],
-    );
+    const stageMap = await this.stageActionMappingRepository.findOne({
+      where: {
+        action_id: action.id,
+        entity_type: 'WFSA',
+      },
+    });
 
     let stageActionMappingData;
 
-    if (stageMapID.length > 0) {
+    if (stageMap) {
       // Update existing mapping
       const stageActionMapping = {
-        id: stageMapID[0].id,
+        id: stageMap.id,
         action_id: action.id,
         stage_id,
         entity_type: 'WFSA',
@@ -176,10 +196,10 @@ export class ActionService extends EntityServiceImpl {
     }
 
     // delete existing template mappings for this action
-    await this.dataSource.query(
-      `DELETE FROM frm_wf_action_resources_mapping WHERE stg_act_mapping_id = $1 AND type = 'template'`,
-      [stageActionMappingData.id],
-    );
+    await this.actionResourcesMappingRepository.delete({
+      stg_act_mapping_id: stageActionMappingData.id,
+      type: 'template',
+    });
 
     // Handle template mapping (using the extracted template)
     if (Array.isArray(template) && template.length > 0) {
@@ -199,10 +219,10 @@ export class ActionService extends EntityServiceImpl {
       }
     }
 
-    await this.dataSource.query(
-      `DELETE FROM frm_wf_action_resources_mapping WHERE stg_act_mapping_id = $1 AND type = 'form'`,
-      [stageActionMappingData.id],
-    );
+    await this.actionResourcesMappingRepository.delete({
+      stg_act_mapping_id: stageActionMappingData.id,
+      type: 'form',
+    });
 
     if (form) {
       const resourceMapping = {
@@ -222,16 +242,23 @@ export class ActionService extends EntityServiceImpl {
     id: number,
     loggedInUser: UserData,
   ): Promise<any> {
-    await this.dataSource.query(
-      `DELETE FROM frm_wf_action_template_mapping WHERE stg_act_mapping_id IN (SELECT
-        id FROM frm_wf_stage_action_mapping WHERE action_id = $1 AND entity_type = 'WFSA')`,
-      [id],
-    );
 
-    await this.dataSource.query(
-      `DELETE FROM frm_wf_stage_action_mapping WHERE action_id = $1 AND entity_type ='WFSA'`,
-      [id],
-    );
+    await this.actionTemplateMappingRepository
+      .createQueryBuilder()
+      .delete()
+      .where(`stg_act_mapping_id IN (
+          SELECT sam.id 
+          FROM frm_wf_stage_action_mapping sam
+          WHERE sam.action_id = :actionId
+          AND sam.entity_type = 'WFSA'
+      )`)
+      .setParameter('actionId', id)
+      .execute();
+
+    await this.stageActionMappingRepository.delete({
+      action_id: id,
+      entity_type: 'WFSA',
+    });
 
     const deleteAction = await super.deleteEntity(entityType, id, loggedInUser);
 

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

@@ -5,12 +5,12 @@ import {
 } from '@nestjs/common';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { UserData } from 'src/module/user/entity/user.entity';
-import { DataSource } from 'typeorm';
+import { DataSource, EntityManager } from 'typeorm';
 import { EntityMasterService } from '../../meta/service/entity-master.service';
 
 @Injectable()
 export class EntityModificationService extends EntityServiceImpl {
-  constructor(private readonly dataSource: DataSource
+  constructor(private readonly entityManager: EntityManager
               ) {
     super();
   }
@@ -36,7 +36,7 @@ export class EntityModificationService extends EntityServiceImpl {
     const tableName = entityMeta.db_table_name;
 
     // Step 2: Get the row from the target table using mapped_entity_id
-    const [entityRow] = await this.dataSource.query(
+    const [entityRow] = await this.entityManager.query(
       `
     SELECT * FROM ${tableName} WHERE id = $1
     `,

package/src/module/workflow/service/stage-group.service.ts

@@ -1,21 +1,17 @@
-import { app } from 'firebase-admin';
 import { BadGatewayException, Inject, Injectable } from '@nestjs/common';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { StageGroupRepository } from '../repository/stage-group.repository';
 import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { StageService } from './stage.service';
-import { DataSource, Repository } from 'typeorm';
-import { WorkflowLevelMappingEntity } from '../entity/workflow-level-mapping.entity';
+import { Repository } from 'typeorm';
 import { InjectRepository } from '@nestjs/typeorm';
 import { StageMovementData } from '../entity/stage-movement-data.entity';
 import * as moment from 'moment';
-import { MediaDataService } from 'src/module/meta/service/media-data.service';
 import axios from 'axios';
 import { ConfigService } from '@nestjs/config';
 import { ListMasterData } from 'src/module/listmaster/entity/list-master.entity';
 import { StageGroup } from '../entity/stage-group.entity';
-import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
 
 @Injectable()
 export class StageGroupService extends EntityServiceImpl {
@@ -23,12 +19,8 @@ export class StageGroupService extends EntityServiceImpl {
     private readonly stageGroupRepository: StageGroupRepository,
     @Inject('StageService')
     private readonly stageService: StageService,
-    private readonly dataSource: DataSource,
-    @InjectRepository(WorkflowLevelMappingEntity)
-    private readonly workflowLevelMappingRepo: Repository<WorkflowLevelMappingEntity>,
     @InjectRepository(StageMovementData)
     private readonly stageMovementRepo: Repository<StageMovementData>,
-    private readonly mediaDataService: MediaDataService,
     private readonly configService: ConfigService,
     @InjectRepository(ListMasterData)
     private readonly listMasterRepo: Repository<ListMasterData>,
@@ -37,17 +29,21 @@ export class StageGroupService extends EntityServiceImpl {
   ) {
     super();
   }
+
   async getAllStageGroup(workflow_id: number, organization_id: number) {
     const allStageGroup = await this.stageGroupRepository.getAllStageGroup(
       workflow_id,
       organization_id,
     );
-    const statusListMaster = await this.dataSource.query(
-      `SELECT id, name 
-     FROM frm_list_master_items 
-     WHERE listtype = 'STS' AND organization_id = $1`,
-      [organization_id],
-    );
+
+    const listMasterItemsRepo = this.reflectionHelper.getRepoService('ListMasterItems');
+
+    const statusListMaster = await listMasterItemsRepo.find({
+      where: {
+        listtype: 'STS',
+        organization_id,
+      },
+    });
 
     // Build a lookup map: id → name
     const statusMap = new Map(
@@ -320,10 +316,16 @@ export class StageGroupService extends EntityServiceImpl {
     id: number,
     loggedInUser: UserData,
   ): Promise<any> {
-    const getAllStage = await this.dataSource.query(
-      `SELECT id FROM frm_wf_stage WHERE stage_group_id = $1 AND level_id = $2 AND level_type = $3`,
-      [id, loggedInUser.level_id, loggedInUser.level_type],
-    );
+
+    const stageRepo = this.reflectionHelper.getRepoService('Stage');
+
+    const getAllStage = await stageRepo.find({
+      where: {
+        stage_group_id: id,
+        level_id: loggedInUser.level_id,
+        level_type: loggedInUser.level_type,
+      },
+    });
 
     if (getAllStage.length > 0) {
       for (const stage of getAllStage) {