rez_core 2.2.94 → 2.2.96

package/package.json

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

package/src/module/meta/service/entity-service-impl.service.ts

@@ -462,6 +462,18 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
     );
   }
 
+  async getSingleResolvedData(
+    loggedInUser: UserData,
+    entityData: any,
+    entityType: string,
+  ): Promise<any> {
+    return this.resolverService.getResolvedData(
+      loggedInUser,
+      entityData,
+      entityType,
+    );
+  }
+
   async getResolvedEntityData(
     entityType: string,
     entityId: number,

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

@@ -1,9 +1,11 @@
+import { DataSource } from 'typeorm';
 import { BadRequestException, Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { ClockIDGenService } from '../../../utils/service/clockIDGenUtil.service';
 import { Otp } from '../entity/otp.entity';
 import { OtpRepository } from '../repository/otp.repository';
 import { LoginService } from './../../user/service/login.service';
+import { EmailService } from './email.service';
 
 @Injectable()
 export class OtpService {
@@ -12,6 +14,8 @@ export class OtpService {
     private readonly idGen: ClockIDGenService,
     private configService: ConfigService,
     private readonly loginService: LoginService,
+    private readonly emailService: EmailService,
+    private readonly dataSource: DataSource,
   ) {}
 
   VERIFY_OTP = this.configService.get('VERIFY_OTP') || 'true';
@@ -35,44 +39,60 @@ export class OtpService {
     otp.verified = 0;
     otp.expiration_date = new Date(Date.now() + expiresIn * 60 * 1000);
 
+    const userData = await this.dataSource
+      .getRepository('cr_user')
+      .findOne({ where: { email_id: identifier } });
+
+    const data = {
+      name: userData?.name || '',
+      otp: otp.otp,
+    };
+
+    await this.emailService.sendEmail(identifier, 'OTP Verification', data);
+
     return await this.otpRepository.save(otp);
   }
 
   async verifyOtp(body: { otp: string; otp_id: string; identifier: string }) {
-    let verifyOTPResponse = {
-      isValid: false,
-    };
+    const { otp, otp_id, identifier } = body;
+    const verifyOTPResponse = { isValid: false };
 
-    let otp = body.otp;
-    let otpId = body.otp_id;
+    // Find OTP entity by ID
+    const otpEntity = await this.findByOtpId(otp_id);
+    if (!otpEntity) {
+      throw new BadRequestException('OTP not found!');
+    }
 
-    let otpEntity = await this.findByOtpId(otpId);
+    // Validate the identifier against the OTP entity
+    if (otpEntity.identifier !== identifier) {
+      throw new BadRequestException('Invalid OTP identifier!');
+    }
 
-    if (otpEntity) {
-      if (otpEntity.identifier !== body.identifier) {
-        throw new BadRequestException('Invalid OTP!');
-      }
+    // OTP validation logic
+    const isOtpValid =
+      otpEntity.otp === otp &&
+      new Date() <= otpEntity.expiration_date &&
+      otpEntity.verified === 0;
 
-      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,
-        );
-        if (updatedOtp) {
-          verifyOTPResponse.isValid = true;
-        }
+    if (isOtpValid) {
+      otpEntity.verified = 1;
+
+      // Save the updated OTP status
+      const updatedOtp = await this.otpRepository.update(
+        otpEntity.id,
+        otpEntity,
+      );
+      if (updatedOtp) {
+        verifyOTPResponse.isValid = true;
       }
     }
 
     if (!verifyOTPResponse.isValid) {
       throw new BadRequestException('Invalid OTP!');
     }
-    return await this.loginService.login(body.identifier, undefined, true);
+
+    // Proceed to login
+    return this.loginService.login(identifier, undefined, true);
   }
 
   async findByOtpId(otpId: string) {