rez_core 2.1.148 → 2.1.150

package/package.json

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

@@ -0,0 +1,40 @@
+import {
+  Body,
+  Controller,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Post,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { TaskService } from '../service/task.service';
+
+@Controller('/task')
+@UseGuards(JwtAuthGuard)
+export class TaskController {
+  constructor(
+    @Inject('TaskService')
+    private readonly taskService: TaskService,
+  ) {}
+
+  @Post('/getTasksbyUserAndStage')
+  @HttpCode(HttpStatus.OK)
+  async getTasksbyUserAndStage(
+    @Req() req: Request & { user: any },
+    @Body()
+    body: {
+      mapped_entity_type: string;
+      mapped_entity_id: number;
+      stage_id: number;
+    },
+  ) {
+    const loggedInUser = req.user.userData;
+    const result = this.taskService.getAllTaskByUserIdandStageId(
+      loggedInUser,
+      body,
+    );
+    return result;
+  }
+}

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-data.entity.ts

@@ -0,0 +1,34 @@
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_wf_action_data' })
+export class ActionDataEntity extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = 'ACTION_DATA';
+  }
+
+  @Column({ nullable: true })
+  action_id: number;
+
+  @Column({ nullable: true })
+  user_id: number;
+
+  @Column({ nullable: true })
+  stage_id: number;
+
+  @Column({ nullable: true })
+  start_time: Date;
+
+  @Column({ nullable: true })
+  end_time: Date;
+
+  @Column({ nullable: true })
+  is_mandatory: boolean;
+
+  @Column({ nullable: true })
+  mapped_entity_id: number;
+
+  @Column({ nullable: true })
+  mapped_entity_type: string;
+}

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

@@ -29,4 +29,7 @@ export class ActionEntity extends BaseEntity {
 
   @Column({ default: 0, type: 'boolean' })
   default_value: boolean;
+
+  @Column({ nullable: true })
+  user_id: number;
 }

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/task-data.entity.ts

@@ -0,0 +1,43 @@
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_wf_task_data' })
+export class TaskDataEntity extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = 'TASK_DATA';
+  }
+
+  @Column({ nullable: true })
+  task_id: number;
+
+  @Column({ nullable: true })
+  user_id: number;
+
+  @Column({ nullable: true })
+  stage_id: number;
+
+  @Column({ nullable: true })
+  action_id: number;
+
+  @Column({ nullable: true })
+  start_time: Date;
+
+  @Column({ nullable: true })
+  end_time: Date;
+
+  @Column({ nullable: true })
+  is_completed: boolean;
+
+  @Column({ default: 0 })
+  is_system: boolean;
+
+  @Column({ nullable: true })
+  is_mandatory: boolean;
+
+  @Column({ nullable: true })
+  mapped_entity_id: number;
+
+  @Column({ nullable: true })
+  mapped_entity_type: string;
+}

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,215 @@
+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';
+import { UserData } from 'src/module/user/entity/user.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 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;
+  }
+
+  async getAllActionByStageId(stageId: number): Promise<any[]> {
+    return this.dataSource.query(
+      `SELECT * FROM cr_wf_stage_action_mapping WHERE stage_id = ?`,
+      [stageId],
+    );
+  }
+
+  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.dataSource.query(
+          `INSERT INTO cr_wf_action_data (stage_id, user_id, action_id) VALUES (?, ?, ?)`,
+          [act.stage_id, loggedInUser.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.dataSource.query(
+          `INSERT INTO cr_wf_task_data (action_id, user_id) VALUES (?, ?)`,
+          [action.id, loggedInUser.id],
+        );
+      }
+    }
+  }
+}

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

@@ -0,0 +1,30 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { TaskDataEntity } from '../entity/task-data.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class TaskRepository {
+  constructor(
+    @InjectRepository(TaskDataEntity)
+    private readonly TaskRepository: Repository<TaskDataEntity>,
+  ) {}
+
+  async getAllTaskByUserIdAndStageId(
+    userId: number,
+    stageId: number,
+    mapped_entity_type: string,
+    mapped_entity_id: number,
+  ) {
+    const result = await this.TaskRepository.find({
+      where: {
+        user_id: userId,
+        stage_id: stageId,
+        mapped_entity_type,
+        mapped_entity_id,
+      },
+    });
+
+    return result;
+  }
+}

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/task.service.ts

@@ -0,0 +1,25 @@
+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';
+
+@Injectable()
+export class TaskService extends EntityServiceImpl {
+  constructor(private readonly taskRepository: TaskRepository) {
+    super();
+  }
+
+  async getAllTaskByUserIdandStageId(
+    loggedInUser: UserData,
+    data,
+  ): Promise<any> {
+    const taskData = await this.taskRepository.getAllTaskByUserIdAndStageId(
+      loggedInUser.id,
+      data.stage_id,
+      data.mapped_entity_type,
+      data.mapped_entity_id,
+    );
+
+    return taskData;
+  }
+}