rez_core 2.2.49 → 2.2.53

package/package.json

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

package/src/module/meta/controller/view-master.controller.ts

@@ -1,48 +1,76 @@
 import {
-    Controller,
-    Get,
-    Query,
-    Res,
-    HttpStatus,
-    UseGuards,
-    Inject,
-  } from '@nestjs/common';
-  import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
-  import { Response } from 'express';
+  Controller,
+  Get,
+  Query,
+  Res,
+  HttpStatus,
+  UseGuards,
+  Inject,
+  Req,
+} from '@nestjs/common';
+import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
+import { Response } from 'express';
 import { ViewMasterService } from '../service/view-master.service';
-  
-  @Controller('entity')
-  @UseGuards(JwtAuthGuard)
-  export class ViewMasterController {
-    constructor(@Inject("ViewMasterService") private  readonly viewMaster: ViewMasterService) {}
-  
-    @Get('viewMaster')
-    async getEntityJsonByType(
-      @Query('entity_type') entityType: string,
-      @Query('type') type:string,
-      @Res() res: Response,
-    ) {
-      try {
-        if (!entityType || !type) {
-          return res.status(HttpStatus.BAD_REQUEST).json({
-            success: false,
-            message: 'Missing entity_type or type query parameter',
-          });
-        }
-  
-        const result = await this.viewMaster.getEntityJson(entityType, type);
-  
-        return res.status(HttpStatus.OK).json({
-          success: true,
-          message: 'Entity data fetched successfully',
-          data: result,
-        });
-      } catch (error) {
-        return res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
+
+@Controller('entity')
+@UseGuards(JwtAuthGuard)
+export class ViewMasterController {
+  constructor(
+    @Inject('ViewMasterService') private readonly viewMaster: ViewMasterService,
+  ) {}
+
+  @Get('viewMaster')
+  async getEntityJsonByType(
+    @Query('entity_type') entityType: string,
+    @Query('type') type: string,
+    @Res() res: Response,
+  ) {
+    try {
+      if (!entityType || !type) {
+        return res.status(HttpStatus.BAD_REQUEST).json({
           success: false,
-          message: error.message || 'Error fetching entity data',
+          message: 'Missing entity_type or type query parameter',
         });
       }
+
+      const result = await this.viewMaster.getEntityJson(entityType, type);
+
+      return res.status(HttpStatus.OK).json({
+        success: true,
+        message: 'Entity data fetched successfully',
+        data: result,
+      });
+    } catch (error) {
+      return res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
+        success: false,
+        message: error.message || 'Error fetching entity data',
+      });
+    }
+  }
+
+  @Get('view_master/dropdown')
+  async getDropdownData(
+    @Req() req: Request & { user: any },
+    @Query() query: Record<string, string>,
+    @Res() res: Response,
+  ) {
+    const loggedInUser = req.user.userData;
+
+    const entityType = query.entity_type;
+    if (!entityType) {
+      return res.status(HttpStatus.BAD_REQUEST).json({
+        success: false,
+        message: 'Missing entity_type query parameter',
+      });
     }
+
+    const result = await this.viewMaster.getViewMasterByEntityType(
+      entityType,
+      loggedInUser,
+    );
+
+    return res.status(HttpStatus.OK).json({
+      data: result,
+    });
   }
-  
+}

package/src/module/meta/repository/view-master.repository.ts

@@ -18,7 +18,21 @@ export class ViewMaterRespository {
       mapped_entity_type: entityType,
       type: type,
     });
-  
+
     return viewMaster;
   }
+
+  async findByEntityType(entityType: string, organizationId: number) {
+    const viewMasters = await this.viewMasterRepository.find({
+      where: {
+        mapped_entity_type: entityType,
+        organization_id: organizationId,
+      },
+    });
+
+    return viewMasters.map((vm) => ({
+      label: vm.name,
+      value: vm.id,
+    }));
+  }
 }

package/src/module/meta/service/view-master.service.ts

@@ -73,4 +73,11 @@ export class ViewMasterService extends EntityServiceImpl {
   ) {
     return await super.getEntityData(entityType, id, loggedInUserData);
   }
+
+  async getViewMasterByEntityType(entityType: string, loggedInUser: UserData) {
+    return await this.viewMasterRepoService.findByEntityType(
+      entityType,
+      loggedInUser.organization_id,
+    );
+  }
 }

