rez_core 5.0.207 → 5.0.208

package/package.json

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

package/src/module/meta/service/resolver.service.ts

@@ -111,9 +111,8 @@ export class ResolverService {
         attr.element_type === 'date' ||
         attr.element_type === 'datetime'
       ) {
-        // 👇 Explicitly define input format to avoid deprecation warning
-        const dateValue = moment(codeValue, "DD-MM-YYYY", true).utcOffset('+05:30');
-
+        const dateFormat = attr.element_type === 'date' ? "DD-MM-YYYY" : "DD-MM-YYYY HH:mm:ss";
+        const dateValue = moment(codeValue,dateFormat).utcOffset('+05:30'); // IST
         if (dateValue.isValid()) {
           resolvedEntityData[field] =
             attr.element_type === 'date'
@@ -159,75 +158,88 @@ export class ResolverService {
         attrKey,
         loggedInUser.enterprise_id,
       );
-    if (!attr) return rawValue;
 
-    // -------- ENTITY data_source_type --------
+    if (!attr) return rawValue;
+    // ----------- ENTITY TYPE RESOLUTION -------------------
     if (attr.data_source_type === 'entity') {
       const entityDef = await this.entityMasterRepo.getEntityByMappedEntityType(
         attr.datasource_list,
         loggedInUser.enterprise_id,
       );
-
       if (!entityDef) return rawValue;
 
       const tableName = entityDef.db_table_name;
 
+      // --- If array (multi-select) ---
       if (Array.isArray(rawValue)) {
         const resolvedValues: string[] = [];
+
         for (const value of rawValue) {
           const query =
             tableName === 'sso_organization'
-              ? `SELECT *
-                 FROM ${tableName}
-                 WHERE code = $1`
-              : `SELECT *
-                 FROM ${tableName}
-                 WHERE id = $1`;
-          const params = tableName === 'sso_organization' ? [value] : [value];
-
-          const [item] = await this.entityManger.query(query, params);
+              ? `SELECT * FROM ${tableName} WHERE code = $1`
+              : `SELECT * FROM ${tableName} WHERE id = $1`;
+
+          const [item] = await this.entityManger.query(query, [value]);
           resolvedValues.push(item?.[attr.data_source_attribute] ?? value);
         }
-        return resolvedValues;
-      } else {
-        const query = `SELECT *
-                       FROM ${tableName}
-                       WHERE id = $1`;
-        const params = [rawValue];
 
-        const [item] = await this.entityManger.query(query, params);
-        return item?.[attr.data_source_attribute] ?? rawValue;
+        return resolvedValues;
       }
+
+      // --- Single value ---
+      const query = `SELECT * FROM ${tableName} WHERE id = $1`;
+      const [item] = await this.entityManger.query(query, [rawValue]);
+
+      return item?.[attr.data_source_attribute] ?? rawValue;
     }
 
-    // -------- MASTER data_source_type --------
-    else if (attr.data_source_type === 'master') {
+    // ----------- MASTER TYPE RESOLUTION -------------------
+    if (attr.data_source_type === 'master') {
       const repo = this.reflectionHelper.getRepoService('ListMasterItems');
-      if (Array.isArray(rawValue)) {
+
+      let value = rawValue;
+
+      // 🟦 If rawValue is a JSON string representing array → parse it
+      if (typeof rawValue === 'string') {
+        try {
+          const parsed = JSON.parse(rawValue);
+          if (Array.isArray(parsed)) value = parsed;
+        } catch (e) {
+          // keep as string
+        }
+      }
+
+      // 🟩 If value is array → resolve each
+      if (Array.isArray(value)) {
         const resolvedValues: string[] = [];
-        for (const code of rawValue) {
-          let item = repo.findOne({
-            where: {
-              id: code,
-            },
+
+        for (const id of value) {
+          const item = await repo.findOne({
+            where: { id: Number(id) },
           });
-          resolvedValues.push(item?.[attr.data_source_attribute] ?? code);
+          resolvedValues.push(item?.[attr.data_source_attribute] ?? id);
         }
+
         return resolvedValues;
-      } else {
-        if (typeof rawValue !== 'number') return rawValue;
-        let item = await repo.findOne({
-          where: {
-            id: Number(rawValue),
-          },
+      }
+
+      // 🟨 Single value (must be number)
+      if (!isNaN(rawValue)) {
+        const item = await repo.findOne({
+          where: { id: Number(rawValue) },
         });
+
         return item?.[attr.data_source_attribute] ?? rawValue;
       }
+
+      return rawValue;
     }
 
     return rawValue;
   }
 
+
   async getResolvedId(
     loggedInUser: UserData,
     attrKey: string,

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

@@ -17,6 +17,7 @@ import { NotificationsController } from './controller/notification.controller';
 import { NotificationsService } from './service/notification.service';
 import { EntityModule } from '../meta/entity.module';
 import { FirebaseAdminProvider } from './firebase-admin.config';
+import { NotificationRepository } from './repository/notification.repository';
 
 @Module({
   imports: [
@@ -57,6 +58,7 @@ import { FirebaseAdminProvider } from './firebase-admin.config';
     EmailService,
     NotificationsService,
     FirebaseAdminProvider,
+    NotificationRepository,
   ],
   exports: [
     OtpService,

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

@@ -0,0 +1,33 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository, EntityManager } from 'typeorm';
+import { NotificationData } from '../entity/notification.entity';
+
+@Injectable()
+export class NotificationRepository {
+  constructor(
+    @InjectRepository(NotificationData)
+    private readonly notificationRepo: Repository<NotificationData>,
+  ) {}
+
+  async getAllNotifications(
+    userId: number,
+    levelId: number,
+    levelType: string,
+    isReadFilter?,
+  ) {
+    const qb = this.notificationRepo
+      .createQueryBuilder('n')
+      .where('n.user_id = :userId', { userId })
+      .andWhere('n.level_id = :levelId', { levelId })
+      .andWhere('n.level_type = :levelType', { levelType });
+
+    if (isReadFilter !== undefined) {
+      qb.andWhere('n.is_read = :isRead', { isRead: isReadFilter });
+    }
+
+    qb.orderBy('n.created_date', 'DESC');
+
+    return await qb.getMany();
+  }
+}

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

@@ -5,6 +5,7 @@ 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 {
@@ -14,6 +15,7 @@ export class NotificationsService {
     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
@@ -69,73 +71,53 @@ export class NotificationsService {
     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`;
+    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,
+      );
 
     //
-    // Execute query
+    // Avoid duplicate API calls for each user_id
     //
-    const notifications = await this.entityManager.query(sql, params);
+    const mediaCache = new Map<
+      number,
+      { name: string; profile_image: string }
+    >();
 
-    //
-    // Enrich profile image + user name
-    //
-    const mediaCache = new Map();
+    const baseUrl = this.configService.get<string>('REDIRECT_BE_URL');
 
     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);
+      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;