rez_core 2.1.140 → 2.1.141

package/package.json

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

package/src/module/workflow/controller/stage.controller.ts

@@ -2,6 +2,8 @@ import {
   Body,
   Controller,
   Get,
+  HttpCode,
+  HttpStatus,
   Inject,
   Post,
   Req,
@@ -9,6 +11,7 @@ import {
 } from '@nestjs/common';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
 import { StageService } from '../service/stage.service';
+import { level } from 'winston';
 
 @Controller('/stage')
 @UseGuards(JwtAuthGuard)
@@ -30,4 +33,18 @@ export class StageController {
       level_type,
     );
   }
+
+  @Post('/getStagesWithGroupName')
+  @HttpCode(HttpStatus.OK)
+  async getStagesWithGroupName(
+    @Body('workflow_id') workflow_id: number,
+    @Req() req: Request & { user: any },
+  ) {
+    const { level_id, level_type } = req.user.userData;
+    return this.stageGroupService.getStagesWithGroupName(
+      workflow_id,
+      level_id,
+      level_type,
+    );
+  }
 }

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

@@ -17,7 +17,4 @@ export class Workflow extends BaseEntity {
 
   @Column({ type: 'boolean', nullable: true })
   is_factory: boolean;
-
-  @Column({ type: 'int', nullable: true })
-  sequence: number;
 }

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

@@ -31,7 +31,7 @@ export class StageGroupRepository {
         level_type,
       },
       order: {
-        sequence: 'ASC', // or 'DESC' if you want reverse order
+        sequence: 'ASC',
       },
     });
 

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

@@ -32,7 +32,7 @@ export class StageRepository {
         level_type,
       },
       order: {
-        sequence: 'ASC', // or 'DESC' if you want reverse order
+        sequence: 'ASC',
       },
     });
 

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

@@ -148,4 +148,25 @@ export class ActionService extends EntityServiceImpl {
 
     return action; // Return the action entity instead of actionData
   }
+
+  async deleteEntity(
+    entityType: string,
+    id: number,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    await this.dataSource.query(
+      `DELETE FROM cr_wf_action_template_mapping WHERE stg_act_mapping_id IN (SELECT
+        id FROM cr_wf_stage_action_mapping WHERE action_id = ? AND entity_type = 'STGM')`,
+      [id],
+    );
+
+    await this.dataSource.query(
+      `DELETE FROM cr_wf_stage_action_mapping WHERE action_id = ? AND entity_type ='STGM'`,
+      [id],
+    );
+
+    const deleteAction = await super.deleteEntity(entityType, id, loggedInUser);
+
+    return deleteAction;
+  }
 }

package/src/module/workflow/service/stage-group.service.ts

@@ -3,10 +3,15 @@ import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.s
 import { StageGroupRepository } from '../repository/stage-group.repository';
 import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
 import { UserData } from 'src/module/user/entity/user.entity';
