rez_core 2.1.154 → 2.1.157

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

@@ -2,10 +2,14 @@ import { Injectable } from '@nestjs/common';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { TaskRepository } from '../repository/task.repository';
+import { ActionDataService } from './action-data.service';
 
 @Injectable()
 export class TaskService extends EntityServiceImpl {
-  constructor(private readonly taskRepository: TaskRepository) {
+  constructor(
+    private readonly taskRepository: TaskRepository,
+    private readonly actionDataService: ActionDataService,
+  ) {
     super();
   }
 
@@ -13,13 +17,79 @@ export class TaskService extends EntityServiceImpl {
     loggedInUser: UserData,
     data,
   ): Promise<any> {
-    const taskData = await this.taskRepository.getAllTaskByUserIdAndStageId(
-      loggedInUser.id,
-      data.stage_id,
-      data.mapped_entity_type,
-      data.mapped_entity_id,
-    );
+    const taskData = await this.taskRepository.getAllTaskByUserIdAndStageId({
+      user_id: data.user_id,
+      stage_id: data.stage_id,
+      mapped_entity_type: data.mapped_entity_type,
+      mapped_entity_id: data.mapped_entity_id,
+    });
+
+    const grouped: { mandatory: any[]; non_mandatory: any[] } = {
+      mandatory: [],
+      non_mandatory: [],
+    };
+
+    for (const task of taskData) {
+      if (task && task.is_mandatory) {
+        grouped.mandatory.push(task);
+      } else {
+        grouped.non_mandatory.push(task);
+      }
+    }
+
+    return grouped;
+  }
+
+  async getEntityData(entityType: string, id: number, loggedInUser: any) {
+    const taskData = await super.getEntityData(entityType, id, loggedInUser);
 
     return taskData;
   }
+
+  async saveActionData(
+    action: any,
+    loggedInUser: UserData,
+    mapped_entity_id: number,
+    mapped_entity_type: string,
+  ): Promise<any> {
+    await this.taskRepository.saveActionDataInTask(
+      action,
+      loggedInUser,
+      mapped_entity_id,
+      mapped_entity_type,
+    );
+  }
+
+  async moveTask(
+    loggedInUser: UserData,
+    body: {
+      mapped_entity_type: string;
+      mapped_entity_id: number;
+      stage_id: number;
+      action_id: number;
+    },
+  ): Promise<any> {
+    // Logic to move task based on the provided body parameters
+    // This could involve updating the task's stage, action, etc.
+
+    // update task status
+    this.taskRepository.updateTaskStatus(
+      loggedInUser,
+      body.mapped_entity_type,
+      body.mapped_entity_id,
+      body.stage_id,
+      body.action_id,
+    );
+
+    // update action status
+    await this.actionDataService.updateActionStatus(
+      loggedInUser,
+      body.mapped_entity_type,
+      body.mapped_entity_id,
+      body.stage_id,
+      body.action_id,
+    );
+
+    return 'Task moved successfully';
+  }
 }

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

@@ -1,11 +1,13 @@
 import { log } from 'console';
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository, DataSource } 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';
+import { ActionDataService } from './action-data.service';
+import { TaskService } from './task.service';
 
 @Injectable()
 export class WorkflowMetaService extends EntityServiceImpl {
@@ -14,6 +16,9 @@ export class WorkflowMetaService extends EntityServiceImpl {
     private readonly stageMovementRepo: Repository<StageMovementData>,
     private readonly stageMovementRepository: StageMovementRepository,
     private readonly dataSource: DataSource,
+    private readonly actionDataService: ActionDataService,
+    @Inject('TaskService')
+    private readonly taskService: TaskService,
   ) {
     super();
   }
@@ -136,7 +141,12 @@ export class WorkflowMetaService extends EntityServiceImpl {
         is_current: 'Y',
       });
 
-      this.populateActionService(currentStage.stage_id, loggedInUser);
+      this.populateActionService(
+        currentStage.stage_id,
+        loggedInUser,
+        mapped_entity_id,
+        mapped_entity_type,
+      );
 
       return `Initialized workflow with first stage (Stage ID: ${firstStage.id}).`;
     }
@@ -168,6 +178,13 @@ export class WorkflowMetaService extends EntityServiceImpl {
         is_current: 'Y',
       });
 
+      this.populateActionService(
+        currentStage.stage_id,
+        loggedInUser,
+        mapped_entity_id,
+        mapped_entity_type,
+      );
+
       return `Moved to next stage (Stage ID: ${nextStage.id}).`;
     }
 
@@ -181,7 +198,12 @@ export class WorkflowMetaService extends EntityServiceImpl {
     return 'Workflow completed. No next stage available.';
   }
 
-  async populateActionService(stage_id: number, loggedInUser: UserData) {
+  async populateActionService(
+    stage_id: number,
+    loggedInUser: UserData,
+    mapped_entity_id: number,
+    mapped_entity_type: string,
+  ): Promise<any> {
     const actions =
       await this.stageMovementRepository.getAllActionByStageId(stage_id);
     // Populate the action service with the retrieved actions
@@ -190,36 +212,20 @@ export class WorkflowMetaService extends EntityServiceImpl {
       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,
-    //   );
-    // }
+    // save in action data
+    await this.actionDataService.saveActionData(
+      actions,
+      loggedInUser,
+      mapped_entity_id,
+      mapped_entity_type,
+    );
+
+    // save in task data
+    await this.taskService.saveActionData(
+      actions,
+      loggedInUser,
+      mapped_entity_id,
+      mapped_entity_type,
+    );
   }
 }

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

@@ -46,6 +46,9 @@ 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';
+import { ActionRepository } from './repository/action.repository';
+import { ActionDataRepository } from './repository/action-data.repository';
+import { ActionDataService } from './service/action-data.service';
 
 @Module({
   imports: [
@@ -96,6 +99,9 @@ import { TaskRepository } from './repository/task.repository';
     PopulateWorkflowService,
     StageMovementRepository,
     TaskRepository,
+    ActionRepository,
+    ActionDataRepository,
+    ActionDataService,
   ],
   exports: [
     'ActionCategoryService',