rez_core 2.1.138 → 2.1.139

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.1.138",
+  "version": "2.1.139",
   "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/stage-group.controller.ts

@@ -0,0 +1,10 @@
+import { Controller, Get, UseGuards } from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+
+@Controller('/stage-group')
+@UseGuards(JwtAuthGuard)
+export class StageGroupController {
+  constructor() {}
+  @Get('/getAllStageGroup')
+  async getAllStageGroup() {}
+}

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

@@ -10,6 +10,7 @@ import {
   Param,
   Put,
   Inject,
+  Delete,
 } from '@nestjs/common';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
 import { WorkflowService } from '../service/workflow.service';
@@ -23,18 +24,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 +44,9 @@ export class WorkflowController {
     return this.workflowService.getWorkflowById(id);
   }
 
-  @Post('/getContactDropdown')
+  @Delete('/deleteWorkflow/:id')
   @HttpCode(HttpStatus.OK)
-  async getLeadContactDropdown(@Body() body: { leadId: number; mode: string }) {
-    return this.workflowService.getLeadContactDropdown(body.leadId, body.mode);
+  async deleteWorkflow(@Param('id') id: number) {
+    return this.workflowService.deleteWorkflowById(id);
   }
 }

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

@@ -11,4 +11,10 @@ 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;
 }

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

@@ -1,29 +1,34 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { DataSource, In } from 'typeorm';
+import { WorkflowRepository } from '../repository/workflow.repository';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
 import { UserData } from 'src/module/user/entity/user.entity';
-import { BaseEntity, DataSource, Entity } from 'typeorm';
+import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
+import { STATUS_INACTIVE, WORKFLOW } from 'src/constant/global.constant';
+import { Workflow } from '../entity/workflow.entity';
 
 @Injectable()
 export class WorkflowService extends EntityServiceImpl {
-  constructor(private readonly dataSource: DataSource) {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly workflowRepository: WorkflowRepository,
+    @Inject('ListMasterService')
+    private readonly listMasterService: ListMasterService,
+  ) {
     super();
   }
 
-  async getAllWorkflow(entity_type: string, loggedInUser: any) {
-    const { level_id, level_type } = loggedInUser;
-
-    const workflows = await this.dataSource.query(
-      `
-      SELECT *
-      FROM cr_workflow
-      WHERE mapped_entity_type = ?
-        AND level_id = ?
-        AND level_type = ?
-      `,
-      [entity_type, level_id, level_type],
+  async getAllWorkflows(
+    entity_type: string,
+    level_id: string,
+    level_type: string,
+  ) {
+    return this.workflowRepository.getAllWorkflowsByFilters(
+      entity_type,
+      level_id,
+      level_type,
     );
-
-    return workflows; // array of rows (each row is already in JSON format)
   }
 
   async getWorkflowById(id: number) {
@@ -34,45 +39,59 @@ export class WorkflowService extends EntityServiceImpl {
     return result[0] || null;
   }
 
-  async getLeadContactDropdown(leadId: number, mode: string): Promise<any[]> {
-    const lead = await this.dataSource.query(
-      `SELECT phone_number, father_mobile, mother_mobile, email, father_email, mother_email
-     FROM crm_lead
-     WHERE id = ?`,
-      [leadId],
+  //update entity
+  async updateEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    const resolveStatus = await this.listMasterService.getResolvedListCode(
+      STATUS_INACTIVE,
+      loggedInUser?.organization_id || 0,
     );
 
-    if (!lead?.length) {
-      throw new BadRequestException('Lead not found');
-    }
+    const workflowId = entityData.id;
 
-    const data = lead[0];
-    const response: { label: string; value: any }[] = [];
+    // Handle INACTIVE status validation
+    if (entityData.status == resolveStatus.id) {
+      const existingWorkflow = (await this.getEntityData(
+        WORKFLOW,
+        workflowId,
+        loggedInUser,
+      )) as Workflow;
 
-    if (mode === 'sms' || mode === 'whatsapp') {
-      if (data.phone_number) {
-        response.push({ label: 'Primary', value: data.phone_number });
-      }
-      if (data.father_mobile) {
-        response.push({ label: 'Father', value: data.father_mobile });
-      }
-      if (data.mother_mobile) {
-        response.push({ label: 'Mother', value: data.mother_mobile });
-      }
-    } else if (mode === 'email') {
-      if (data.email) {
-        response.push({ label: 'Primary', value: data.email });
+      if (!existingWorkflow) {
+        return { success: false, error: 'Workflow not found' };
       }
-      if (data.father_email) {
-        response.push({ label: 'Father', value: data.father_email });
+
+      if (existingWorkflow.is_default) {
+        return {
+          success: false,
+          error: 'Cannot inactivate because it is default.',
+        };
       }
-      if (data.mother_email) {
-        response.push({ label: 'Mother', value: data.mother_email });
+
+      if (existingWorkflow.is_factory) {
+        return {
+          success: false,
+          error: 'Cannot inactivate because it is factory.',
+        };
       }
-    } else {
-      throw new BadRequestException('Invalid mode');
     }
 
-    return response;
+    // Handle is_default uniqueness logic
+    if ((entityData as Workflow).is_default == true) {
+      await this.dataSource
+        .createQueryBuilder()
+        .update(Workflow)
+        .set({ is_default: 0 })
+        .where('is_default = :isDefault', { isDefault: 1 })
+        .execute();
+    }
+    // Final update
+    return super.updateEntity(entityData, loggedInUser);
+  }
+
+  async deleteWorkflowById(id: number) {
+    return this.workflowRepository.deleteWorkflowById(id);
   }
 }

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

@@ -21,6 +21,9 @@ import { WorkflowListMasterService } from './service/workflow-list-master.servic
 import { WorkflowListMasterController } from './controller/workflow-list-master.controller';
 import { ActionTemplateMappingController } from './controller/action-template-mapping.controller';
 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';
 
 @Module({
   imports: [
@@ -35,6 +38,7 @@ import { WorkflowController } from './controller/workflow.controller';
       StageActionMapping,
     ]),
     EntityModule,
+    ListMasterModule,
   ],
   providers: [
     { provide: 'ActionCategoryService', useClass: ActionCategoryService },
@@ -49,6 +53,7 @@ import { WorkflowController } from './controller/workflow.controller';
     { provide: 'WorkflowService', useClass: WorkflowService },
     WorkflowListMasterService,
     ActionTemplateMappingService,
+    WorkflowRepository,
   ],
   exports: [
     'ActionCategoryService',
@@ -57,6 +62,7 @@ import { WorkflowController } from './controller/workflow.controller';
     'ActionService',
     'StageService',
     'StageGroupService',
+    WorkflowRepository,
   ],
   controllers: [
     WorkflowListMasterController,