+import { StageService } from './stage.service';
 
 @Injectable()
 export class StageGroupService extends EntityServiceImpl {
-  constructor(private readonly stageGroupRepository: StageGroupRepository) {
+  constructor(
+    private readonly stageGroupRepository: StageGroupRepository,
+    @Inject('StageService')
+    private readonly stageService: StageService,
+  ) {
     super();
   }
   async getAllStageGroup(
@@ -35,4 +40,30 @@ export class StageGroupService extends EntityServiceImpl {
   ): Promise<BaseEntity | null> {
     return await super.getEntityData(entityType, id, loggedInUser);
   }
+
+  async deleteEntity(
+    entityType: string,
+    id: number,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    const getAllStage = await this.stageService.getAllStage(
+      id,
+      loggedInUser.level_id,
+      loggedInUser.level_type,
+    );
+
+    if (getAllStage.length > 0) {
+      for (const stage of getAllStage) {
+        await this.stageService.deleteEntity('STG', stage.id, loggedInUser);
+      }
+    }
+
+    const deleteStageGroup = await super.deleteEntity(
+      entityType,
+      id,
+      loggedInUser,
+    );
+
+    return deleteStageGroup;
+  }
 }

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

@@ -1,12 +1,26 @@
-import { Injectable } from '@nestjs/common';
+import { ActionService } from './action.service';
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { StageRepository } from '../repository/stage.repository';
+import { DataSource } from 'typeorm';
+import { StageGroupRepository } from '../repository/stage-group.repository';
 
 @Injectable()
 export class StageService extends EntityServiceImpl {
-  constructor(private readonly stageRepository: StageRepository) {
+  constructor(
+    private readonly stageRepository: StageRepository,
+    private readonly stageGroupRepository: StageGroupRepository,
+    private readonly dataSource: DataSource,
+    @Inject('ActionService')
+    private readonly actionService: ActionService,
+  ) {
     super();
   }
   async getAllStage(
@@ -35,4 +49,75 @@ export class StageService extends EntityServiceImpl {
   ): Promise<BaseEntity | null> {
     return await super.getEntityData(entityType, id, loggedInUser);
   }
+
+  async deleteEntity(
+    entityType: string,
+    id: number,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    const getAllStageAction = await this.dataSource.query(
+      `SELECT action_id FROM cr_wf_stage_action_mapping WHERE stage_id = ? AND entity_type = 'STGM'`,
+      [id],
+    );
+
+    if (getAllStageAction.length > 0) {
+      for (const action of getAllStageAction) {
+        await this.actionService.deleteEntity(
+          'ACTN',
+          action.action_id,
+          loggedInUser,
+        );
+      }
+    }
+
+    const deleteStage = await super.deleteEntity(entityType, id, loggedInUser);
+
+    return deleteStage;
+  }
+
+  async getStagesWithGroupName(
+    workflow_id: number,
+    level_id: string,
+    level_type: string,
+  ) {
+    if (!workflow_id) {
+      throw new BadRequestException('workflow_id is required');
+    }
+
+    const stageGroups = await this.stageGroupRepository.getAllStageGroup(
+      workflow_id,
+      level_id,
+      level_type,
+    );
+
+    const stageGroupIds = stageGroups.map((group) => group.id);
+    const groupNameMap = new Map<number, string>(
+      stageGroups.map((group) => [Number(group.id), group.name]),
+    );
+
+    // Get all stages for all stageGroups
+    const allStages: any = [];
+    for (const groupId of stageGroupIds) {
+      try {
+        const stages = await this.stageRepository.getAllStage(
+          groupId,
+          level_id,
+          level_type,
+        );
+        allStages.push(...stages);
+      } catch (err) {
+        if (err instanceof NotFoundException) {
+          console.warn(`No stages for group ID ${groupId}`);
+          continue;
+        }
+        throw err;
+      }
+    }
+
+    const result = allStages.map((stage) => ({
+      stage_id: stage.id,
+      full_name: `${groupNameMap.get(stage.stage_group_id)} - ${stage.name}`,
+    }));
+    return result;
+  }
 }

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

@@ -8,6 +8,9 @@ import { ListMasterService } from 'src/module/listmaster/service/list-master.ser
 import { STATUS_INACTIVE, WORKFLOW } from 'src/constant/global.constant';
 import { Workflow } from '../entity/workflow.entity';
 
+import { StageGroupRepository } from '../repository/stage-group.repository';
+import { StageGroupService } from './stage-group.service';
+
 @Injectable()
 export class WorkflowService extends EntityServiceImpl {
   constructor(
@@ -15,6 +18,9 @@ export class WorkflowService extends EntityServiceImpl {
     private readonly workflowRepository: WorkflowRepository,
     @Inject('ListMasterService')
     private readonly listMasterService: ListMasterService,
+    @Inject('StageGroupService')
+    private readonly stateGroupService: StageGroupService,
+    private readonly stageGroupRepository: StageGroupRepository,
   ) {
     super();
   }
@@ -95,6 +101,36 @@ export class WorkflowService extends EntityServiceImpl {
     return this.workflowRepository.deleteWorkflowById(id);
   }
 
+  async deleteEntity(
+    entityType: string,
+    id: number,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    const getAllStage = await this.stageGroupRepository.getAllStageGroup(
+      id,
+      loggedInUser.level_id,
+      loggedInUser.level_type,
+    );
+
+    if (getAllStage.length > 0) {
+      for (const stage of getAllStage) {
+        await this.stateGroupService.deleteEntity(
+          'STGP',
+          stage.id,
+          loggedInUser,
+        );
+      }
+    }
+
+    const deleteWorkflow = await super.deleteEntity(
+      entityType,
+      id,
+      loggedInUser,
+    );
+
+    return deleteWorkflow;
+  }
+
   async updateSequence(body: any[], loggedInUser: any) {
     if (!Array.isArray(body) || body.length === 0) {
       throw new BadRequestException(