rez_core 7.0.13 → 7.1.1

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

@@ -1,142 +1,142 @@
-import { Injectable } from '@nestjs/common';
-import { MailerService } from '@nestjs-modules/mailer';
-import * as Handlebars from 'handlebars';
-import { DataSource } from 'typeorm';
-import { IcsMeetingService } from 'src/module/ics/service/ics.service';
-
-@Injectable()
-export class EmailService {
-  constructor(
-    private readonly mailerService: MailerService,
-    private readonly datasource: DataSource,
-    private readonly icsService: IcsMeetingService,
-  ) { }
-
-  async sendEmail(
-    email: string,
-    subject: string,
-    context?: any,
-    icsPayload?: any,
-  ) {
-    const template = await this.datasource
-      .getRepository('frm_wf_comm_template')
-      .findOne({ where: { code: 'OTP_TEMPLATE' } });
-
-    if (!template) return;
-
-    const compiled = Handlebars.compile(template.rich_text || '');
-    const htmlContent = compiled(context);
-
-    const attachments: any[] = [];
-
-    if (icsPayload) {
-      const icsBase64 = await this.icsService.generateIcs(icsPayload);
-      if (icsBase64) {
-        attachments.push({
-          filename: 'invite.ics',
-          content: icsBase64,
-          encoding: 'base64',
-          contentType: 'text/calendar; charset="utf-8"; method=REQUEST',
-        });
-      }
-    }
-
-    // fire-and-forget // removed await
-    const result = this.mailerService
-      .sendMail({
-        to: email,
-        subject,
-        html: htmlContent,
-        attachments,
-      })
-      .then(() => {
-        console.log(`Email sent to ${email}`);
-        return;
-      })
-      .catch((err) => {
-        console.error(`Failed to send email to ${email}`, err);
-        // Optionally: push to a retry queue, Sentry, DB log, etc.
-      });
-
-    console.log(result); // Return immediately (parent doesn’t block)
-    return;
-  }
-
-  async sendEmailWithDynamicTemplate(
-    email: string,
-    subject: string,
-    templateCode: string,
-    cc?: string[],
-    bcc?: string[],
-    message?: string,
-    context?: any,
-    icsPayload?: any,
-  ) {
-    // retrieve the rich_text from the database table frm_wf_comm_template for the given templateCode
-    const template = await this.datasource
-      .getRepository('frm_wf_comm_template')
-      .findOne({ where: { code: templateCode } });
-
-    if (!template) {
-      console.log(`Template with code ${templateCode} not found`);
-      return {
-        success: false,
-        message: `Template with code ${templateCode} not found`,
-      };
-    }
-
-    // Compile the template string with Handlebars
-    const templateString = template.rich_text || '';
-    const compiled = Handlebars.compile(message || templateString);
-    const htmlContent = compiled(context);
-
-    // Attachments (ICS optional)
-    const attachments: any[] = [];
-    if (icsPayload) {
-      const icsBase64 = await this.icsService.generateIcs(icsPayload);
-      if (icsBase64) {
-        attachments.push({
-          filename: 'invite.ics',
-          content: icsBase64,
-          encoding: 'base64',
-          contentType: 'text/calendar; charset="utf-8"; method=REQUEST',
-        });
-      }
-    }
-
-    const mailOptions: any = {
-      to: email,
-      subject,
-      html: htmlContent,
-      attachments,
-    };
-
-    if (cc && cc.length > 0) {
-      mailOptions.cc = cc;
-    }
-
-    if (bcc && bcc.length > 0) {
-      mailOptions.bcc = bcc;
-    }
-
-    // Send the email
-    await this.mailerService.sendMail(mailOptions);
-
-    return { success: true, message: 'Email sent successfully' };
-  }
-
-  async sendEmailWithoutTemplate(to: string, subject: string, body: string) {
-    try {
-      await this.mailerService.sendMail({
-        to,
-        subject,
-        html: body,
-      });
-      console.log(`Email sent successfully to ${to} via NodeMailer.`);
-    } catch (error) {
-      console.error(`Failed to send email to ${to} via NodeMailer:`, error);
-      throw error; // Re-throw to allow calling context to handle
-    }
-  }
-
-}
+import { Injectable } from '@nestjs/common';
+import { MailerService } from '@nestjs-modules/mailer';
+import * as Handlebars from 'handlebars';
+import { DataSource } from 'typeorm';
+import { IcsMeetingService } from 'src/module/ics/service/ics.service';
+
+@Injectable()
+export class EmailService {
+  constructor(
+    private readonly mailerService: MailerService,
+    private readonly datasource: DataSource,
+    private readonly icsService: IcsMeetingService,
+  ) { }
+
+  async sendEmail(
+    email: string,
+    subject: string,
+    context?: any,
+    icsPayload?: any,
+  ) {
+    const template = await this.datasource
+      .getRepository('frm_wf_comm_template')
+      .findOne({ where: { code: 'OTP_TEMPLATE' } });
+
+    if (!template) return;
+
+    const compiled = Handlebars.compile(template.rich_text || '');
+    const htmlContent = compiled(context);
+
+    const attachments: any[] = [];
+
+    if (icsPayload) {
+      const icsBase64 = await this.icsService.generateIcs(icsPayload);
+      if (icsBase64) {
+        attachments.push({
+          filename: 'invite.ics',
+          content: icsBase64,
+          encoding: 'base64',
+          contentType: 'text/calendar; charset="utf-8"; method=REQUEST',
+        });
+      }
+    }
+
+    // fire-and-forget // removed await
+    const result = this.mailerService
+      .sendMail({
+        to: email,
+        subject,
+        html: htmlContent,
+        attachments,
+      })
+      .then(() => {
+        console.log(`Email sent to ${email}`);
+        return;
+      })
+      .catch((err) => {
+        console.error(`Failed to send email to ${email}`, err);
+        // Optionally: push to a retry queue, Sentry, DB log, etc.
+      });
+
+    console.log(result); // Return immediately (parent doesn’t block)
+    return;
+  }
+
+  async sendEmailWithDynamicTemplate(
+    email: string,
+    subject: string,
+    templateCode: string,
+    cc?: string[],
+    bcc?: string[],
+    message?: string,
+    context?: any,
+    icsPayload?: any,
+  ) {
+    // retrieve the rich_text from the database table frm_wf_comm_template for the given templateCode
+    const template = await this.datasource
+      .getRepository('frm_wf_comm_template')
+      .findOne({ where: { code: templateCode } });
+
+    if (!template) {
+      console.log(`Template with code ${templateCode} not found`);
+      return {
+        success: false,
+        message: `Template with code ${templateCode} not found`,
+      };
+    }
+
+    // Compile the template string with Handlebars
+    const templateString = template.rich_text || '';
+    const compiled = Handlebars.compile(message || templateString);
+    const htmlContent = compiled(context);
+
+    // Attachments (ICS optional)
+    const attachments: any[] = [];
+    if (icsPayload) {
+      const icsBase64 = await this.icsService.generateIcs(icsPayload);
+      if (icsBase64) {
+        attachments.push({
+          filename: 'invite.ics',
+          content: icsBase64,
+          encoding: 'base64',
+          contentType: 'text/calendar; charset="utf-8"; method=REQUEST',
+        });
+      }
+    }
+
+    const mailOptions: any = {
+      to: email,
+      subject,
+      html: htmlContent,
+      attachments,
+    };
+
+    if (cc && cc.length > 0) {
+      mailOptions.cc = cc;
+    }
+
+    if (bcc && bcc.length > 0) {
+      mailOptions.bcc = bcc;
+    }
+
+    // Send the email
+    await this.mailerService.sendMail(mailOptions);
+
+    return { success: true, message: 'Email sent successfully' };
+  }
+
+  async sendEmailWithoutTemplate(to: string, subject: string, body: string) {
+    try {
+      await this.mailerService.sendMail({
+        to,
+        subject,
+        html: body,
+      });
+      console.log(`Email sent successfully to ${to} via NodeMailer.`);
+    } catch (error) {
+      console.error(`Failed to send email to ${to} via NodeMailer:`, error);
+      throw error; // Re-throw to allow calling context to handle
+    }
+  }
+
+}

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

@@ -1,163 +1,145 @@
-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 };
-  }
-}
+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 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 };
+  }
+}

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

@@ -1,25 +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;
-}
+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;
+}