rez_core 2.1.139 → 2.1.141

package/package.json

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

package/src/module/workflow/controller/comm-template.controller.ts

@@ -0,0 +1,31 @@
+import {
+  Controller,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { CommTemplateService } from '../service/comm-template.service';
+
+@Controller('/templates')
+@UseGuards(JwtAuthGuard)
+export class CommTemplateController {
+  constructor(private readonly commTemplateService: CommTemplateService) {}
+
+  @Get('/get-comm-template')
+  @HttpCode(HttpStatus.OK)
+  async getTemplate(
+    @Req() req: Request & { user: any },
+    @Query('entity_type') entityType?: string,
+  ) {
+    const loggedInUser = req.user.userData;
+    const result = this.commTemplateService.getAllCommTemplate(
+      entityType || '',
+      loggedInUser,
+    );
+    return result;
+  }
+}

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

@@ -1,10 +1,33 @@
-import { Controller, Get, UseGuards } from '@nestjs/common';
+import {
+  Body,
+  Controller,
+  Get,
+  Inject,
+  Post,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { StageGroupService } from '../service/stage-group.service';
 
 @Controller('/stage-group')
 @UseGuards(JwtAuthGuard)
 export class StageGroupController {
-  constructor() {}
-  @Get('/getAllStageGroup')
-  async getAllStageGroup() {}
+  constructor(
+    @Inject('StageGroupService')
+    private readonly stageGroupService: StageGroupService,
+  ) {}
+
+  @Post('/getAllStageGroup')
+  async getAllStageGroup(
+    @Req() req: Request & { user: any },
+    @Body() body: { workflow_id: number },
+  ) {
+    const { level_id, level_type } = req.user.userData;
+    return this.stageGroupService.getAllStageGroup(
+      body.workflow_id,
+      level_id,
+      level_type,
+    );
+  }
 }

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

@@ -0,0 +1,50 @@
+import {
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Post,
+  Req,
+  UseGuards,
+} 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)
+export class StageController {
+  constructor(
+    @Inject('StageService')
+    private readonly stageGroupService: StageService,
+  ) {}
+
+  @Post('/getAllStage')
+  async getAllStage(
+    @Req() req: Request & { user: any },
+    @Body() body: { stage_group_id: number },
+  ) {
+    const { level_id, level_type } = req.user.userData;
+    return this.stageGroupService.getAllStage(
+      body.stage_group_id,
+      level_id,
+      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/controller/workflow.controller.ts

@@ -14,7 +14,6 @@ import {
 } from '@nestjs/common';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
 import { WorkflowService } from '../service/workflow.service';
-import { Request } from 'express';
 
 @Controller('/workflow')
 @UseGuards(JwtAuthGuard)
@@ -49,4 +48,11 @@ export class WorkflowController {
   async deleteWorkflow(@Param('id') id: number) {
     return this.workflowService.deleteWorkflowById(id);
   }
+
+  @Put('/updateSequence')
+  @HttpCode(HttpStatus.OK)
+  async updateSequence(@Body() body: any, @Req() req: Request & { user: any }) {
+    const loggedInUser = req.user?.userData;
+    return this.workflowService.updateSequence(body, loggedInUser);
+  }
 }

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

@@ -3,7 +3,7 @@ import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
 import { Column, Entity } from 'typeorm';
 
 @Entity({ name: 'cr_wf_action' })
-export class Action extends BaseEntity {
+export class ActionEntity extends BaseEntity {
   constructor() {
     super();
     this.entity_type = ACTION;
@@ -17,4 +17,13 @@ export class Action extends BaseEntity {
 
   @Column({ type: 'varchar', nullable: true })
   action_requirement: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  reason_code: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  default_reason_code: string;
+
+  @Column({ default: 0, type: 'boolean' })
+  default_value: boolean;
 }

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

@@ -13,5 +13,5 @@ export class StageGroup extends BaseEntity {
   workflow_id: number;
 
   @Column({ type: 'int', nullable: true })
-  sortindex: number;
+  sequence: number;
 }

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

@@ -12,9 +12,6 @@ export class Stage extends BaseEntity {
   @Column({ type: 'int', nullable: true })
   stage_group_id: number;
 
-  @Column({ type: 'varchar', length: 100, nullable: true })
-  full_name: string;
-
   @Column({ type: 'int', nullable: true })
-  sortindex: number;
+  sequence: number;
 }

package/src/module/workflow/repository/comm-template.repository.ts

@@ -0,0 +1,22 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Workflow } from '../entity/workflow.entity';
+import { Repository } from 'typeorm';
+import { CommTemplate } from '../entity/comm-template.entity';
+
+@Injectable()
+export class CommTemplateRepository {
+  constructor(
+    @InjectRepository(CommTemplate)
+    private readonly commTemplateRepository: Repository<CommTemplate>,
+  ) {}
+
+  async getAllCommTemplate(entity_type: string, loggedInUser) {
+    return this.commTemplateRepository.find({
+      select: ['name', 'code'],
+      where: {
+        entity_type: entity_type,
+      },
+    });
+  }
+}

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

@@ -0,0 +1,46 @@
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { StageGroup } from '../entity/stage-group.entity';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class StageGroupRepository {
+  constructor(
+    @InjectRepository(StageGroup)
+    private readonly stageGroupRepository: Repository<StageGroup>,
+  ) {}
+
+  async getAllStageGroup(
+    workflow_id: number,
+    level_id: string,
+    level_type: string,
+  ) {
+    if (!workflow_id) {
+      throw new BadRequestException('workflow_id is required');
+    }
+
+    const result = await this.stageGroupRepository.find({
+      where: {
+        workflow_id,
+        level_id,
+        level_type,
+      },
+      order: {
+        sequence: 'ASC',
+      },
+    });
+
+    if (!result || result.length === 0) {
+      throw new NotFoundException(
+        'No stage groups found for the given workflow ID',
+      );
+    }
+
+    return result;
+  }
+}

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

@@ -0,0 +1,47 @@
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { StageGroup } from '../entity/stage-group.entity';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Stage } from '../entity/stage.entity';
+
+@Injectable()
+export class StageRepository {
+  constructor(
+    @InjectRepository(Stage)
+    private readonly stageRepository: Repository<Stage>,
+  ) {}
+
+  async getAllStage(
+    stage_group_id: number,
+    level_id: string,
+    level_type: string,
+  ) {
+    if (!stage_group_id) {
+      throw new BadRequestException('stage_group_id is required');
+    }
+
+    const result = await this.stageRepository.find({
+      where: {
+        stage_group_id,
+        level_id,
+        level_type,
+      },
+      order: {
+        sequence: 'ASC',
+      },
+    });
+
+    if (!result || result.length === 0) {
+      throw new NotFoundException(
+        'No stage found for the given stage group ID',
+      );
+    }
+
+    return result;
+  }
+}

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

@@ -3,6 +3,7 @@ import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { DataSource, EntityManager } from 'typeorm';
+import { ActionEntity } from '../entity/action.entity';
 
 @Injectable()
 export class ActionService extends EntityServiceImpl {
@@ -10,6 +11,26 @@ export class ActionService extends EntityServiceImpl {
     super();
   }
 
+  async getEntityData(
+    entityType: string,
+    id: number,
+    loggedInUser,
+  ): Promise<any> {
+    const actionData = await super.getEntityData(entityType, id, loggedInUser);
+
+    if (!actionData) {
+      return null;
+    }
+
+    const template = await this.dataSource.query(
+      `SELECT template_code FROM cr_wf_action_template_mapping WHERE stg_act_mapping_id =
+        (SELECT id FROM cr_wf_stage_action_mapping WHERE action_id = ? AND entity_type = 'STGM')`,
+      [actionData.id],
+    );
+
+    return { ...actionData, template: template.map((t) => t.template_code) };
+  }
+
   async createEntity(
     entityData: BaseEntity,
     loggedInUser: UserData | null,
@@ -27,6 +48,7 @@ export class ActionService extends EntityServiceImpl {
       appcode,
     );
 
+    // stage mapping
     let stageActionMapping = {
       action_id: action.id,
       stage_id: actionData.stage_id,
@@ -44,20 +66,7 @@ export class ActionService extends EntityServiceImpl {
       const templates = actionData.template;
 
       for (let i = 0; i < templates.length; i++) {
-        const templateId = templates[i];
-
-        // Fetch the template code from `cr_wf_comm_template`
-        const templateResult = await this.dataSource.query(
-          `SELECT code FROM cr_wf_comm_template WHERE id = ?`,
-          [templateId],
-        );
-
-        if (templateResult.length === 0) {
-          console.warn(`Template not found for id: ${templateId}`);
-          continue;
-        }
-
-        const templateCode = templateResult[0].code;
+        const templateCode = templates[i];
 
         // Create Action-Template Mapping
         const actionTemplateMapping = {
@@ -77,4 +86,87 @@ export class ActionService extends EntityServiceImpl {
 
     return actionData;
   }
+
+  async updateEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    console.log('entityData', entityData);
+
+    // Extract template from entityData, keep the rest for ActionEntity
+    const { template, stage_id, ...actionData } = entityData as ActionEntity & {
+      template?: number[];
+      stage_id?: string;
+    };
+
+    // Pass only actionData (without template) to super.updateEntity
+    let action = await super.updateEntity(actionData, loggedInUser);
+
+    if (!action) {
+      throw new Error('Action not found or could not be updated');
+    }
+
+    const stageMapID = await this.dataSource.query(
+      `SELECT id FROM cr_wf_stage_action_mapping WHERE action_id = ? AND entity_type = 'STGM'`,
+      [action.id],
+    );
+
+    // stage mapping
+    let stageActionMapping = {
+      action_id: action.id,
+      stage_id: stage_id,
+      entity_type: 'STGM',
+      id: stageMapID.length > 0 ? stageMapID[0].id : null,
+    } as any;
+
+    let stageActionMappingData = await super.updateEntity(
+      stageActionMapping,
+      loggedInUser,
+    );
+
+    // Handle template mapping (using the extracted template)
+    if (Array.isArray(template) && template.length > 0) {
+      for (let i = 0; i < template.length; i++) {
+        const templateCode = template[i];
+
+        // delete existing template mappings for this action
+        await this.dataSource.query(
+          `DELETE FROM cr_wf_action_template_mapping WHERE stg_act_mapping_id = ? AND template_code = ?`,
+          [stageActionMappingData.id, templateCode],
+        );
+
+        // Create Action-Template Mapping
+        const actionTemplateMapping = {
+          stg_act_mapping_id: stageActionMappingData.id,
+          template_code: templateCode,
+          entity_type: 'ATMP',
+        } as any;
+
+        await super.createEntity(actionTemplateMapping, loggedInUser);
+      }
+    }
+
+    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/comm-template.service.ts

@@ -1,5 +1,24 @@
 import { Injectable } from '@nestjs/common';
-import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { CommTemplateRepository } from '../repository/comm-template.repository';
 
 @Injectable()
-export class CommTemplateService extends EntityServiceImpl {}
+export class CommTemplateService {
+  constructor(
+    private readonly commTemplateRepository: CommTemplateRepository,
+  ) {}
+
+  async getAllCommTemplate(entity_type: string, loggedInUser) {
+    const commTemplateData =
+      await this.commTemplateRepository.getAllCommTemplate(
+        entity_type,
+        loggedInUser,
+      );
+
+    const response = commTemplateData.map((item) => ({
+      label: item.name,
+      value: item.code,
+    }));
+
+    return response;
+  }
+}

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

@@ -1,5 +1,69 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+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 {}
+export class StageGroupService extends EntityServiceImpl {
+  constructor(
+    private readonly stageGroupRepository: StageGroupRepository,
+    @Inject('StageService')
+    private readonly stageService: StageService,
+  ) {
+    super();
+  }
+  async getAllStageGroup(
+    workflow_id: number,
+    level_id: string,
+    level_type: string,
+  ) {
+    return await this.stageGroupRepository.getAllStageGroup(
+      workflow_id,
+      level_id,
+      level_type,
+    );
+  }
+
+  async updateEntity(
+    entityData: BaseEntity,
+    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 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;
+  }
+}