rez_core 2.1.148 → 2.1.149

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.1.148",
+  "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/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.service.ts

@@ -288,7 +288,7 @@ export class ActionService extends EntityServiceImpl {
       .createQueryBuilder()
       .select([
         'a.id AS id',
-        'a.name AS action_name',
+        'a.name AS name',
         'ac.name AS action_category',
         'ar.name AS action_requirement',
       ])

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;

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

@@ -1,14 +1,38 @@
+import { log } from 'console';
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { StageMovementData } from '../entity/stage-movement-data.entity';
+import { UserData } from 'src/module/user/entity/user.entity';
+import { StageMovementRepository } from '../repository/stage-movement.repository';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 
 @Injectable()
-export class WorkflowMetaService {
+export class WorkflowMetaService extends EntityServiceImpl {
   constructor(
     @InjectRepository(StageMovementData)
     private readonly stageMovementRepo: Repository<StageMovementData>,
-  ) {}
+    private readonly stageMovementRepository: StageMovementRepository,
+  ) {
+    super();
+  }
+
+  // get first stage from stage table
+  async getFirstStage(
+    loggedInUser: UserData,
+    mapped_entity_type: string,
+    mapped_entity_id: number,
+  ): Promise<any | null> {
+    // step1 find in workflow_level_mapping if not found with current level_id and level_type search in for ORG
+    // step2 find in stage_group => workflow_id
+    // step3 find in stage => stage_group_id
+    // step4 get first stage from stage table
+    return this.stageMovementRepository.getFirstStage({
+      loggedInUser,
+      mapped_entity_type,
+      mapped_entity_id,
+    });
+  }
 
   /**
    * Get the current active stage for a given mapped entity
@@ -16,26 +40,37 @@ export class WorkflowMetaService {
   async getCurrentStage(
     mapped_entity_type: string,
     mapped_entity_id: number,
-  ): Promise<StageMovementData | null> {
-    return this.stageMovementRepo.findOne({
+    loggedInUser: UserData,
+  ): Promise<any | null> {
+    // Try to find the current stage movement entry
+    let currentStage = await this.stageMovementRepo.findOne({
       where: {
         mapped_entity_type,
         mapped_entity_id,
         is_current: 'Y',
       },
     });
+
+    // Return the found or newly created current stage movement
+    return currentStage;
   }
 
   /**
    * Get next stage ID based on current stage
    * (Stub logic – replace with real stage transition resolution)
    */
-  async getNextStage(currentStage: StageMovementData): Promise<number | null> {
-    // TODO: Replace with actual logic based on mapping table
-    const nextStageId = currentStage.stage_action_mapping_id + 1;
-    const hasNext = true;
+  async getNextStage(currentStage: any): Promise<any | null> {
+    // get all stage for that stage group
+    const nextStage =
+      await this.stageMovementRepository.getNextStageOrFirstOfNextGroup(
+        currentStage.stage_group_id,
+        currentStage.stage_id,
+      );
 
-    return hasNext ? nextStageId : null;
+    return {
+      hasNextStage: !!nextStage,
+      nextStage: nextStage,
+    };
   }
 
   /**
@@ -44,31 +79,47 @@ export class WorkflowMetaService {
   async moveToNextStage(
     mapped_entity_type: string,
     mapped_entity_id: number,
-    current_user_id: number,
+    loggedInUser: UserData,
   ): Promise<string> {
     const now = new Date();
-    const currentStage = await this.getCurrentStage(mapped_entity_type, mapped_entity_id);
+    let currentStage = await this.getCurrentStage(
+      mapped_entity_type,
+      mapped_entity_id,
+      loggedInUser,
+    );
 
     // Case 1: First stage – initialize
+    // If no current stage movement found, create one from the first stage
     if (!currentStage) {
-      const firstStageId = 1; // TODO: Replace with actual logic to fetch first stage
+      const getAllResult = await this.getFirstStage(
+        loggedInUser,
+        mapped_entity_type,
+        mapped_entity_id,
+      );
 
-      await this.stageMovementRepo.save({
+      const { mappingUsed, stageGroup, firstStage } = getAllResult;
+
+      // Create a new current stage movement record
+      currentStage = await this.stageMovementRepo.save({
+        entity_type: 'STGM',
         mapped_entity_type,
         mapped_entity_id,
-        current_user_id,
-        stage_action_mapping_id: firstStageId,
-        start_date: now,
+        name: firstStage.name,
+        status: firstStage.status,
+        current_user_id: loggedInUser.id,
+        stage_action_mapping_id: firstStage.id,
+        stage_group_id: stageGroup.id,
+        stage_id: firstStage.id,
+        start_date: new Date(),
         is_current: 'Y',
       });
-
-      return 'Workflow started with the first stage.';
     }
 
     // Case 2: Has next stage – move forward
-    const nextStageId = await this.getNextStage(currentStage);
+    const stageDate = await this.getNextStage(currentStage);
 
-    if (nextStageId) {
+    if (stageDate.hasNextStage) {
+      const { nextStage } = stageDate;
       // Close current stage
       currentStage.end_date = now;
       currentStage.is_current = 'N';
@@ -76,16 +127,20 @@ export class WorkflowMetaService {
 
       // Insert next stage
       await this.stageMovementRepo.save({
-        entity_type: 'STAGE_MOVEMENT_DATA',
+        entity_type: 'STGM',
         mapped_entity_type,
         mapped_entity_id,
-        current_user_id,
-        stage_action_mapping_id: nextStageId,
+        name: nextStage.name,
+        status: nextStage.status,
+        current_user_id: loggedInUser.id,
+        stage_action_mapping_id: nextStage.id,
         start_date: now,
+        stage_group_id: nextStage.stage_group_id,
+        stage_id: nextStage.id,
         is_current: 'Y',
       });
 
-      return `Moved to next stage (Stage ID: ${nextStageId}).`;
+      return `Moved to next stage (Stage ID: ${nextStage.id}).`;
     }
 
     // Case 3: No next stage – mark workflow as done

package/src/module/workflow/workflow.module.ts

@@ -39,6 +39,8 @@ import { WorkflowListMasterService } from './service/workflow-list-master.servic
 import { WorkflowMetaService } from './service/workflow-meta.service';
 import { WorkflowService } from './service/workflow.service';
 import { ActionCategoryController } from './controller/action-category.controller';
+import { StageMovementRepository } from './repository/stage-movement.repository';
+import { WorkflowLevelMappingEntity } from './entity/workflow-level-mapping.entity';
 
 @Module({
   imports: [
@@ -54,6 +56,7 @@ import { ActionCategoryController } from './controller/action-category.controlle
       StageMovementData,
       EntityModification,
       TemplateAttach,
+      WorkflowLevelMappingEntity,
     ]),
     EntityModule,
     ListMasterModule,
@@ -83,6 +86,7 @@ import { ActionCategoryController } from './controller/action-category.controlle
     WorkflowService,
     WorkflowMetaService,
     PopulateWorkflowService,
+    StageMovementRepository,
   ],
   exports: [
     'ActionCategoryService',