rez_core 5.0.5 → 5.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "5.0.5",
+  "version": "5.0.7",
   "description": "",
   "author": "",
   "private": false,

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

@@ -63,95 +63,117 @@ export class StageGroupRepository {
 
   async getAllStageGroupAndStageHierarchy(
     workflow_id: number,
-    loggedInUser: any, // required for media service
+    loggedInUser: any,
     lead_id: number,
   ) {
     if (!workflow_id) {
       throw new BadRequestException('workflow_id is required');
     }
 
-    // Step 1: Get all stage groups
+    // Step 1: Get stage groups
     const stageGroups = await this.getAllStageGroupByCondition({
       workflow_id,
       organization_id: loggedInUser.organization_id,
-      // level_id: loggedInUser.level_id,
     });
 
     if (!stageGroups.length) return [];
 
-    // Step 2: Get all stages for these stage groups
-    const stageGroupIds = stageGroups.map((sg) => sg.id);
+    // -------------------------------------------------------------
+    // STEP 2: Get all stages - FIXED with `$1, $2, $3...`
+    // -------------------------------------------------------------
+
+    const stageGroupIds = stageGroups.map((sg) => Number(sg.id));
+    const stageGroupPlaceholders = stageGroupIds
+      .map((_, idx) => `$${idx + 1}`)
+      .join(", ");
+
+    const params_stage = [...stageGroupIds, Number(loggedInUser.organization_id)];
+
     const stagesRaw = await this.dataSource.query(
       `
-      SELECT
-        frm_wf_stage.*
+      SELECT frm_wf_stage.*
       FROM frm_wf_stage
-      WHERE frm_wf_stage.stage_group_id IN (${stageGroupIds.map(() => '?').join(',')})
-        AND frm_wf_stage.organization_id = $2
+      WHERE frm_wf_stage.stage_group_id IN (${stageGroupPlaceholders})
+        AND frm_wf_stage.organization_id = $${stageGroupIds.length + 1}
       ORDER BY frm_wf_stage.sequence ASC
     `,
-      [...stageGroupIds, loggedInUser.organization_id],
+      params_stage,
     );
 
-    const stageIds = stagesRaw.map((s) => s.id);
+    const stageIds = stagesRaw.map((s) => Number(s.id));
+
+    if (stageIds.length === 0) {
+      return stageGroups.map((sg) => ({ ...sg, stages: [] }));
+    }
+
+    // -------------------------------------------------------------
+    // STEP 3: Task Counts (Postgres-safe)
+    // -------------------------------------------------------------
+    const stagePlaceholders = stageIds
+      .map((_, idx) => `$${idx + 1}`)
+      .join(", ");
+
+    const params_task = [...stageIds, Number(lead_id)];
 
-    // Task counts
     const taskCounts = await this.dataSource.query(
       `
-    SELECT stage_id, COUNT(*) AS task_count
-    FROM frm_wf_task_data
-    WHERE stage_id IN (${stageIds.map(() => '?').join(',')}) AND is_system=0 AND mapped_entity_id = $2
-    GROUP BY stage_id
+      SELECT stage_id, COUNT(*) AS task_count
+      FROM frm_wf_task_data
+      WHERE stage_id IN (${stagePlaceholders})
+        AND is_system = 0
+        AND mapped_entity_id = $${stageIds.length + 1}
+      GROUP BY stage_id
     `,
-      [...stageIds, lead_id],
+      params_task,
     );
 
-    // Meeting counts
+    // -------------------------------------------------------------
+    // 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 (${stageIds.map(() => '?').join(',')}) AND mapped_entity_id = $2
-    GROUP BY stage_id
+      SELECT stage_id, COUNT(*) AS meeting_count
+      FROM crm_lead_meeting
+      WHERE stage_id IN (${stagePlaceholders})
+        AND mapped_entity_id = $${stageIds.length + 1}
+      GROUP BY stage_id
     `,
-      [...stageIds, lead_id],
+      params_task,
     );
 
-    // Send communication counts
+    // -------------------------------------------------------------
+    // 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 (${stageIds.map(() => '?').join(',')}) AND mapped_entity_id = $2
-    AND type IN ('SEND', 'LOG')
-    GROUP BY stage_id
+      SELECT stage_id, COUNT(*) AS send_comm_count
+      FROM crm_lead_communication
+      WHERE stage_id IN (${stagePlaceholders})
+        AND mapped_entity_id = $${stageIds.length + 1}
+        AND type IN ('SEND','LOG')
+      GROUP BY stage_id
     `,
-      [...stageIds, lead_id],
+      params_task,
     );
 
-    // Convert to maps for quick lookup
+    // Convert to maps
     const taskCountMap = new Map(
-      taskCounts.map((row) => [Number(row.stage_id), Number(row.task_count)]),
+      taskCounts.map((r) => [Number(r.stage_id), Number(r.task_count)]),
     );
     const meetingCountMap = new Map(
-      meetingCounts.map((row) => [
-        Number(row.stage_id),
-        Number(row.meeting_count),
-      ]),
+      meetingCounts.map((r) => [Number(r.stage_id), Number(r.meeting_count)]),
     );
     const sendCommCountMap = new Map(
-      sendCommCounts.map((row) => [
-        Number(row.stage_id),
-        Number(row.send_comm_count),
-      ]),
+      sendCommCounts.map((r) => [Number(r.stage_id), Number(r.send_comm_count)]),
     );
 
-    // Step 4: Add counts & profile to each stage
-
-    // Step 5: Group stages by stage_group_id
+    // -------------------------------------------------------------
+    // STEP 6: Combine stages per group
+    // -------------------------------------------------------------
     const stageMap = new Map<number, any[]>();
+
     for (const stage of stagesRaw) {
-      const stageId = Number(stage.id); // ensure number
+      const stageId = Number(stage.id);
 
       stage.task_count = taskCountMap.get(stageId) || 0;
       stage.meeting_count = meetingCountMap.get(stageId) || 0;
@@ -160,17 +182,16 @@ export class StageGroupRepository {
       if (!stageMap.has(stage.stage_group_id)) {
         stageMap.set(stage.stage_group_id, []);
       }
-      stageMap.get(stage.stage_group_id)?.push(stage);
-    }
 
-    // Step 5: Attach stages with counts to stage groups
-    const result = stageGroups.map((stageGroup) => {
-      return {
-        ...stageGroup,
-        stages: stageMap.get(Number(stageGroup.id)) || [],
-      };
-    });
+      stageMap.get(stage.stage_group_id)!.push(stage);
+    }
 
-    return result;
+    // -------------------------------------------------------------
+    // STEP 7: Build final response
+    // -------------------------------------------------------------
+    return stageGroups.map((sg) => ({
+      ...sg,
+      stages: stageMap.get(Number(sg.id)) || [],
+    }));
   }
 }