rez_core 2.1.138 → 2.1.140

package/package.json

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

package/src/module/filter/controller/filter.controller.ts

@@ -26,11 +26,16 @@ export class FilterController {
   @UseGuards(JwtAuthGuard)
   async applyFilter(
     @Body() body: any,
-    @Query('page', ParseIntPipe) page: number = 1,
-    @Query('size', ParseIntPipe) size: number = 10,
+    @Query('page', ParseIntPipe) page = 1,
+    @Query('size', ParseIntPipe) size = 10,
     @Req() req: Request & { user: any },
+    @Query() queryParams: Record<string, string>,
   ) {
-    const userData = req.user.userData;
+    const loggedInUser = req.user.userData;
+
+    // Remove page and size from queryParams
+    const { page: _p, size: _s, ...otherQueryParams } = queryParams;
+
     const {
       entity_type,
       quickFilter,
@@ -49,7 +54,8 @@ export class FilterController {
       sortby,
       page,
       size,
-      loggedInUser: userData,
+      loggedInUser,
+      queryParams: otherQueryParams, // only remaining query params
     });
   }
 

package/src/module/filter/dto/filter-request.dto.ts

@@ -26,4 +26,5 @@ export interface FilterRequestDto {
   page?: number;
   size?: number;
   loggedInUser: UserData;
+  queryParams?: Record<string, string>;
 }

package/src/module/filter/service/filter.service.ts

@@ -78,8 +78,10 @@ export class FilterService {
       tabs,
       sortby,
       loggedInUser,
+      queryParams,
     } = dto;
 
+    // abstract user details
     const {
       level_type,
       level_id,
@@ -88,15 +90,18 @@ export class FilterService {
       organization_id,
     } = loggedInUser || {};
 
-    // Fetch meta
+    // Fetch meta from entity table service
     const entityMeta = await this.entityTableService.getEntityData(
       entity_type,
       loggedInUser,
     );
     const tableName = entityMeta?.data_source; // data_souce is the table name
-    if (!tableName)
+
+    if (!tableName) {
       throw new BadRequestException(`Invalid entity_type: ${entity_type}`);
+    }
 
+    // get table meta from cr_entity_table
     const getTableMeta =
       await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
         entity_type,
@@ -110,6 +115,7 @@ export class FilterService {
         `Table meta not found for entity_type: ${entity_type}`,
       );
     }
+
     const getTableColumnMeta =
       await this.entityTableColumnService.findByParentIdAndParentType(
         getTableMeta.id,
@@ -153,6 +159,32 @@ export class FilterService {
       });
     }
 
+    // andWhere search with attributeName && attributeValue
+    if (queryParams) {
+      Object.entries(queryParams).forEach(([key, value]) => {
+        if (!value) return;
+
+        // Handle custom attributeName/attributeValue
+        if (key === 'attributeName' && queryParams['attributeValue']) {
+          const attrName = value;
+          const attrValue = queryParams['attributeValue'];
+
+          baseWhere.push({
+            query: `e.${attrName} = :${attrName}`,
+            params: { [attrName]: attrValue },
+          });
+        }
+
+        // Ignore attributeValue itself from being added again
+        else if (key !== 'attributeValue') {
+          baseWhere.push({
+            query: `e.${key} = :${key}`,
+            params: { [key]: value },
+          });
+        }
+      });
+    }
+
     // if (!this.skipAppCodeFilterEntities.includes(entity_type)) {
     //   baseWhere.push({
     //     query: 'e.appcode = :appcode',

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

@@ -0,0 +1,33 @@
+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(
+    @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,33 @@
+import {
+  Body,
+  Controller,
+  Get,
+  Inject,
+  Post,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { StageService } from '../service/stage.service';
+
+@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,
+    );
+  }
+}

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

@@ -10,10 +10,10 @@ import {
   Param,
   Put,
   Inject,
+  Delete,
 } 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)
@@ -23,18 +23,18 @@ export class WorkflowController {
     private readonly workflowService: WorkflowService,
   ) {}
 
-  @Post('/getWorkflow')
+  @Post('/getAllWorkflows')
   @HttpCode(HttpStatus.OK)
-  async getWorkflow(
-    @Body() body: { entity_type: string },
+  async getAllWorkflows(
     @Req() req: Request & { user: any },
+    @Body() body: { entity_type: string },
   ) {
-    const loggedInUser = req.user.userData;
-    const result = await this.workflowService.getAllWorkflow(
+    const { level_id, level_type } = req.user.userData;
+    return this.workflowService.getAllWorkflows(
       body.entity_type,
-      loggedInUser,
+      level_id,
+      level_type,
     );
-    return result;
   }
 
   @Get('/getWorkflowById/:id')
@@ -43,9 +43,16 @@ export class WorkflowController {
     return this.workflowService.getWorkflowById(id);
   }
 
-  @Post('/getContactDropdown')
+  @Delete('/deleteWorkflow/:id')
+  @HttpCode(HttpStatus.OK)
+  async deleteWorkflow(@Param('id') id: number) {
+    return this.workflowService.deleteWorkflowById(id);
+  }
+
+  @Put('/updateSequence')
   @HttpCode(HttpStatus.OK)
-  async getLeadContactDropdown(@Body() body: { leadId: number; mode: string }) {
-    return this.workflowService.getLeadContactDropdown(body.leadId, body.mode);
+  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/entity/workflow.entity.ts

@@ -11,4 +11,13 @@ export class Workflow extends BaseEntity {
 
   @Column({ type: 'varchar', nullable: true })
   mapped_entity_type: string;
+
+  @Column({ type: 'boolean', nullable: true })
+  is_default: boolean;
+
+  @Column({ type: 'boolean', nullable: true })
+  is_factory: boolean;
+
+  @Column({ type: 'int', nullable: true })
+  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', // or 'DESC' if you want reverse order
+      },
+    });
+
+    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', // or 'DESC' if you want reverse order
+      },
+    });
+
+    if (!result || result.length === 0) {
+      throw new NotFoundException(
+        'No stage found for the given stage group ID',
+      );
+    }
+
+    return result;
+  }
+}

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

@@ -1,4 +1,42 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Workflow } from '../entity/workflow.entity';
+import { Repository } from 'typeorm';
 
 @Injectable()
-export class WorkflowRepsository {}
+export class WorkflowRepository {
+  constructor(
+    @InjectRepository(Workflow)
+    private readonly workflowRepository: Repository<Workflow>,
+  ) {}
+
+  // async getWorkflowById(id: number) {
+  //     return this.workflowRepository.findOne(id);
+  // }
+
+  async getAllWorkflowsByFilters(
+    entity_type: string,
+    level_id: string,
+    level_type: string,
+  ): Promise<Workflow[]> {
+    return this.workflowRepository.find({
+      where: {
+        mapped_entity_type: entity_type,
+        level_id,
+        level_type,
+      },
+    });
+  }
+
+  async deleteWorkflowById(id: number) {
+    const result = await this.workflowRepository.delete(id);
+
+    if (result.affected === 0) {
+      throw new NotFoundException(`Workflow with ID ${id} not found`);
+    }
+
+    return {
+      message: `Workflow has been successfully deleted.`,
+    };
+  }
+}

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,66 @@ 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
+  }
 }

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;
+  }
+}