package/src/module/notification/controller/otp.controller.ts

@@ -44,14 +44,15 @@ export class OtpController {
   @Post('verify')
   @HttpCode(HttpStatus.OK)
   async verifyOtp(@Body() request: any) {
-    let otp = request.otp;
-    let otpId = request.otp_id;
-
-    let verify = await this.otpService.verifyOtp(otp, otpId);
-    if (!verify) {
+    let verify = await this.otpService.verifyOtp(request);
+    if (!verify.isValid) {
       throw new BadRequestException('Invalid OTP!');
     }
-    return { message: 'OTP verified successfully!', success: true };
+    return {
+      message: 'OTP verified successfully!',
+      success: true,
+      data: verify,
+    };
   }
 
   @Post('send-mail')

package/src/module/notification/notification.module.ts

@@ -1,4 +1,4 @@
-import { Module } from '@nestjs/common';
+import { forwardRef, Module } from '@nestjs/common';
 import { OtpService } from './service/otp.service';
 import { OtpRepository } from './repository/otp.repository';
 import { TypeOrmModule } from '@nestjs/typeorm';
@@ -9,6 +9,7 @@ import { HandlebarsAdapter } from '@nestjs-modules/mailer/dist/adapters/handleba
 import { EmailService } from './service/email.service';
 import { join } from 'path';
 import { ConfigModule, ConfigService } from '@nestjs/config';
+import { AuthModule } from '../auth/auth.module';
 
 @Module({
   imports: [
@@ -38,6 +39,7 @@ import { ConfigModule, ConfigService } from '@nestjs/config';
         },
       }),
     }),
+    AuthModule,
   ],
   providers: [OtpService, OtpRepository, EmailService],
   exports: [OtpService, EmailService],

package/src/module/notification/service/otp.service.ts

@@ -3,6 +3,8 @@ import { OtpRepository } from '../repository/otp.repository';
 import { Otp } from '../entity/otp.entity';
 import { ClockIDGenService } from '../../../utils/service/clockIDGenUtil.service';
 import { ConfigService } from '@nestjs/config';
+import { DataSource } from 'typeorm';
+import { JwtAuthService } from 'src/module/auth/services/jwt.service';
 
 @Injectable()
 export class OtpService {
@@ -10,19 +12,28 @@ export class OtpService {
     private readonly otpRepository: OtpRepository,
     private readonly idGen: ClockIDGenService,
     private configService: ConfigService,
-  ) {
-  }
-  
+    // @Inject('JwtAuthService')
+    private readonly jwtAuthService: JwtAuthService,
+    private databaseSource: DataSource,
+  ) {}
+
   VERIFY_OTP = this.configService.get('VERIFY_OTP') || 'true';
   DEFAULT_OTP = this.configService.get('DEFAULT_OTP') || '123456';
 
