rez_core 2.1.139 → 2.1.141

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

@@ -1,47 +1,123 @@
-import { Injectable } from '@nestjs/common';
-import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+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 { DataSource, EntityManager } from 'typeorm';
+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 dataSource: DataSource) {
+  constructor(
+    private readonly stageRepository: StageRepository,
+    private readonly stageGroupRepository: StageGroupRepository,
+    private readonly dataSource: DataSource,
+    @Inject('ActionService')
+    private readonly actionService: ActionService,
+  ) {
     super();
   }
+  async getAllStage(
+    stage_group_id: number,
+    level_id: string,
+    level_type: string,
+  ) {
+    return await this.stageRepository.getAllStage(
+      stage_group_id,
+      level_id,
+      level_type,
+    );
+  }
 
-  async createEntity(
+  async updateEntity(
     entityData: BaseEntity,
-    loggedInUser: UserData | null,
-    manager?: EntityManager | null,
-    appcode?: string,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    return await super.updateEntity(entityData, loggedInUser);
+  }
+
+  async getEntityData(
+    entityType: string,
+    id: number,
+    loggedInUser?: UserData,
+  ): Promise<BaseEntity | null> {
+    return await super.getEntityData(entityType, id, loggedInUser);
+  }
+
+  async deleteEntity(
+    entityType: string,
+    id: number,
+    loggedInUser: UserData,
   ): Promise<any> {
-    const stageData = entityData as any;
-
-    // Step 1: Get the stage_group name using stage_group_id
-    let stageGroupName = '';
-    if (stageData.stage_group_id) {
-      const result = await this.dataSource.query(
-        `SELECT name FROM cr_wf_stage_group WHERE id = ?`,
-        [stageData.stage_group_id],
-      );
-
-      if (result.length > 0) {
-        stageGroupName = result[0].name;
+    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,
+        );
       }
     }
 
-    if (stageGroupName && stageData.name) {
-      stageData.full_name = `${stageGroupName}-${stageData.name}`;
+    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 savedStage = await super.createEntity(
-      stageData,
-      loggedInUser,
-      manager,
-      appcode,
+    const stageGroups = await this.stageGroupRepository.getAllStageGroup(
+      workflow_id,
+      level_id,
+      level_type,
     );
 
-    return savedStage;
+    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();
   }
@@ -94,4 +100,68 @@ export class WorkflowService extends EntityServiceImpl {
   async deleteWorkflowById(id: number) {
     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(
+        'Invalid input. Expected a non-empty array.',
+      );
+    }
+
+    const results: {
+      id: any;
+      success: boolean;
+      result?: any;
+      error?: string;
+    }[] = [];
+
+    for (const item of body) {
+      if (!item.id || item.sequence === undefined) {
+        results.push({
+          id: item.id || null,
+          success: false,
+          error: 'Missing id or sequence',
+        });
+        continue;
+      }
+
+      try {
+        const result = await super.updateEntity(item, loggedInUser);
+        results.push({ id: item.id, success: true, result });
+      } catch (err) {
+        results.push({ id: item.id, success: false, error: err.message });
+      }
+    }
+    return { updated: results.filter((r) => r.success).length, results };
+  }
 }

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

@@ -16,7 +16,6 @@ import { StageService } from './service/stage.service';
 import { StageGroupService } from './service/stage-group.service';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { EntityModule } from '../meta/entity.module';
-import { Action } from './entity/action.entity';
 import { WorkflowListMasterService } from './service/workflow-list-master.service';
 import { WorkflowListMasterController } from './controller/workflow-list-master.controller';
 import { ActionTemplateMappingController } from './controller/action-template-mapping.controller';
@@ -24,12 +23,19 @@ import { WorkflowController } from './controller/workflow.controller';
 import { WorkflowRepository } from './repository/workflow.repository';
 import { ListMasterService } from '../listmaster/service/list-master.service';
 import { ListMasterModule } from '../listmaster/listmaster.module';
+import { CommTemplateController } from './controller/comm-template.controller';
+import { CommTemplateRepository } from './repository/comm-template.repository';
+import { ActionEntity } from './entity/action.entity';
+import { StageGroupRepository } from './repository/stage-group.repository';
+import { StageGroupController } from './controller/stage-group.controller';
+import { StageController } from './controller/stage.controller';
+import { StageRepository } from './repository/stage.repository';
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([
       Workflow,
-      Action,
+      ActionEntity,
       ActionCategory,
       Stage,
       StageGroup,
@@ -54,6 +60,10 @@ import { ListMasterModule } from '../listmaster/listmaster.module';
     WorkflowListMasterService,
     ActionTemplateMappingService,
     WorkflowRepository,
+    CommTemplateService,
+    CommTemplateRepository,
+    StageGroupRepository,
+    StageRepository,
   ],
   exports: [
     'ActionCategoryService',
@@ -63,11 +73,16 @@ import { ListMasterModule } from '../listmaster/listmaster.module';
     'StageService',
     'StageGroupService',
     WorkflowRepository,
+    StageGroupRepository,
+    StageRepository,
   ],
   controllers: [
     WorkflowListMasterController,
     ActionTemplateMappingController,
     WorkflowController,
+    CommTemplateController,
+    StageGroupController,
+    StageController,
   ],
 })
 export class WorkflowModule {}