rez_core 2.1.148 → 2.1.150

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,53 @@ 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.';
+      this.populateActionService(currentStage.stage_id, loggedInUser);
+
+      return `Initialized workflow with first stage (Stage ID: ${firstStage.id}).`;
     }
 
+    //idhr
+
     // 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,18 +133,24 @@ 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}).`;
     }
 
+    //idhr
+
     // Case 3: No next stage – mark workflow as done
     currentStage.end_date = now;
     currentStage.is_current = 'N';
@@ -95,4 +158,46 @@ export class WorkflowMetaService {
 
     return 'Workflow completed. No next stage available.';
   }
+
+  async populateActionService(stage_id: number, loggedInUser: UserData) {
+    const actions =
+      await this.stageMovementRepository.getAllActionByStageId(stage_id);
+    // Populate the action service with the retrieved actions
+
+    if (!actions || actions.length === 0) {
+      return 'No actions found for this stage.';
+    }
+
+    await this.stageMovementRepository.saveActionData(actions, loggedInUser);
+    await this.stageMovementRepository.saveTaskData(actions, loggedInUser);
+
+    // // loop through each action and get the action data and populate the task data
+    // for (const action of actions) {
+    //   const actionData = await super.getEntityData(
+    //     'STAGE_ACTION',
+    //     action.id,
+    //     loggedInUser,
+    //   );
+
+    //   await super.createEntity(
+    //     {
+    //       user_id: loggedInUser.id,
+    //       stage_id: action.stage_id,
+    //       action_id: action.id,
+    //     } as any,
+    //     loggedInUser,
+    //   );
+
+    //   await super.createEntity(
+    //     {
+    //       user_id: loggedInUser.id,
+    //       stage_id: action.stage_id,
+    //       action_id: action.id,
+    //       mapped_entity_type: actionData?.entity_type,
+    //       mapped_entity_id: actionData?.entity_id,
+    //     } as any,
+    //     loggedInUser,
+    //   );
+    // }
+  }
 }

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

@@ -39,6 +39,13 @@ 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';
+import { TaskDataEntity } from './entity/task-data.entity';
+import { ActionDataEntity } from './entity/action-data.entity';
+import { TaskController } from './controller/task.controller';
+import { TaskService } from './service/task.service';
+import { TaskRepository } from './repository/task.repository';
 
 @Module({
   imports: [
@@ -54,6 +61,9 @@ import { ActionCategoryController } from './controller/action-category.controlle
       StageMovementData,
       EntityModification,
       TemplateAttach,
+      WorkflowLevelMappingEntity,
+      TaskDataEntity,
+      ActionDataEntity,
     ]),
     EntityModule,
     ListMasterModule,
@@ -67,6 +77,7 @@ import { ActionCategoryController } from './controller/action-category.controlle
     },
     { provide: 'ActionService', useClass: ActionService },
     { provide: 'StageService', useClass: StageService },
+    { provide: 'TaskService', useClass: TaskService },
     { provide: 'StageGroupService', useClass: StageGroupService },
     { provide: 'WorkflowService', useClass: WorkflowService },
     {
@@ -83,6 +94,8 @@ import { ActionCategoryController } from './controller/action-category.controlle
     WorkflowService,
     WorkflowMetaService,
     PopulateWorkflowService,
+    StageMovementRepository,
+    TaskRepository,
   ],
   exports: [
     'ActionCategoryService',
@@ -109,6 +122,7 @@ import { ActionCategoryController } from './controller/action-category.controlle
     WorkflowMetaController,
     EntityModificationController,
     ActionCategoryController,
+    TaskController,
   ],
 })
 export class WorkflowModule {}