-
-  async generate(identifier: string, service: string, expiresIn: number = 5, otpLength: number = 6) {
+  async generate(
+    identifier: string,
+    service: string,
+    expiresIn: number = 5,
+    otpLength: number = 6,
+  ) {
     let otp = new Otp();
     otp.created_date = new Date();
     otp.otp_id = this.idGen.idGenerator();
     otp.identifier = identifier;
-    otp.otp = 'true' === this.VERIFY_OTP ? this.generateOtp(otpLength) : this.DEFAULT_OTP;
+    otp.otp =
+      'true' === this.VERIFY_OTP
+        ? this.generateOtp(otpLength)
+        : this.DEFAULT_OTP;
     otp.service = service;
     otp.verified = 0;
     otp.expiration_date = new Date(Date.now() + expiresIn * 60 * 1000);
@@ -30,18 +41,53 @@ export class OtpService {
     return await this.otpRepository.save(otp);
   }
 
-  async verifyOtp(otp: string, otpId: string) {
+  async verifyOtp(request) {
+    let verifyOTPResponse = { isValid: false, access_token: '' };
+
+    let otp = request.otp;
+    let otpId = request.otp_id;
+
     let otpEntity = await this.findByOtpId(otpId);
+
     if (otpEntity) {
-      if (otpEntity.otp === otp && new Date(Date.now()) <= otpEntity.expiration_date && 0 === otpEntity.verified) {
+      if (
+        otpEntity.otp === otp &&
+        new Date(Date.now()) <= otpEntity.expiration_date &&
+        0 === otpEntity.verified
+      ) {
         otpEntity.verified = 1;
-        const updatedOtp = await this.otpRepository.update(otpEntity.id, otpEntity);
+        const updatedOtp = await this.otpRepository.update(
+          otpEntity.id,
+          otpEntity,
+        );
         if (updatedOtp) {
-          return true;
+          verifyOTPResponse.isValid = true;
         }
       }
     }
-    return false;
+
+    if (verifyOTPResponse.isValid && request.entity) {
+      const entity_type = request.entity.entity_type;
+      const entity_id = request.entity.entity_id;
+
+      const entityData = await this.databaseSource.query(
+        `SELECT level_id, level_type, organization_id FROM ether_core.crm_lead where id = ${entity_id}`,
+      );
+
+      if (entityData.length > 0) {
+        const level_id = entityData[0].level_id;
+        const level_type = entityData[0].level_type;
+        const organization_id = entityData[0].organization_id;
+
+        verifyOTPResponse.access_token = await this.jwtAuthService.generateJwt({
+          level_id: level_id,
+          level_type: level_type,
+          organization_id: organization_id,
+        });
+      }
+    }
+
+    return verifyOTPResponse;
   }
 
   async findByOtpId(otpId: string) {

package/src/module/workflow/controller/activity-log.controller.ts

@@ -0,0 +1,35 @@
+import {
+  Body,
+  Controller,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Post,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { ActivityLogService } from '../service/activity-log.service';
+import { Http } from 'winston/lib/winston/transports';
+
+@Controller('/activity-log')
+@UseGuards(JwtAuthGuard)
+export class ActivityLogController {
+  constructor(
+    @Inject('ActivityLogService')
+    private readonly activityLogService: ActivityLogService,
+  ) {}
+  @Post('/get-all-activity-log')
+  @HttpCode(HttpStatus.OK)
+  async getAllActivityLog(
+    @Req() req: Request & { user: any },
+    @Body('entity_type') mapped_entity_type: string,
+  ) {
+    const loggedInUser = req.user.userData;
+    const result = this.activityLogService.getAllActivityLog(
+      mapped_entity_type,
+      loggedInUser,
+    );
+    return result;
+  }
+}

package/src/module/workflow/controller/form-master.controller.ts

@@ -32,4 +32,12 @@ export class FormMasterController {
     );
     return result;
   }
+
+  @Post('/submit')
+  @HttpCode(HttpStatus.OK)
+  async submitForm(@Req() req: Request & { user: any }, @Body() body: any) {
+    const loggedInUser = req.user.userData;
+    const result = this.formMasterService.submitForm(body);
+    return result;
+  }
 }

package/src/module/workflow/entity/action-resources-mapping.entity.ts

@@ -23,4 +23,7 @@ export class ActionResourcesMapping extends BaseEntity {
 
   @Column({ type: 'int', nullable: true })
   stg_act_mapping_id: number;
+
+  @Column({ type: 'varchar', nullable: true })
+  form_entity_type: string;
 }

package/src/module/workflow/entity/activity-log.entity.ts

@@ -0,0 +1,55 @@
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'eth_activity_log' })
+export class ActivityLog extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = 'ACLG';
+  }
+
+  @Column({ type: 'varchar', nullable: true })
+  running_id: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  mapped_entity_type: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  mapped_entity_id: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  title: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  description: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  user_id: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  level_type: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  level_id: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  category: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  action: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  action_icon: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  action_category_color: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  additional_info_1: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  additional_info_2: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  additional_info_3: string;
+}

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

@@ -0,0 +1,25 @@
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_wf_form' })
+export class FormDataEntity extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = 'FORM';
+  }
+
+  @Column({ nullable: true })
+  mapped_entity_id: number;
+
+  @Column({ nullable: true })
+  mapped_entity_type: string;
+
+  @Column({ nullable: true })
+  view_id: number;
+
+  @Column({ nullable: true })
+  entity_id: number;
+
+  @Column({ nullable: true })
+  action_id: number;
+}

package/src/module/workflow/repository/action-data.repository.ts

