rez_core 6.1.0 → 6.1.1

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

@@ -1,217 +1,217 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { IsNull, MoreThan, Not, 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 { 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 {
-  constructor(
-    @InjectRepository(WorkflowLevelMappingEntity)
-    private readonly workflowLevelMappingRepo: Repository<WorkflowLevelMappingEntity>,
-    @InjectRepository(StageGroup)
-    private readonly stageGroupRepo: Repository<StageGroup>,
-    @InjectRepository(Stage)
-    private readonly stageRepo: Repository<Stage>,
-    private readonly reflectionHelper: ReflectionHelper,
-    @InjectRepository(ActionDataEntity)
-    private readonly actionDataEntityRepository: Repository<ActionDataEntity>,
-    @InjectRepository(TaskDataEntity)
-    private readonly taskDataEntityRepository: Repository<TaskDataEntity>,
-  ) {}
-
-  async getFirstStage({
-    loggedInUser,
-    mapped_entity_type,
-    mapped_entity_id,
-  }: {
-    loggedInUser: any;
-    mapped_entity_type: string;
-    mapped_entity_id: string | number;
-  }): Promise<any | null> {
-    // Try finding mapping at user's level
-    let workflowLevelMapping = await this.workflowLevelMappingRepo.findOne({
-      where: {
-        mapped_level_type: loggedInUser.level_type,
-        mapped_level_id: loggedInUser.level_id,
-      },
-    });
-
-    // If not found, fallback to enterprise-level mapping
-    if (!workflowLevelMapping) {
-      workflowLevelMapping = await this.workflowLevelMappingRepo.findOne({
-        where: {
-          mapped_level_type: 'ORG',
-          mapped_level_id: loggedInUser.enterprise_id,
-        },
-      });
-    }
-
-    // If still not found, return null
-    if (!workflowLevelMapping) return null;
-
-    // Find the stage group for this workflow
-    const stageGroup = await this.stageGroupRepo.findOne({
-      where: {
-        workflow_id: workflowLevelMapping.workflow_id,
-      },
-      order: { id: 'ASC' }, // Ensure you get the earliest/first group if needed
-    });
-
-    if (!stageGroup) return null;
-
-    // Find the first stage within this group
-    const firstStage = await this.stageRepo.findOne({
-      where: {
-        stage_group_id: stageGroup.id,
-      },
-      order: { id: 'ASC' }, // Change ordering as per your "first" logic
-    });
-
-    if (!firstStage) return null;
-
-    // Return comprehensive result
-    return {
-      mappingUsed: workflowLevelMapping,
-      stageGroup,
-      firstStage,
-    };
-  }
-
-  async getNextStage(
-    stageGroupId: number,
-    currentStageId: number,
-  ): Promise<any | null> {
-    const allStages = await this.stageRepo.find({
-      where: { stage_group_id: stageGroupId },
-      order: { sequence: 'ASC' },
-    });
-
-    if (currentStageId === 0) return allStages.length > 0 ? allStages[0] : null;
-
-    const currentStage = allStages.find((s) => s.id == currentStageId);
-    if (!currentStage) return null;
-
-    // Filter for stages with a greater sequence, then pick the smallest one
-    const higherStages = allStages
-      .filter((s) => s.sequence > currentStage.sequence)
-      .sort((a, b) => a.sequence - b.sequence);
-
-    return higherStages.length > 0 ? higherStages[0] : null;
-  }
-
-  async getNextStageGroup(currentStageGroupId: number): Promise<any | null> {
-    const currentStageGroup = await this.stageGroupRepo.findOne({
-      where: { id: currentStageGroupId },
-    });
-    if (!currentStageGroup) return null;
-
-    //get workflow id of current stage group
-    const workflowId = currentStageGroup.workflow_id;
-
-    // Find the next stage group with a higher sequence
-    const nextStageGroup = await this.stageGroupRepo.findOne({
-      where: {
-        workflow_id: workflowId,
-        sequence: MoreThan(currentStageGroup.sequence),
-      },
-      order: { sequence: 'ASC' }, // Get the immediate next
-    });
-
-    return nextStageGroup || null;
-  }
-
-  async getNextStageOrFirstOfNextGroup(
-    stageGroupId: number,
-    currentStageId: number,
-  ): Promise<any | null> {
-    // 1. Try to get the next stage in same group
-    const nextStage = await this.getNextStage(stageGroupId, currentStageId);
-    if (nextStage) return nextStage;
-
-    // 2. No next stage. Try to get next stage group
-    const nextStageGroup = await this.getNextStageGroup(stageGroupId);
-    if (!nextStageGroup) return null;
-
-    const nextStageGroupFirstStage = await this.getNextStage(
-      nextStageGroup.id,
-      0,
-    );
-    return nextStageGroupFirstStage || null;
-  }
-
-  async getAllActionByStageId(stageId: number): Promise<any> {
-    const actionRepo = this.reflectionHelper.getRepoService('ActionEntity');
-    const result = await actionRepo
-      .createQueryBuilder('a')
-      .innerJoin(
-        'frm_wf_stage_action_mapping',
-        'm',
-        'a.id = m.action_id::bigint',
-      )
-      .leftJoin(
-        'frm_wf_action_category',
-        'ac',
-        'a.action_category::bigint = ac.id',
-      )
-      .where('m.stage_id::bigint = :stageId', { stageId: Number(stageId) })
-      .select([
-        'a.*',
-        'm.id AS mapping_id',
-        'm.stage_id AS stage_id',
-        'ac.code AS action_category_code'
-      ])
-      .orderBy('a.sequence', 'ASC')
-      .getRawMany();
-
-    // Use for..of with await instead of map
-    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,
-            form_id: Not(IsNull())
-          },
-        });
-
-        item.form_id = actionData?.form_id || null;
-      }
-    }
-
-    return result;
-  }
-
-  async saveActionData(action: any, loggedInUser: UserData): Promise<any> {
-    // Implement the logic to save action data
-
-    if (action.length > 0) {
-      for (const act of action) {
-        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.taskDataEntityRepository.save({
-          action_id: action.id,
-          user_id: String(loggedInUser.id),
-        });
-      }
-    }
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { IsNull, MoreThan, Not, 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 { 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 {
+  constructor(
+    @InjectRepository(WorkflowLevelMappingEntity)
+    private readonly workflowLevelMappingRepo: Repository<WorkflowLevelMappingEntity>,
+    @InjectRepository(StageGroup)
+    private readonly stageGroupRepo: Repository<StageGroup>,
+    @InjectRepository(Stage)
+    private readonly stageRepo: Repository<Stage>,
+    private readonly reflectionHelper: ReflectionHelper,
+    @InjectRepository(ActionDataEntity)
+    private readonly actionDataEntityRepository: Repository<ActionDataEntity>,
+    @InjectRepository(TaskDataEntity)
+    private readonly taskDataEntityRepository: Repository<TaskDataEntity>,
+  ) {}
+
+  async getFirstStage({
+    loggedInUser,
+    mapped_entity_type,
+    mapped_entity_id,
+  }: {
+    loggedInUser: any;
+    mapped_entity_type: string;
+    mapped_entity_id: string | number;
+  }): Promise<any | null> {
+    // Try finding mapping at user's level
+    let workflowLevelMapping = await this.workflowLevelMappingRepo.findOne({
+      where: {
+        mapped_level_type: loggedInUser.level_type,
+        mapped_level_id: loggedInUser.level_id,
+      },
+    });
+
+    // If not found, fallback to enterprise-level mapping
+    if (!workflowLevelMapping) {
+      workflowLevelMapping = await this.workflowLevelMappingRepo.findOne({
+        where: {
+          mapped_level_type: 'ORG',
+          mapped_level_id: loggedInUser.enterprise_id,
+        },
+      });
+    }
+
+    // If still not found, return null
+    if (!workflowLevelMapping) return null;
+
+    // Find the stage group for this workflow
+    const stageGroup = await this.stageGroupRepo.findOne({
+      where: {
+        workflow_id: workflowLevelMapping.workflow_id,
+      },
+      order: { id: 'ASC' }, // Ensure you get the earliest/first group if needed
+    });
+
+    if (!stageGroup) return null;
+
+    // Find the first stage within this group
+    const firstStage = await this.stageRepo.findOne({
+      where: {
+        stage_group_id: stageGroup.id,
+      },
+      order: { id: 'ASC' }, // Change ordering as per your "first" logic
+    });
+
+    if (!firstStage) return null;
+
+    // Return comprehensive result
+    return {
+      mappingUsed: workflowLevelMapping,
+      stageGroup,
+      firstStage,
+    };
+  }
+
+  async getNextStage(
+    stageGroupId: number,
+    currentStageId: number,
+  ): Promise<any | null> {
+    const allStages = await this.stageRepo.find({
+      where: { stage_group_id: stageGroupId },
+      order: { sequence: 'ASC' },
+    });
+
+    if (currentStageId === 0) return allStages.length > 0 ? allStages[0] : null;
+
+    const currentStage = allStages.find((s) => s.id == currentStageId);
+    if (!currentStage) return null;
+
+    // Filter for stages with a greater sequence, then pick the smallest one
+    const higherStages = allStages
+      .filter((s) => s.sequence > currentStage.sequence)
+      .sort((a, b) => a.sequence - b.sequence);
+
+    return higherStages.length > 0 ? higherStages[0] : null;
+  }
+
+  async getNextStageGroup(currentStageGroupId: number): Promise<any | null> {
+    const currentStageGroup = await this.stageGroupRepo.findOne({
+      where: { id: currentStageGroupId },
+    });
+    if (!currentStageGroup) return null;
+
+    //get workflow id of current stage group
+    const workflowId = currentStageGroup.workflow_id;
+
+    // Find the next stage group with a higher sequence
+    const nextStageGroup = await this.stageGroupRepo.findOne({
+      where: {
+        workflow_id: workflowId,
+        sequence: MoreThan(currentStageGroup.sequence),
+      },
+      order: { sequence: 'ASC' }, // Get the immediate next
+    });
+
+    return nextStageGroup || null;
+  }
+
+  async getNextStageOrFirstOfNextGroup(
+    stageGroupId: number,
+    currentStageId: number,
+  ): Promise<any | null> {
+    // 1. Try to get the next stage in same group
+    const nextStage = await this.getNextStage(stageGroupId, currentStageId);
+    if (nextStage) return nextStage;
+
+    // 2. No next stage. Try to get next stage group
+    const nextStageGroup = await this.getNextStageGroup(stageGroupId);
+    if (!nextStageGroup) return null;
+
+    const nextStageGroupFirstStage = await this.getNextStage(
+      nextStageGroup.id,
+      0,
+    );
+    return nextStageGroupFirstStage || null;
+  }
+
+  async getAllActionByStageId(stageId: number): Promise<any> {
+    const actionRepo = this.reflectionHelper.getRepoService('ActionEntity');
+    const result = await actionRepo
+      .createQueryBuilder('a')
+      .innerJoin(
+        'frm_wf_stage_action_mapping',
+        'm',
+        'a.id = m.action_id::bigint',
+      )
+      .leftJoin(
+        'frm_wf_action_category',
+        'ac',
+        'a.action_category::bigint = ac.id',
+      )
+      .where('m.stage_id::bigint = :stageId', { stageId: Number(stageId) })
+      .select([
+        'a.*',
+        'm.id AS mapping_id',
+        'm.stage_id AS stage_id',
+        'ac.code AS action_category_code'
+      ])
+      .orderBy('a.sequence', 'ASC')
+      .getRawMany();
+
+    // Use for..of with await instead of map
+    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,
+            form_id: Not(IsNull())
+          },
+        });
+
+        item.form_id = actionData?.form_id || null;
+      }
+    }
+
+    return result;
+  }
+
+  async saveActionData(action: any, loggedInUser: UserData): Promise<any> {
+    // Implement the logic to save action data
+
+    if (action.length > 0) {
+      for (const act of action) {
+        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.taskDataEntityRepository.save({
+          action_id: action.id,
+          user_id: String(loggedInUser.id),
+        });
+      }
+    }
+  }
+}