rez_core 2.2.49 → 2.2.52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.2.49",
+  "version": "2.2.52",
   "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,20 @@
+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.find({
+      where: {
+        mapped_entity_type: mapped_entity_type,
+        organization_id: organization_id,
+      },
+    });
+  }
+}

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-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) {

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

@@ -0,0 +1,24 @@
+import { Injectable } from '@nestjs/common';
+import { create } from 'domain';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { Entity } from 'typeorm';
+import { ActivityLog } from '../entity/activity-log.entity';
+import { ActivityLogRepository } from '../repository/activity-log.repository';
+import { UserData } from 'src/module/user/entity/user.entity';
+
+@Injectable()
+export class ActivityLogService extends EntityServiceImpl {
+  constructor(private readonly activityLogRepository: ActivityLogRepository) {
+    super();
+  }
+
+  async getAllActivityLog(
+    mapped_entity_type: string,
+    loggedInUser: UserData,
+  ): Promise<ActivityLog[]> {
+    return this.activityLogRepository.getAllActivityLog(
+      mapped_entity_type,
+      loggedInUser,
+    );
+  }
+}

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

@@ -13,4 +13,14 @@ export class FormMasterService {
       source_entity_type,
     );
   }
+
+  async submitForm(data: any) {
+    const { entity_id, entity_type, view_id } = data;
+
+    return this.formMasterRepository.submitForm({
+      entity_id,
+      entity_type,
+      view_id,
+    });
+  }
 }

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

@@ -57,6 +57,11 @@ import { ActionResourcesMapping } from './entity/action-resources-mapping.entity
 import { ActionResourcesMappingService } from './service/action-resources-mapping.service';
 import { ActionResourcesMappingController } from './controller/action-resource-mapping.controller';
 import { ActionCategoryRepository } from './repository/action-category.repository';
+import { FormDataEntity } from './entity/form.entity';
+import { ActivityLog } from './entity/activity-log.entity';
+import { ActivityLogService } from './service/activity-log.service';
+import { ActivityLogController } from './controller/activity-log.controller';
+import { ActivityLogRepository } from './repository/activity-log.repository';
 
 @Module({
   imports: [
@@ -76,7 +81,9 @@ import { ActionCategoryRepository } from './repository/action-category.repositor
       TaskDataEntity,
       ActionDataEntity,
       FormMasterDataEntity,
+      FormDataEntity,
       ActionResourcesMapping,
+      ActivityLog,
     ]),
     EntityModule,
     ListMasterModule,
@@ -102,6 +109,11 @@ import { ActionCategoryRepository } from './repository/action-category.repositor
       provide: 'ActionResourcesMappingService',
       useClass: ActionResourcesMappingService,
     },
+    {
+      provide: 'ActivityLogService',
+      useClass: ActivityLogService,
+    },
+
     WorkflowListMasterService,
     ActionTemplateMappingService,
     WorkflowRepository,
@@ -119,6 +131,8 @@ import { ActionCategoryRepository } from './repository/action-category.repositor
     ActionDataService,
     FormMasterRepository,
     ActionCategoryRepository,
+    ActivityLogService,
+    ActivityLogRepository,
   ],
   exports: [
     'ActionCategoryService',
@@ -137,6 +151,8 @@ import { ActionCategoryRepository } from './repository/action-category.repositor
     WorkflowMetaService,
     PopulateWorkflowService,
     ActionCategoryRepository,
+    'ActivityLogService',
+    ActivityLogRepository,
   ],
   controllers: [
     WorkflowListMasterController,
@@ -152,6 +168,7 @@ import { ActionCategoryRepository } from './repository/action-category.repositor
     TaskController,
     FormMasterController,
     ActionResourcesMappingController,
+    ActivityLogController,
   ],
 })
 export class WorkflowModule {}