rez_core 5.0.89 → 5.0.91

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

@@ -24,7 +24,6 @@ export class StageService extends EntityServiceImpl {
     private readonly stageGroupRepository: StageGroupRepository,
     @InjectRepository(StageMovementData)
     private readonly stageMovementRepo: Repository<StageMovementData>,
-    private readonly dataSource: DataSource,
     @Inject('ActionService')
     private readonly actionService: ActionService,
   ) {
@@ -39,24 +38,33 @@ export class StageService extends EntityServiceImpl {
     organization_id: number,
     show_previous: boolean,
   ) {
+    const listRepo = this.reflectionHelper.getRepoService('ListMasterItems');
+    const stageMovementRepo =
+      this.reflectionHelper.getRepoService('StageMovementData');
+
     if (!show_previous) {
       const allStages = await this.stageRepository.getAllStage(
         payload.stage_group_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],
-      );
-
-      // Build a lookup map: id → name
+      const statusListMaster = await listRepo.find({
+        where: {
+          listtype: 'STS',
+          organization_id: organization_id,
+        },
+        select: {
+          id: true,
+          name: true,
+        },
+      });
+
+      // id → name map
       const statusMap = new Map(
         statusListMaster.map((s) => [String(s.id), s.name]),
       );
 
+      // Replace status IDs with names
       for (const stage of allStages) {
         stage.status = statusMap.get(String(stage.status)) as any;
       }
@@ -64,22 +72,15 @@ export class StageService extends EntityServiceImpl {
       return allStages;
     }
 
-    // 1. Get all stages up to the current stage group
+    // 1. Get all stage groups & stages
     const allStageWithStageGroup =
       await this.stageRepository.getAllStageGroupAndStageByStageMovement(
         payload.stage_group_id,
         organization_id,
       );
 
-    // 2. Get stage movement history for this entity
-    const allStageMovementData = await this.dataSource.manager.find<{
-      id: number;
-      stage_group_id: number;
-      stage_id: number;
-      mapped_entity_id: number;
-      mapped_entity_type: string;
-      is_current: string;
-    }>('frm_wf_stage_movement_data', {
+    // 2. Replace raw manager.find with proper repository
+    const allStageMovementData = await stageMovementRepo.find({
       where: {
         mapped_entity_id: payload.mapped_entity_id,
         mapped_entity_type: 'LEAD',
@@ -91,7 +92,7 @@ export class StageService extends EntityServiceImpl {
       return allStageWithStageGroup;
     }
 
-    // 3. Find the current stage movement (is_current === 'Y')
+    // 3. Find the current stage movement
     const currentMovement = allStageMovementData.find(
       (m) => m.is_current === 'Y',
     );
@@ -100,13 +101,11 @@ export class StageService extends EntityServiceImpl {
       return allStageWithStageGroup;
     }
 
-    // 4. Filter stages up to and including the current stage_id
+    // 4. Filter stages up to current stage_id
     const filteredStages: any[] = [];
     for (const stage of allStageWithStageGroup) {
       filteredStages.push(stage);
-      if (stage.id === currentMovement.stage_id) {
-        break; // stop once we reach the current stage
-      }
+      if (stage.id === currentMovement.stage_id) break;
     }
 
     return filteredStages;
@@ -132,11 +131,19 @@ export class StageService extends EntityServiceImpl {
     id: number,
     loggedInUser: UserData,
   ): Promise<any> {
-    const getAllStageAction = await this.dataSource.query(
-      `SELECT action_id FROM frm_wf_stage_action_mapping WHERE stage_id = $1 AND entity_type = 'WFSA'`,
-      [id],
-    );
+    const stageActionRepo =
+      this.reflectionHelper.getRepoService('StageActionMapping');
+
+    // 1. Fetch all actions mapped to this stage (replaces raw SQL)
+    const getAllStageAction = await stageActionRepo.find({
+      where: {
+        stage_id: id,
+        entity_type: 'WFSA',
+      },
+      select: ['action_id'],
+    });
 
+    // 2. Delete all related WFSA actions
     if (getAllStageAction.length > 0) {
       for (const action of getAllStageAction) {
         await this.actionService.deleteEntity(
@@ -147,6 +154,7 @@ export class StageService extends EntityServiceImpl {
       }
     }
 
+    // 3. Delete the stage itself
     const deleteStage = await super.deleteEntity(entityType, id, loggedInUser);
 
     return deleteStage;

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

@@ -6,13 +6,10 @@ import { ActionDataService } from './action-data.service';
 import { DataSource, EntityManager } from 'typeorm';
 import { ActivityLogService } from './activity-log.service';
 import { ACTIVITY_CATEGORIES } from '../repository/activity-log.repository';
-import { MediaDataService } from 'src/module/meta/service/media-data.service';
 import { ActionHandler } from 'src/module/workflow-automation/interface/action.decorator';
 import * as moment from 'moment';
 import { ConfigService } from '@nestjs/config';
 import axios from 'axios';
-import { ChecksumAlgorithm } from '@aws-sdk/client-s3';
-import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 
 @Injectable()
 @ActionHandler('add_task')
@@ -20,10 +17,8 @@ export class TaskService extends EntityServiceImpl {
   constructor(
     private readonly taskRepository: TaskRepository,
     private readonly actionDataService: ActionDataService,
-    private readonly dataSource: DataSource,
     @Inject('ActivityLogService')
     private readonly activityLogService: ActivityLogService,
-    private readonly mediaDataService: MediaDataService,
     private readonly configService: ConfigService,
   ) {
     super();
@@ -108,23 +103,25 @@ export class TaskService extends EntityServiceImpl {
       // Logging should not block main flow
     }
 
-    let relationData = await this.dataSource.query(
-      `SELECT * FROM frm_entity_relation WHERE source_entity_type = $1  AND target_entity_type = $2`,
-      [createdEntity.mapped_entity_type, createdEntity.entity_type],
-    );
+    const entityRelationRepo =
+      this.reflectionHelper.getRepoService('EntityRelationData');
+
+    let relationData = await entityRelationRepo.findOne({
+      where: {
+        source_entity_type: createdEntity.mapped_entity_type,
+        target_entity_type: createdEntity.entity_type,
+      },
+    });
 
     if (relationData) {
-      await this.dataSource.query(
-        `INSERT INTO frm_entity_relation_data (organization_id, source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) VALUES ($1, $2, $3, $4, $5 , $6)`,
-        [
-          loggedInUser.organization_id,
-          createdEntity.mapped_entity_id,
-          createdEntity.mapped_entity_type,
-          createdEntity.id,
-          createdEntity.entity_type,
-          relationData[0]?.relation_type,
-        ],
-      );
+      await entityRelationRepo.save({
+        organization_id: loggedInUser.organization_id,
+        source_entity_id: createdEntity.mapped_entity_id,
+        source_entity_type: createdEntity.mapped_entity_type,
+        target_entity_id: createdEntity.id,
+        target_entity_type: createdEntity.entity_type,
+        relation_type: relationData?.relation_type,
+      });
     }
 
     return createdEntity;
@@ -135,37 +132,35 @@ export class TaskService extends EntityServiceImpl {
     loggedInUser: UserData,
     appcode?: string,
   ): Promise<any> {
-    const taskStatusQuery = `
-    SELECT name 
-    FROM frm_list_master_items 
-    WHERE id = $1 
-      AND organization_id = $2 
-      AND listtype = 'TKST'
-    LIMIT 1;
-  `;
-
-    const statusRows = await this.dataSource.query(taskStatusQuery, [
-      entityData.status,
-      loggedInUser.organization_id,
-    ]);
-
-    const oldStatusQuery = `
-    SELECT * 
-    FROM frm_wf_task_data
-    WHERE id = $1
-      AND organization_id = $2
-    LIMIT 1;
-  `;
-
-    const [oldRow] = await this.dataSource.query(oldStatusQuery, [
-      entityData.id,
-      loggedInUser.organization_id,
-    ]);
-
-    const oldStatusRows = await this.dataSource.query(taskStatusQuery, [
-      oldRow.status,
-      loggedInUser.organization_id,
-    ]);
+    const listRepo = this.reflectionHelper.getRepoService('ListMasterItems');
+    const taskRepo = this.reflectionHelper.getRepoService('TaskDataEntity');
+
+    const statusRows = await listRepo.find({
+      where: {
+        id: entityData.status,
+        organization_id: loggedInUser.organization_id,
+        listtype: 'TKST',
+      },
+      take: 1,
+    });
+
+    const oldRow = await taskRepo.findOne({
+      where: {
+        id: entityData.id,
+        organization_id: loggedInUser.organization_id,
+      },
+    });
+
+    const oldStatusRows = oldRow
+      ? await listRepo.find({
+          where: {
+            id: oldRow.status,
+            organization_id: loggedInUser.organization_id,
+            listtype: 'TKST',
+          },
+          take: 1,
+        })
+      : [];
 
     const isStatusChanged =
       statusRows.length > 0 &&
@@ -176,7 +171,6 @@ export class TaskService extends EntityServiceImpl {
       statusRows.length > 0 &&
       statusRows[0].name?.toLowerCase() === 'completed';
 
-    // Sync flags based on status
     entityData.is_completed = isCompletedStatus;
     entityData.is_done = isCompletedStatus;
 
@@ -195,11 +189,14 @@ export class TaskService extends EntityServiceImpl {
       appcode,
     );
 
-    // Convert boolean back to "1" / "0" for response
+    // Convert boolean → "1"/"0"
     if (updatedEntity && typeof updatedEntity['is_mandatory'] === 'boolean') {
       updatedEntity['is_mandatory'] = updatedEntity['is_mandatory'] ? '1' : '0';
     }
 
+    // -------------------------------
+    // Logging Activity
+    // -------------------------------
     try {
       if (isCompletedStatus && isStatusChanged) {
         const completedLogData = {
@@ -234,7 +231,6 @@ export class TaskService extends EntityServiceImpl {
         'Failed to log activity for task:',
         error?.message || error,
       );
-      // Don't block main flow
     }
 
     return updatedEntity;
@@ -524,12 +520,13 @@ export class TaskService extends EntityServiceImpl {
     loggedInUser: any,
   ) {
     if (!entity || !entity.mapped_entity_id || !entity.reason_code) return null;
-    const listMasterItemRepo = this.reflectionHelper.getRepoService('ListMasterItems');
+    const listMasterItemRepo =
+      this.reflectionHelper.getRepoService('ListMasterItems');
     const reason = await listMasterItemRepo.findOne({
       where: {
         id: entity.reason_code,
         organization_id: loggedInUser.organization_id,
-      }
+      },
     });
 
     const notePayload = {

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

@@ -4,57 +4,65 @@ import { DataSource } from 'typeorm';
 
 @Injectable()
 export class WorkflowListMasterService extends EntityServiceImpl {
-  constructor(private readonly dataSource: DataSource) {
+  constructor() {
     super();
   }
 
   async getActionCategoryListByStageId(stageId: number): Promise<any[]> {
-    const results = await this.dataSource.query(
-      `
-      SELECT 
-      ac.name AS name,
-      ac.logo AS logo,
-        ac.modalName AS modalName,
-        a.action_requirement AS actionRequirement
-      FROM frm_wf_stage_action_mapping sam
-      JOIN frm_wf_action a ON sam.action_id = a.id
-      JOIN frm_wf_action_category ac ON a.action_category = ac.id
-      WHERE sam.stage_id = $1
-      `,
-      [stageId],
-    );
+    const stageActionMapping = this.reflectionHelper.getRepoService('StageActionMapping');
+
+    const results = await stageActionMapping
+      .createQueryBuilder("sam")
+      .select([
+        "ac.name AS name",
+        "ac.logo AS logo",
+        "ac.modalname AS modalname",
+        "a.action_requirement AS actionRequirement",
+      ])
+      .innerJoin("frm_wf_action", "a", "a.id = sam.action_id")
+      .innerJoin("frm_wf_action_category", "ac", "ac.id = a.action_category")
+      .where("sam.stage_id = :stageId", { stageId })
+      .getRawMany();
 
     // Add actionStatus and return formatted output
-    return results.map((item: any) => ({
+    return results.map((item) => ({
       name: item.name,
       logo: item.logo,
-      modalName: item.modalName,
+      modalname: item.modalname,
       actionRequirement: item.actionRequirement,
-      actionStatus: 'Done',
+      actionStatus: "Done",
     }));
   }
 
   async getStagesByGroup(stageGroupId: number): Promise<any[]> {
-    const results = await this.dataSource.query(
-      `SELECT id, full_name FROM frm_wf_stage WHERE stage_group_id = $1`,
-      [stageGroupId],
-    );
-    return results;
+    let stageRepo = this.reflectionHelper.getRepoService('Stage');
+
+    const results = await stageRepo.find({
+      where: {
+        stage_group_id: stageGroupId
+      }
+    });
+
+    return results.map(stage => ({
+      id: stage.id,
+      full_name: stage.full_name,
+    }));
   }
 
   async getModes(loggedInUser): Promise<any[]> {
     const { organization_id } = loggedInUser;
 
-    const modes = await this.dataSource.query(
-      `
-    SELECT id, name
-    FROM frm_list_master_items
-    WHERE listtype = 'MOD'
-      AND organization_id = $1
-    `,
-      [organization_id],
-    );
-
-    return modes;
+    let listMasterItemsRepo = this.reflectionHelper.getRepoService('ListMasterItems');
+    const modes = await listMasterItemsRepo.find({
+      where: {
+        listtype: 'MOD',
+        organization_id
+      }
+    });
+
+    return modes.map(mode => ({
+      id: mode.id,
+      name: mode.name,
+    }));
   }
 }

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

@@ -1,15 +1,10 @@
-import {
-  BadGatewayException,
-  Inject,
-  Injectable,
-  Logger,
-} from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { InjectRepository } from '@nestjs/typeorm';
 import axios from 'axios';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { UserData } from 'src/module/user/entity/user.entity';
-import { DataSource, Repository } from 'typeorm';
+import { In, Repository } from 'typeorm';
 import { StageMovementData } from '../entity/stage-movement-data.entity';
 import { ACTIVITY_CATEGORIES } from '../repository/activity-log.repository';
 import { StageMovementRepository } from '../repository/stage-movement.repository';
@@ -20,6 +15,8 @@ import { EntityModificationService } from './entity-modification.service';
 import { TaskService } from './task.service';
 import { ActionCategory } from '../entity/action-category.entity';
 import { StageGroup } from '../entity/stage-group.entity';
+import { ActionDataEntity } from '../entity/action-data.entity';
+import { TaskDataEntity } from '../entity/task-data.entity';
 
 @Injectable()
 export class WorkflowMetaService extends EntityServiceImpl {
@@ -27,7 +24,6 @@ export class WorkflowMetaService extends EntityServiceImpl {
     @InjectRepository(StageMovementData)
     private readonly stageMovementRepo: Repository<StageMovementData>,
     private readonly stageMovementRepository: StageMovementRepository,
-    private readonly dataSource: DataSource,
     private readonly taskRepository: TaskRepository,
     private readonly actionDataService: ActionDataService,
     @Inject('TaskService')
@@ -41,6 +37,10 @@ export class WorkflowMetaService extends EntityServiceImpl {
     private readonly actionCategoryRepo: Repository<ActionCategory>,
     @InjectRepository(StageGroup)
     private readonly stageGroupRepo: Repository<StageGroup>,
+    @InjectRepository(ActionDataEntity)
+    private readonly actionDataEntityRepository:Repository<ActionDataEntity>,
+    @InjectRepository(TaskDataEntity)
+    private readonly taskDataEntityRepository:Repository<TaskDataEntity>,
   ) {
     super();
   }
@@ -92,7 +92,7 @@ export class WorkflowMetaService extends EntityServiceImpl {
       if (!latestMovement) return null;
 
       let stageGroup = await this.stageGroupRepo.findOne({
-        where: {id: latestMovement?.stage_group_id}
+        where: { id: latestMovement?.stage_group_id },
       });
 
       return {
@@ -103,7 +103,7 @@ export class WorkflowMetaService extends EntityServiceImpl {
 
     // get group name for the current stage
     const stageGroup = await this.stageGroupRepo.findOne({
-      where: {id: currentStage?.stage_group_id}
+      where: { id: currentStage?.stage_group_id },
     });
 
     // Return the found or newly created current stage movement
@@ -132,8 +132,8 @@ export class WorkflowMetaService extends EntityServiceImpl {
     const stageGroup = await this.stageGroupRepo.findOne({
       where: {
         id: nextStage?.stage_group_id,
-      }
-    })
+      },
+    });
 
     return {
       hasNextStage: !!nextStage,
@@ -227,8 +227,8 @@ export class WorkflowMetaService extends EntityServiceImpl {
             const actionCategory = await actionCategoryRepo.findOne({
               where: {
                 id: Number(action.action_category),
-              }
-            })
+              },
+            });
 
             if (actionCategory?.code == 'SGCP') {
               await this.taskRepository.updateTaskStatus(
@@ -339,17 +339,17 @@ export class WorkflowMetaService extends EntityServiceImpl {
 
     const actionCategory = await this.actionCategoryRepo.findOne({
       where: {
-        id: Number(firstAction.action_category)
-      }
-    })
+        id: Number(firstAction.action_category),
+      },
+    });
 
     const listMasterItemsRepo = this.reflectionHelper.getRepoService('ListMasterItems');
 
     const assignmentType = await listMasterItemsRepo.findOne({
       where: {
-        id:Number(firstAction.assignment_type)
-      }
-    })
+        id: Number(firstAction.assignment_type),
+      },
+    });
 
     // save in action data
     await this.actionDataService.saveActionData(
@@ -413,13 +413,14 @@ export class WorkflowMetaService extends EntityServiceImpl {
       loggedInUser,
     );
 
-    const unassignedListMasterItemData = await this.dataSource.query(
-      `SELECT name, id 
-   FROM frm_list_master_items 
-   WHERE listtype = "LEST" AND organization_id = $1 
-     AND value IN ($2, $3)`,
-      [loggedInUser.organization_id, 'unassigned', 'active'],
-    );
+    const listMasterItemsRepo = this.reflectionHelper.getRepoService('ListMasterItems');
+    const unassignedListMasterItemData = await listMasterItemsRepo.find({
+      where: {
+        listtype: 'LEST',
+        organization_id: loggedInUser.organization_id,
+        value: In(['unassigned', 'active'])
+      }
+    });
 
     // Find the IDs explicitly
     const unassignedId = unassignedListMasterItemData.find(
@@ -444,50 +445,54 @@ export class WorkflowMetaService extends EntityServiceImpl {
       loggedInUser,
     );
 
-    await this.dataSource.query(
-      `UPDATE frm_wf_action_data SET user_id =$1 
-      WHERE mapped_entity_id=$2
-      AND mapped_entity_type = $3
-      AND stage_id = $4
-      AND (is_current = 'Y' OR is_current IS NULL)
-      `,
-      [lead_owner, lead_id, entity_type, stage_id],
-    );
-
-    await this.dataSource.query(
-      `UPDATE crm_lead_meeting SET user_id=$1
-      WHERE stage_id = $2 
-      AND mapped_entity_id = $3
-      AND mapped_entity_type = "LEAD" 
-      AND (status='scheduled' OR status='rescheduled')
-      `,
-      [lead_owner, stage_id, lead_id],
-    );
-
-    const taskRows = await this.dataSource.query(
-      `SELECT id,status FROM frm_wf_task_data
-      WHERE mapped_entity_id = $1
-      AND mapped_entity_type = $2
-      AND stage_id = $3`,
-      [lead_id, entity_type, stage_id],
-    );
+    await this.actionDataEntityRepository
+      .createQueryBuilder()
+      .update()
+      .set({ user_id: lead_owner })
+      .where("mapped_entity_id = :leadId", { leadId: lead_id })
+      .andWhere("mapped_entity_type = :entityType", { entityType: entity_type })
+      .andWhere("stage_id = :stageId", { stageId: stage_id })
+      .andWhere("(is_current = 'Y' OR is_current IS NULL)")
+      .execute();
+
+    const leadMeetingRepo = this.reflectionHelper.getRepoService('LeadScheduleMeet');
+
+    await leadMeetingRepo
+      .createQueryBuilder()
+      .update()
+      .set({ user_id: lead_owner })
+      .where("stage_id = :stageId", { stageId: stage_id })
+      .andWhere("mapped_entity_id = :leadId", { leadId: lead_id })
+      .andWhere("mapped_entity_type = :entityType", { entityType: "LEAD" })
+      .andWhere("(status = 'scheduled' OR status = 'rescheduled')")
+      .execute();
+
+    const taskRows = await this.taskDataEntityRepository.find({
+      where: {
+        mapped_entity_id: lead_id,
+        mapped_entity_type: entity_type,
+        stage_id
+      }
+    });
 
     for (const task of taskRows) {
-      const statusRows = await this.dataSource.query(
-        `SELECT value FROM frm_list_master_items
-        WHERE id = $1 AND organization_id = $2`,
-        [task.status, loggedInUser.organization_id],
-      );
+      const statusRows = await listMasterItemsRepo.findOne({
+        where: {
+          id: task.status,
+          organization_id: loggedInUser.organization_id
+        }
+      });
 
-      const statusName = statusRows[0]?.value?.toLowerCase() || '';
+      const statusName = statusRows?.value?.toLowerCase() || '';
       if (
         ['todo', 'in_progress'].includes(statusName) ||
         statusName === 'todo'
       ) {
-        await this.dataSource.query(
-          `UPDATE frm_wf_task_data SET user_id = $1, task_owner = $2 WHERE id  = $3`,
-          [lead_owner, lead_owner, task.id],
-        );
+
+        await this.taskDataEntityRepository.update(task.id,{
+          user_id: lead_owner,
+          task_owner: lead_owner
+        });
       }
     }
 
@@ -572,19 +577,18 @@ export class WorkflowMetaService extends EntityServiceImpl {
 
     // 2) Find the last assigned *eligible* owner (use IN (...))
     const placeholders = userIds.map(() => '?').join(',');
-    const lastRow: Array<{ lead_owner: number }> = await this.dataSource.query(
-      `
-    SELECT lead_owner
-    FROM crm_lead
-    WHERE organization_id = $1
-      AND level_id = $2
-      AND level_type = $3
-      AND lead_owner IN (${placeholders})
-    ORDER BY created_date DESC
-    LIMIT 1
-    `,
-      [organization_id, Number(level_id), level_type, ...userIds],
-    );
+
+    const leadRepo = this.reflectionHelper.getRepoService('CRMLead');
+    const lastRow = await leadRepo
+      .createQueryBuilder("cl")
+      .select("cl.lead_owner", "lead_owner")
+      .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")
+      .limit(1)
+      .getRawOne();
 
     const lastAssigned = lastRow.length ? Number(lastRow[0].lead_owner) : null;