@@ -1,8 +1,9 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { ActionDataEntity } from '../entity/action-data.entity';
 import { DataSource, Repository } from 'typeorm';
 import { UserData } from 'src/module/user/entity/user.entity';
+import { FormDataEntity } from '../entity/form.entity';
 
 @Injectable()
 export class ActionDataRepository {
@@ -10,6 +11,8 @@ export class ActionDataRepository {
     @InjectRepository(ActionDataEntity)
     private readonly actionDataRepo: Repository<ActionDataEntity>,
     private readonly dataSource: DataSource,
+    @InjectRepository(FormDataEntity)
+    private readonly formRepo: Repository<FormDataEntity>,
   ) {}
 
   async saveActionData(
@@ -43,6 +46,20 @@ export class ActionDataRepository {
           category: act?.action_category_code,
         } as ActionDataEntity);
         await this.actionDataRepo.save(actionData);
+
+        // SEND FORM related logic
+        // if the action_category_code is 'SDFM', create a entry in cr_wf_form table
+        if (act?.action_category_code === 'SDFM') {
+          this.formRepo.insert({
+            mapped_entity_type,
+            mapped_entity_id,
+            entity_type: mapped_entity_type,
+            entity_id: mapped_entity_id,
+            view_id: act.form_id,
+            status: 'N',
+            action_id: act.id,
+          });
+        }
       }
     }
   }

package/src/module/workflow/repository/activity-log.repository.ts

@@ -0,0 +1,24 @@
+import { InjectRepository } from '@nestjs/typeorm';
+import { ActivityLog } from '../entity/activity-log.entity';
+import { Repository } from 'typeorm';
+
+export class ActivityLogRepository {
+  constructor(
+    @InjectRepository(ActivityLog)
+    private readonly activityLogRepository: Repository<ActivityLog>,
+  ) {}
+
+  async getAllActivityLog(mapped_entity_type: string, loggedInUser) {
+    const { organization_id } = loggedInUser;
+
+    return this.activityLogRepository
+      .createQueryBuilder('log')
+      .leftJoin('cr_user', 'user', 'log.user_id = user.id')
+      .where('log.mapped_entity_type = :mapped_entity_type', {
+        mapped_entity_type,
+      })
+      .andWhere('log.organization_id = :organization_id', { organization_id })
+      .addSelect('user.name', 'user_name') // Add only user_name
+      .getRawMany();
+  }
+}

package/src/module/workflow/repository/form-master.repository.ts

