rez_core 6.6.6 → 7.0.0

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

@@ -1,146 +1,163 @@
-import { Inject, Injectable } from '@nestjs/common';
-import { DataSource, EntityManager } from 'typeorm';
-import { MediaDataService } from 'src/module/meta/service/media-data.service';
-import * as admin from 'firebase-admin';
-import axios from 'axios';
-import { ConfigService } from '@nestjs/config';
-import { ReflectionHelper } from 'src/utils/service/reflection-helper.service';
-import { NotificationRepository } from '../repository/notification.repository';
-
-@Injectable()
-export class NotificationsService {
-  constructor(
-    private readonly entityManager: EntityManager,
-    private readonly mediaDataService: MediaDataService,
-    private readonly configService: ConfigService,
-    private readonly reflectionHelper: ReflectionHelper,
-    @Inject('FIREBASE_ADMIN') private readonly firebaseAdmin: typeof admin,
-    private readonly notificationRepository: NotificationRepository,
-  ) {}
-
-  private tokens: Map<string, string> = new Map(); // store in memory for now
-
-  async saveToken(userId: string | undefined, token: string) {
-    if (userId) {
-      this.tokens.set(userId, token);
-    }
-    return { success: true, token };
-  }
-
-  async sendToDevice(
-    token: string,
-    title: string,
-    body: string,
-    data?: Record<string, any>,
-  ) {
-    // Utility to sanitize FCM data payload
-    const sanitizeFCMData = (
-      payload: Record<string, any>,
-    ): Record<string, string> =>
-      Object.fromEntries(
-        Object.entries(payload).map(([k, v]) => {
-          if (v === null || v === undefined) return [k, '']; // fallback for null/undefined
-          if (typeof v === 'object') return [k, JSON.stringify(v)]; // preserve structure
-          return [k, String(v)]; // numbers, booleans, strings
-        }),
-      );
-
-    const message: admin.messaging.Message = {
-      token,
-      notification: { title, body }, // system notification
-      data: data ? sanitizeFCMData(data) : undefined,
-    };
-
-    try {
-      return await this.firebaseAdmin.messaging().send(message);
-    } catch (error) {
-      console.error('Error sending FCM message:', error);
-      throw error;
-    }
-  }
-
-  // Helper: send to a registered user by userId
-  async sendToUser(userId: string, title: string, body: string) {
-    const token = this.tokens.get(userId);
-    if (!token) return { error: 'No token found for user' };
-
-    return this.sendToDevice(token, title, body);
-  }
-
-  async getAllNotifications(
-    loggedInUser: any,
-    filterQuery?: { is_read?: string },
-  ) {
-    const { id: userId, level_id, level_type } = loggedInUser;
-
-    // Fetch notifications from repository
-    const notifications: any =
-      await this.notificationRepository.getAllNotifications(
-        userId,
-        level_id,
-        level_type,
-        filterQuery?.is_read,
-      );
-
-    //
-    // Avoid duplicate API calls for each user_id
-    //
-    const mediaCache = new Map<
-      number,
-      { name: string; profile_image: string }
-    >();
-
-    const baseUrl = this.configService.get<string>('REDIRECT_BE_URL');
-
-    for (const notification of notifications) {
-      const uid = notification?.user_id;
-
-      if (uid && !mediaCache.has(uid)) {
-        try {
-          const queryParams = new URLSearchParams({
-            loggedInUser: JSON.stringify(loggedInUser),
-          }).toString();
-
-          const response = await axios.get(
-            `${baseUrl}/users/profile-image-url/${uid}?entity_type=USR&${queryParams}`,
-            { headers: { 'Content-Type': 'application/json' } },
-          );
-
-          mediaCache.set(uid, {
-            name: response.data.name,
-            profile_image: response.data.profile_image,
-          });
-        } catch (err) {
-          console.error('⚠️ Internal Entity API call failed:', err.message);
-        }
-      }
-
-      const cachedData = mediaCache.get(uid);
-      notification.user_name = cachedData?.name;
-      notification.user_profile = cachedData?.profile_image;
-    }
-
-    return notifications;
-  }
-
-  async markAllAsRead(loggedInUser: any) {
-    const { id, level_id, level_type } = loggedInUser;
-
-    const notificationRepo =
-      this.reflectionHelper.getRepoService('NotificationData');
-
-    const result = await notificationRepo.update(
-      {
-        user_id: id,
-        level_id: level_id,
-        level_type: level_type,
-        is_read: false,
-      },
-      {
-        is_read: true,
-      },
-    );
-
-    return { success: true, affectedRows: result.affected || 0 };
-  }
-}
+import { Inject, Injectable } from '@nestjs/common';
+import { DataSource, EntityManager } from 'typeorm';
+import { MediaDataService } from 'src/module/meta/service/media-data.service';
+import * as admin from 'firebase-admin';
+import axios from 'axios';
+import { ConfigService } from '@nestjs/config';
+import { ReflectionHelper } from 'src/utils/service/reflection-helper.service';
+
+@Injectable()
+export class NotificationsService {
+  constructor(
+    private readonly entityManager: EntityManager,
+    private readonly configService: ConfigService,
+    private readonly reflectionHelper: ReflectionHelper,
+    @Inject('FIREBASE_ADMIN') private readonly firebaseAdmin: typeof admin,
+  ) {}
+
+  private tokens: Map<string, string> = new Map(); // store in memory for now
+
+  async saveToken(userId: string | undefined, token: string) {
+    if (userId) {
+      this.tokens.set(userId, token);
+    }
+    return { success: true, token };
+  }
+
+  async sendToDevice(
+    token: string,
+    title: string,
+    body: string,
+    data?: Record<string, any>,
+  ) {
+    // Utility to sanitize FCM data payload
+    const sanitizeFCMData = (
+      payload: Record<string, any>,
+    ): Record<string, string> =>
+      Object.fromEntries(
+        Object.entries(payload).map(([k, v]) => {
+          if (v === null || v === undefined) return [k, '']; // fallback for null/undefined
+          if (typeof v === 'object') return [k, JSON.stringify(v)]; // preserve structure
+          return [k, String(v)]; // numbers, booleans, strings
+        }),
+      );
+
+    const message: admin.messaging.Message = {
+      token,
+      notification: { title, body }, // system notification
+      data: data ? sanitizeFCMData(data) : undefined,
+    };
+
+    try {
+      return await this.firebaseAdmin.messaging().send(message);
+    } catch (error) {
+      console.error('Error sending FCM message:', error);
+      throw error;
+    }
+  }
+
+  // Helper: send to a registered user by userId
+  async sendToUser(userId: string, title: string, body: string) {
+    const token = this.tokens.get(userId);
+    if (!token) return { error: 'No token found for user' };
+
+    return this.sendToDevice(token, title, body);
+  }
+
+  async getAllNotifications(
+    loggedInUser: any,
+    filterQuery?: { is_read?: string },
+  ) {
+    const { id, level_id, level_type } = loggedInUser;
+
+    //
+    // Convert "true"/"false" → "1"/"0" as strings
+    //
+    let isReadFilter: string | undefined = undefined;
+    if (filterQuery && filterQuery.is_read !== undefined) {
+      const isRead = String(filterQuery.is_read).toLowerCase() === 'true';
+      isReadFilter = isRead ? '1' : '0'; // <-- always string
+    }
+
+    //
+    // Build base SQL
+    //
+    let paramIndex = 1;
+    let sql = `
+    SELECT n.*
+    FROM frm_notification n
+    WHERE n.user_id = $${paramIndex}
+      AND n.level_id = $${paramIndex + 1}
+      AND n.level_type = $${paramIndex + 2}
+  `;
+
+    const params: string[] = [String(id), String(level_id), String(level_type)];
+    paramIndex += 3;
+
+    //
+    // Apply optional filter
+    //
+    if (isReadFilter !== undefined) {
+      sql += ` AND n.is_read = $${paramIndex}`;
+      params.push(String(isReadFilter));
+      paramIndex++;
+    }
+
+    sql += ` ORDER BY n.created_date DESC`;
+
+    //
+    // Execute query
+    //
+    const notifications = await this.entityManager.query(sql, params);
+
+    //
+    // Enrich profile image + user name
+    //
+    const mediaCache = new Map();
+
+    for (const notification of notifications) {
+      notification.is_read =
+        notification.is_read === 1 || notification.is_read === '1';
+
+      try {
+        const baseUrl = this.configService.get<string>('REDIRECT_BE_URL');
+        const queryParams = new URLSearchParams({
+          loggedInUser: JSON.stringify(loggedInUser),
+        }).toString();
+
+        const response = await axios.get(
+          `${baseUrl}/users/profile-image-url/${notification.user_id}?entity_type=USR&${queryParams}`,
+          { headers: { 'Content-Type': 'application/json' } },
+        );
+
+        notification.user_name = response.data.name;
+        notification.user_profile = response.data.profile_image;
+      } catch (error) {
+        console.error('⚠️ Internal Entity API call failed:', error.message);
+      }
+    }
+
+    return notifications;
+  }
+
+  async markAllAsRead(loggedInUser: any) {
+    const { id, level_id, level_type } = loggedInUser;
+
+    const notificationRepo =
+      this.reflectionHelper.getRepoService('NotificationData');
+
+    const result = await notificationRepo.update(
+      {
+        user_id: id,
+        level_id: level_id,
+        level_type: level_type,
+        is_read: 0,
+      },
+      {
+        is_read: 1,
+      },
+    );
+
+    return { success: true, affectedRows: result.affected || 0 };
+  }
+}

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

