rez_core 2.1.147 → 2.1.149

package/package.json

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

package/src/module/meta/entity/base-entity.entity.ts

@@ -49,7 +49,7 @@ export class BaseEntity {
   @Expose()
   modified_by: number;
 
-  @Column({ name: 'modified_date',  nullable: true })
+  @Column({ name: 'modified_date', nullable: true })
   @Expose()
   modified_date: Date;
 

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

@@ -1,8 +1,18 @@
-import { Controller, Get, Query, Post, Body } from '@nestjs/common';
+import {
+  Controller,
+  Get,
+  Query,
+  Post,
+  Body,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
 import { WorkflowMetaService } from '../service/workflow-meta.service';
 import { StageMovementData } from '../entity/stage-movement-data.entity';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
 
 @Controller('workflow-meta')
+@UseGuards(JwtAuthGuard)
 export class WorkflowMetaController {
   constructor(private readonly workflowMetaService: WorkflowMetaService) {}
 
@@ -13,8 +23,15 @@ export class WorkflowMetaController {
   async getCurrentStage(
     @Query('entityType') mapped_entity_type: string,
     @Query('entityId') mapped_entity_id: number,
+    @Req() req: Request & { user: any },
   ): Promise<StageMovementData | null> {
-    return this.workflowMetaService.getCurrentStage(mapped_entity_type, Number(mapped_entity_id));
+    let loggedInUser = req.user.userData;
+
+    return this.workflowMetaService.getCurrentStage(
+      mapped_entity_type,
+      Number(mapped_entity_id),
+      loggedInUser,
+    );
   }
 
   /**
@@ -24,8 +41,14 @@ export class WorkflowMetaController {
   async getNextStage(
     @Query('entityType') mapped_entity_type: string,
     @Query('entityId') mapped_entity_id: number,
+    @Req() req: Request & { user: any },
   ): Promise<number | null> {
-    const current = await this.workflowMetaService.getCurrentStage(mapped_entity_type, Number(mapped_entity_id));
+    const loggedInUser = req.user.userData;
+    const current = await this.workflowMetaService.getCurrentStage(
+      mapped_entity_type,
+      Number(mapped_entity_id),
+      loggedInUser,
+    );
     return current ? this.workflowMetaService.getNextStage(current) : null;
   }
 
@@ -41,12 +64,13 @@ export class WorkflowMetaController {
   async moveToNextStage(
     @Body('entityType') mapped_entity_type: string,
     @Body('entityId') mapped_entity_id: number,
-    @Body('currentUserId') current_user_id: number,
+    @Req() req: Request & { user: any },
   ): Promise<string> {
+    const loggedInUser = req.user.userData;
     return this.workflowMetaService.moveToNextStage(
       mapped_entity_type,
       Number(mapped_entity_id),
-      current_user_id,
+      loggedInUser,
     );
   }
 }

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

@@ -24,8 +24,8 @@ export class ActionEntity extends BaseEntity {
   @Column({ type: 'varchar', nullable: true })
   reason_code: string;
 
-  @Column({ type: 'varchar', nullable: true })
-  default_reason_code: string;
+  @Column({ type: 'int', nullable: true })
+  default_reason_code: number;
 
   @Column({ default: 0, type: 'boolean' })
   default_value: boolean;

package/src/module/workflow/entity/stage-movement-data.entity.ts

@@ -15,6 +15,12 @@ export class StageMovementData extends BaseEntity {
   @Column({ type: 'int', nullable: true })
   stage_action_mapping_id: number;
 
+  @Column({ type: 'int', nullable: true })
+  stage_group_id: number;
+
+  @Column({ type: 'int', nullable: true })
+  stage_id: number;
+
   @Column({ type: 'date', nullable: true })
   start_date: Date;
 

package/src/module/workflow/entity/workflow-level-mapping.entity.ts

@@ -0,0 +1,18 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'cr_workflow_level_mapping' })
+export class WorkflowLevelMappingEntity {
+  constructor() {}
+
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ nullable: true })
+  workflow_id: number;
+
+  @Column({ nullable: true })
+  mapped_level_id: string;
+
+  @Column({ nullable: true })
+  mapped_level_type: string;
+}

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

@@ -0,0 +1,181 @@
+import { get } from 'http';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository, DataSource, MoreThan } 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';
+
+@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 dataSource: DataSource,
+  ) {}
+
+  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 organization-level mapping
+    if (!workflowLevelMapping) {
+      workflowLevelMapping = await this.workflowLevelMappingRepo.findOne({
+        where: {
+          mapped_level_type: 'ORG',
+          mapped_level_id: loggedInUser.organization_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> {
+  //   // 1. Get current stage to find its sequence number
+  //   const currentStage = await this.stageRepo.findOne({
+  //     where: { id: currentStageId, stage_group_id: stageGroupId },
+  //   });
+  //   if (!currentStage) return null;
+
+  //   // 2. Find the next stage with sequence just after the current one
+  //   const nextStage = await this.stageRepo.findOne({
+  //     where: {
+  //       stage_group_id: stageGroupId,
+  //       sequence: MoreThan(currentStage.sequence),
+  //     },
+  //     order: { sequence: 'ASC' },
+  //   });
+
+  //   return nextStage || null;
+  // }
+
+  // async getNextStageGroup(
+  //   currentStageGroupId: number,
+  // ): Promise<StageGroup | null> {
+  //   // 1. Get current stage group
+  //   const currentStageGroup = await this.stageGroupRepo.findOne({
+  //     where: { id: currentStageGroupId },
+  //   });
+  //   if (!currentStageGroup) return null;
+  //   // 2. Find the next stage group with a higher sequence
+  //   const nextStageGroup = await this.stageGroupRepo.findOne({
+  //     where: {
+  //       sequence: MoreThan(currentStageGroup.sequence),
+  //     },
+  //     order: { sequence: 'ASC' }, // Get the immediate next
+  //   });
+  //   return nextStageGroup || null;
+  // }
+
+  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;
+  }
+}

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

@@ -22,6 +22,9 @@ export class ActionCategoryService extends EntityServiceImpl {
       [entity_type, organization_id],
     );
 
-    return result;
+    return result.map((row: any) => ({
+      label: row.name,
+      value: row.id,
+    }));
   }
 }

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

@@ -37,8 +37,6 @@ export class ActionService extends EntityServiceImpl {
     manager?: EntityManager | null,
     appcode?: string,
   ): Promise<any> {
-    console.log('entityData', entityData);
-
     let actionData = entityData as any;
 
     let action = await super.createEntity(
@@ -196,7 +194,7 @@ export class ActionService extends EntityServiceImpl {
     }
     const result = await this.dataSource.query(
       `
-    SELECT name, value 
+    SELECT name, id 
     FROM cr_list_master_items 
     WHERE listtype = ? AND organization_id = ?
     `,
@@ -205,8 +203,8 @@ export class ActionService extends EntityServiceImpl {
 
     // Format as array of key-value pairs
     return result.map((row: any) => ({
-      label: row.value,
-      value: row.name,
+      label: row.name,
+      value: row.id,
     }));
   }
 
@@ -228,88 +226,93 @@ export class ActionService extends EntityServiceImpl {
     const actionIds = stageActions.map((sa) => sa.action_id);
     const mappingIds = stageActions.map((sa) => sa.id);
 
+    // Step 2: Get template codes with mapping IDs
     const templateMappings = await this.dataSource.query(
       `
-    SELECT template_code 
+    SELECT stg_act_mapping_id, template_code 
     FROM cr_wf_action_template_mapping 
-    WHERE stg_act_mapping_id IN (?)
+    WHERE stg_act_mapping_id IN (${mappingIds.map(() => '?').join(',')})
     `,
-      [mappingIds],
+      mappingIds,
     );
 
     const templateCodes = templateMappings.map((tm) => tm.template_code);
 
     // Step 3: Fetch template names from cr_wf_comm_template
-    let templateNameMap: Record<number, string> = {};
+    const templateCodeToName: Record<string, string> = {};
 
     if (templateCodes.length > 0) {
-      const templates = await this.dataSource.query(
-        `
-      SELECT code, name 
-      FROM cr_wf_comm_template 
-      WHERE code IN (?)
-        AND organization_id = ?
-      `,
-        [templateCodes, organization_id],
-      );
-
-      // Map template_code to name
-      const codeToNameMap = templates.reduce((acc, curr) => {
-        acc[curr.code] = curr.name;
-        return acc;
-      }, {});
-
-      // Group template names by mapping_id
-      templateMappings.forEach((tm) => {
-        const mappingId = tm.stg_act_mapping_id;
-        const name = codeToNameMap[tm.template_code];
-        if (name) {
-          if (!templateNameMap[mappingId]) {
-            templateNameMap[mappingId] = name;
-          } else {
-            templateNameMap[mappingId] += `, ${name}`;
-          }
-        }
+      const templates = await this.dataSource
+        .createQueryBuilder()
+        .select(['t.code AS code', 't.name AS name'])
+        .from('cr_wf_comm_template', 't')
+        .where('t.code IN (:...codes)', { codes: templateCodes })
+        .andWhere('t.organization_id = :orgId', { orgId: organization_id })
+        .getRawMany();
+
+      templates.forEach((tpl) => {
+        templateCodeToName[tpl.code] = tpl.name;
       });
     }
 
-    // Step 2: Fetch action details based on those action_ids
-    // Step 4: Fetch action details
-    const result = await this.dataSource.query(
-      `
-    SELECT 
-      a.id,
-      a.name AS action_name,
-      ac.name AS action_category,
-      ar.name AS action_requirement
-    FROM cr_wf_action a
-    LEFT JOIN cr_wf_action_category ac 
-      ON ac.id = a.action_cat_id
-    LEFT JOIN cr_list_master_items ar 
-      ON ar.id = a.action_requirement
-      AND ar.listtype = 'ACRQ'
-      AND ar.organization_id = ?
-    WHERE a.organization_id = ?
-      AND a.id IN (?)
-    `,
-      [organization_id, organization_id, actionIds],
-    );
+    // Step 4: Build map of mapping_id → template names
+    const mappingIdToTemplates: Record<number, string[]> = {};
 
-    // Step 5: Attach templates (comma-separated) to each result row
-    const enrichedResult = result.map((row) => {
-      // Find all mapping_ids where action_id == current row.id
-      const relatedMappingIds = stageActions
-        .filter((sa) => sa.action_id === row.id)
-        .map((sa) => sa.id);
+    for (const tm of templateMappings) {
+      const mappingId = tm.stg_act_mapping_id;
+      const name = templateCodeToName[tm.template_code];
+      if (name) {
+        if (!mappingIdToTemplates[mappingId]) {
+          mappingIdToTemplates[mappingId] = [];
+        }
+        mappingIdToTemplates[mappingId].push(name);
+      }
+    }
+
+    // Step 5: Build action_id → template names using mappingIdToTemplates + stageActions
+    const actionIdToTemplates: Record<number, string[]> = {};
+
+    for (const sa of stageActions) {
+      const mappingId = sa.id;
+      const templates = mappingIdToTemplates[mappingId];
+      if (templates?.length) {
+        if (!actionIdToTemplates[sa.action_id]) {
+          actionIdToTemplates[sa.action_id] = [];
+        }
+        actionIdToTemplates[sa.action_id].push(...templates);
+      }
+    }
 
-      // Collect all template names across those mapping ids
-      const allNames = relatedMappingIds
-        .map((mid) => templateNameMap[mid])
-        .filter(Boolean);
+    // Step 6: Fetch action details
+    const actionResults = await this.dataSource
+      .createQueryBuilder()
+      .select([
+        'a.id AS id',
+        'a.name AS name',
+        'ac.name AS action_category',
+        'ar.name AS action_requirement',
+      ])
+      .from('cr_wf_action', 'a')
+      .leftJoin('cr_wf_action_category', 'ac', 'ac.id = a.action_cat_id')
+      .leftJoin(
+        'cr_list_master_items',
+        'ar',
+        `ar.id = a.action_requirement AND ar.listtype = 'ACRQ' AND ar.organization_id = :orgId`,
+        { orgId: organization_id },
+      )
+      .where('a.organization_id = :orgId', { orgId: organization_id })
+      .andWhere('a.id IN (:...actionIds)', { actionIds })
+      .getRawMany();
+
+    // Step 7: Enrich result with template field
+    const enrichedResult = actionResults.map((row) => {
+      const actionId = Number(row.id); // Ensure numeric ID match
+      const templates = actionIdToTemplates[actionId] || [];
+      const uniqueTemplates = [...new Set(templates)]; // remove duplicates
 
       return {
         ...row,
-        template: allNames.length ? allNames.join(', ') : '',
+        template: uniqueTemplates.join(', '),
       };
     });
 

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

@@ -86,7 +86,7 @@ export class CommTemplateService extends EntityServiceImpl {
 
     const response = commTemplateData.map((item) => ({
       value: item.code,
-      name: item.name,
+      label: item.name,
     }));
 
     return response;