@@ -7,6 +7,7 @@ import {
 import { InjectRepository } from '@nestjs/typeorm';
 import { DataSource, Repository } from 'typeorm';
 import { FormMasterDataEntity } from '../entity/form-master.entity';
+import { FormDataEntity } from '../entity/form.entity';
 
 @Injectable()
 export class FormMasterRepository {
@@ -14,6 +15,8 @@ export class FormMasterRepository {
     @InjectRepository(FormMasterDataEntity)
     private readonly formMasterRepository: Repository<FormMasterDataEntity>,
     private readonly dataSource: DataSource,
+    @InjectRepository(FormDataEntity)
+    private readonly formRepo: Repository<FormDataEntity>,
   ) {}
 
   async getForms(organization_id: number, source_entity_type: string) {
@@ -34,4 +37,20 @@ export class FormMasterRepository {
 
     return formatted;
   }
+
+  async submitForm(formData: any) {
+    const currentForm = await this.formRepo.findOneBy({
+      mapped_entity_id: formData.entity_id,
+      mapped_entity_type: formData.entity_type,
+      view_id: formData.view_id,
+    });
+
+    if (!currentForm) {
+      throw new NotFoundException('Form not found');
+    }
+
+    currentForm.status = 'Y';
+
+    return this.formRepo.save(currentForm);
+  }
 }

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

@@ -56,33 +56,85 @@ export class StageGroupRepository {
 
     if (!stageGroups.length) return [];
 
-    // Step 2: Get all stages where stage_group_id IN (...)
+    // Step 2: Get all stages for these stage groups
     const stageGroupIds = stageGroups.map((sg) => sg.id);
 
     const stages = await this.dataSource.query(
       `
-  SELECT
-    cr_wf_stage.*,
-    cr_user.name AS created_by_name
-  FROM cr_wf_stage
-  LEFT JOIN cr_user ON cr_wf_stage.created_by = cr_user.id
-  WHERE cr_wf_stage.stage_group_id IN (${stageGroupIds.map(() => '?').join(',')})
-    AND cr_wf_stage.organization_id = ?
-  ORDER BY cr_wf_stage.sequence ASC
-  `,
+    SELECT
+      cr_wf_stage.*,
+      cr_user.name AS created_by_name
+    FROM cr_wf_stage
+    LEFT JOIN cr_user ON cr_wf_stage.created_by = cr_user.id
+    WHERE cr_wf_stage.stage_group_id IN (${stageGroupIds.map(() => '?').join(',')})
+      AND cr_wf_stage.organization_id = ?
+    ORDER BY cr_wf_stage.sequence ASC
+    `,
       [...stageGroupIds, organization_id],
     );
 
-    // Step 3: Group stages by stage_group_id
+    // Step 3: Get all counts in bulk
+    const stageIds = stages.map((s) => s.id);
+
+    // Task counts
+    const taskCounts = await this.dataSource.query(
+      `
+    SELECT stage_id, COUNT(*) AS task_count
+    FROM cr_wf_task_data
+    WHERE stage_id IN (${stageIds.map(() => '?').join(',')})
+    GROUP BY stage_id
+    `,
+      [...stageIds],
+    );
+
+    // Meeting counts
+    const meetingCounts = await this.dataSource.query(
+      `
+    SELECT stage_id, COUNT(*) AS meeting_count
+    FROM cr_lead_meeting
+    WHERE stage_id IN (${stageIds.map(() => '?').join(',')})
+    GROUP BY stage_id
+    `,
+      [...stageIds],
+    );
+
+    // Send communication counts
+    const sendCommCounts = await this.dataSource.query(
+      `
+    SELECT stage_id, COUNT(*) AS send_comm_count
+    FROM cr_lead_communication
+    WHERE stage_id IN (${stageIds.map(() => '?').join(',')}) AND type = 'SEND'
+    GROUP BY stage_id
+    `,
+      [...stageIds],
+    );
+
+    // Convert to maps for quick lookup
+    const taskCountMap = new Map(
+      taskCounts.map((row) => [row.stage_id, row.task_count]),
+    );
+    const meetingCountMap = new Map(
+      meetingCounts.map((row) => [row.stage_id, row.meeting_count]),
+    );
+    const sendCommCountMap = new Map(
+      sendCommCounts.map((row) => [row.stage_id, row.send_comm_count]),
+    );
+
+    // Step 4: Add counts to each stage
     const stageMap = new Map<number, any[]>();
     for (const stage of stages) {
+      const stageId = Number(stage.id);
+      stage.task_count = taskCountMap.get(stageId) || 0;
+      stage.meeting_count = meetingCountMap.get(stageId) || 0;
+      stage.send_comm_count = sendCommCountMap.get(stageId) || 0;
+
       if (!stageMap.has(stage.stage_group_id)) {
         stageMap.set(stage.stage_group_id, []);
       }
       stageMap.get(stage.stage_group_id)?.push(stage);
     }
 
-    // Step 4: Attach stages to stage groups
+    // Step 5: Attach stages with counts to stage groups
     const result = stageGroups.map((stageGroup) => {
       return {
         ...stageGroup,

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

@@ -186,10 +186,12 @@ export class StageMovementRepository {
     SELECT 
       a.*, 
       m.stage_id, 
-      ac.code AS action_category_code
+      ac.code AS action_category_code,
+      arm.form_id
     FROM cr_wf_action a
     INNER JOIN cr_wf_stage_action_mapping m ON a.id = m.action_id
     LEFT JOIN cr_wf_action_category ac ON a.action_category = ac.id
+    LEFT JOIN cr_wf_action_resources_mapping arm ON m.id = arm.stg_act_mapping_id
     WHERE m.stage_id = ?
     `,
       [stageId],

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

@@ -105,6 +105,7 @@ export class ActionService extends EntityServiceImpl {
           form_id: formId,
           type: 'form',
           entity_type: 'ARMS',
+          form_entity_type: 'LEAD',
         } as any;
 
         if (entityData?.organization_id) {