@@ -1,133 +1,144 @@
-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 {
-  constructor(
-    private readonly otpRepository: OtpRepository,
-    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';
-  DEFAULT_OTP = this.configService.get('DEFAULT_OTP') || '123456';
-
-  async generate(
-    identifier: string,
-    service: string,
-    expiresIn: number = 5,
-    otpLength: number = 6,
-  ) {
-    const 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.service = service;
-    otp.verified = 0;
-    otp.expiration_date = new Date(Date.now() + expiresIn * 60 * 1000);
-
-    const userData = await this.dataSource
-      .getRepository('sso_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(data: {
-    otp: string;
-    otp_id: string;
-    identifier: string;
-    subdomain: string;
-    fcm_token: string;
-    browser?: string;
-    ip?: string;
-    os?: string;
-  }) {
-    const { otp, otp_id, identifier, subdomain, fcm_token, browser, ip, os } =
-      data;
-    const verifyOTPResponse = { isValid: false };
-
-    // Find OTP entity by ID
-    const otpEntity = await this.findByOtpId(otp_id);
-    if (!otpEntity) {
-      // throw new BadRequestException('OTP not found!');
-      return {
-        sucess: false,
-        message: 'OTP not found!',
-      };
-    }
-
-    // Validate the identifier against the OTP entity
-    if (otpEntity.identifier !== identifier) {
-      return {
-        sucess: false,
-        message: 'Invalid OTP identifier!',
-      };
-    }
-
-    // OTP validation logic
-    const isOtpValid =
-      (otpEntity.otp === otp ||
-        (this.DEFAULT_OTP && this.DEFAULT_OTP === otp)) &&
-      new Date() <= otpEntity.expiration_date &&
-      otpEntity.verified === 0;
-
-    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 {
-        sucess: false,
-        message: 'Invalid OTP!',
-      };
-    }
-
-    // Proceed to login
-    return this.loginService.login({
-      email_id: identifier,
-      is_otp: true,
-      subdomain,
-    });
-  }
-
-  async findByOtpId(otpId: string) {
-    return await this.otpRepository.findByOtpId(otpId);
-  }
-
-  private generateOtp(length: number): string {
-    const min = 10 ** (length - 1);
-    const max = 10 ** length - 1;
-    return Math.floor(min + Math.random() * (max - min + 1)).toString();
-  }
-}
+import { DataSource } from 'typeorm';
+import { 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';
+import { PreferenceService } from 'src/module/preference_master/preference.service';
+
+@Injectable()
+export class OtpService {
+  constructor(
+    private readonly otpRepository: OtpRepository,
+    private readonly idGen: ClockIDGenService,
+    private configService: ConfigService,
+    private readonly loginService: LoginService,
+    private readonly dataSource: DataSource,
+    // private readonly preferenceService: PreferenceService,
+    private readonly emailService: EmailService,
+  ) {
+  }
+
+  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,
+  ) {
+    const 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.service = service;
+    otp.verified = 0;
+    otp.expiration_date = new Date(Date.now() + expiresIn * 60 * 1000);
+
+    const userData: any = await this.dataSource
+      .getRepository('sso_user')
+      .findOne({ where: { email_id: identifier } });
+
+    const data = {
+      name: userData?.name || '',
+      otp: otp.otp,
+    };
+
+    // TODO: Inject and use PreferenceService here
+    // const preference = await this.preferenceService.fetchPreferenceByType('OTP', true);
+
+    // if (preference) {
+    //   let otpBody = preference.filter((item) => item.key === 'OTP_BODY')[0].value;
+    //   otpBody = otpBody.replace('${otp}', otp.otp);
+    //   const otpSubject = preference.filter((item) => item.key === 'OTP_SUBJECT')[0].value;
+    //   this.emailService.sendEmailWithoutTemplate(userData.email_id, otpSubject, otpBody);
+    // }
+
+    return await this.otpRepository.save(otp);
+  }
+
+  async verifyOtp(data: {
+    otp: string;
+    otp_id: string;
+    identifier: string;
+    subdomain: string;
+    fcm_token: string;
+    browser?: string;
+    ip?: string;
+    os?: string;
+  }) {
+    const { otp, otp_id, identifier, subdomain, fcm_token, browser, ip, os } =
+      data;
+    const verifyOTPResponse = { isValid: false };
+
+    // Find OTP entity by ID
+    const otpEntity = await this.findByOtpId(otp_id);
+    if (!otpEntity) {
+      // throw new BadRequestException('OTP not found!');
+      return {
+        sucess: false,
+        message: 'OTP not found!',
+      };
+    }
+
+    // Validate the identifier against the OTP entity
+    if (otpEntity.identifier !== identifier) {
+      return {
+        sucess: false,
+        message: 'Invalid OTP identifier!',
+      };
+    }
+
+    // OTP validation logic
+    const isOtpValid =
+      (otpEntity.otp === otp ||
+        (this.DEFAULT_OTP && this.DEFAULT_OTP === otp)) &&
+      new Date() <= otpEntity.expiration_date &&
+      otpEntity.verified === 0;
+
+    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 {
+        sucess: false,
+        message: 'Invalid OTP!',
+      };
+    }
+
+    // Proceed to login
+    return this.loginService.login({
+      email_id: identifier,
+      is_otp: true,
+      subdomain,
+    });
+  }
+
+  async findByOtpId(otpId: string) {
+    return await this.otpRepository.findByOtpId(otpId);
+  }
+
+  private generateOtp(length: number): string {
+    const min = 10 ** (length - 1);
+    const max = 10 ** length - 1;
+    return Math.floor(min + Math.random() * (max - min + 1)).toString();
+  }
+}

package/src/module/preference_master/entity/preference.entity.ts

@@ -0,0 +1,25 @@
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn } from 'typeorm';
+
+@Entity('sso_preference_master')
+export class PreferenceData {
+    @PrimaryGeneratedColumn()
+    id: number;
+
+    @Column({ name: 'enterprise_id', type: 'int' })
+    enterpriseId: number;
+
+    @Column({ name: 'preference_type', type: 'varchar', length: 15 })
+    preferenceType: string;
+
+    @Column({ type: 'varchar', length: 255 })
+    key: string;
+
+    @Column({ type: 'text' })
+    value: string;
+
+    @CreateDateColumn({ name: 'created_date', type: 'timestamp' })
+    createdDate: Date;
+
+    @Column({ type: 'boolean', default: true })
+    status: boolean;
+}

package/src/module/preference_master/preference.service.ts

@@ -0,0 +1,27 @@
+// src/module/preference_master/preference.service.ts
+import { Injectable } from '@nestjs/common';
+import { PreferenceData } from './entity/preference.entity';
+import { PreferenceRepository } from './repo/preference.repository';
+
+@Injectable()
+export class PreferenceService {
+    constructor(
+        private readonly preferenceRepository: PreferenceRepository
+    ) { }
+
+    async fetchPreference(
+        entID: number,
+        key: string,
+        status: boolean,
+    ): Promise<PreferenceData | null> {
+        return await this.preferenceRepository.findByEntIdAndKeyAndStatus(
+            entID,
+            key,
+            status,
+        );
+    }
+
+    async fetchPreferenceByType(preferenceType: string, status: boolean) {
+        return await this.preferenceRepository.findByPreferenceType(preferenceType, status);
+    }
+}