rez_core 3.1.133 → 3.1.134

package/package.json

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

package/src/module/integration/service/wrapper.service.ts

@@ -148,14 +148,16 @@ export class WrapperService {
   async sendCommunicationWrapperService(entity: any, loggedInUser: any) {
     try {
       this.logger.log(
-        `sendCommunicationWrapper called. User: ${JSON.stringify(loggedInUser)}, Payload: ${JSON.stringify(entity)}`,
+        `sendCommunicationWrapper called. User: ${JSON.stringify(
+          loggedInUser,
+        )}, Payload: ${JSON.stringify(entity)}`,
       );
 
-      const { level_id, level_type, appcode } = loggedInUser;
+      const { level_id, level_type, appcode, organization_id } = loggedInUser;
 
-      // Step 1: Check if active email configs exist for current user's level
+      // Check if active configs exist for current user's level
       this.logger.debug(
-        `Checking active EMAIL configs for level_id=${level_id}, level_type=${level_type}, app_code=${appcode}`,
+        `Checking active ${entity.type || 'EMAIL'} configs for level_id=${level_id}, level_type=${level_type}, app_code=${appcode}`,
       );
 
       let configs = await this.integrationService.getActiveConfigs(
@@ -168,7 +170,7 @@ export class WrapperService {
       let effectiveLevelId = level_id;
       let effectiveLevelType = level_type;
 
-      // Step 2: If no configs exist, fall back to ORG-level (1, 'ORG')
+      // Fallback to ORG-level if no configs found
       if (!configs || configs.length === 0) {
         this.logger.warn(
           `No active configs found for ${level_type}:${level_id}, falling back to ORG-level`,
@@ -180,6 +182,7 @@ export class WrapperService {
           appcode,
           entity.type || 'EMAIL',
         );
+
         effectiveLevelId = 1;
         effectiveLevelType = 'ORG';
       }
@@ -189,14 +192,60 @@ export class WrapperService {
         throw new Error('No active configurations found.');
       }
 
-      // Step 3: Prepare payload for Integration Service
+      // Template lookup if templateCode is provided
+      let resolvedTemplateId = entity?.templateId;
+
+      if (entity.template_code) {
+        this.logger.debug(
+          `Looking up template for code=${entity.template_code}, level_id=${level_id}, level_type=${level_type}`,
+        );
+
+        // Try to find template at user's level first
+        let templates = await this.datasource.query(
+          `SELECT id FROM cr_wf_comm_template 
+         WHERE code = ? 
+           AND level_id = ? 
+           AND level_type = ? 
+         LIMIT 1`,
+          [entity.template_code, level_id, level_type],
+        );
+
+        // Fallback to ORG + organization_id if not found
+        if (!templates || templates.length === 0) {
+          this.logger.warn(
+            `No template found for ${entity.template_code} at provided level. Falling back to ORG-level.`,
+          );
+
+          templates = await this.datasource.query(
+            `SELECT id FROM cr_wf_comm_template 
+           WHERE code = ? 
+             AND level_type = 'ORG' 
+             AND organization_id = ? 
+           LIMIT 1`,
+            [entity.template_code, organization_id],
+          );
+        }
+
+        if (templates && templates.length > 0) {
+          resolvedTemplateId = templates[0]?.id;
+          this.logger.debug(
+            `Template resolved for code=${entity.template_code}, id=${resolvedTemplateId}`,
+          );
+        } else {
+          this.logger.warn(
+            `No template found for code=${entity.template_code} at any level.`,
+          );
+        }
+      }
+
+      // Step Prepare payload for Integration Service
       const mailPayload = {
         to: entity.to,
         subject: entity.subject,
         html: entity.message,
         cc: entity?.cc,
         bcc: entity?.bcc,
-        templateId: entity.templateId,
+        templateId: resolvedTemplateId, // updated with resolved ID
         message: entity.message,
         type: entity.type || 'EMAIL',
         levelId: effectiveLevelId,
@@ -213,7 +262,7 @@ export class WrapperService {
         `Final payload for sendGenericMessage: ${JSON.stringify(mailPayload)}`,
       );
 
-      // Step 4: Send mail via integration service
+      // Step 5️⃣ Send via Integration Service
       const result =
         await this.integrationService.sendGenericMessage(mailPayload);
 

package/src/module/layout_preference/service/layout_preference.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
 import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { UserData } from 'src/module/user/entity/user.entity';
@@ -7,6 +7,8 @@ import { DataSource } from 'typeorm';
 
 @Injectable()
 export class LayoutPreferenceService extends EntityServiceImpl {
+  private readonly logger = new Logger(LayoutPreferenceService.name);
+
   constructor(
     private layoutPreferenceRepository: LayoutPreferenceRepository,
     private readonly dataSource: DataSource,
@@ -79,62 +81,92 @@ export class LayoutPreferenceService extends EntityServiceImpl {
     sort_by: string,
     loggedInUser: UserData,
   ): Promise<string[]> {
-    const getTableMeta =
-      await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
-        entity_type,
-        entity_type,
-        'LIST',
-        loggedInUser?.organization_id,
+    try {
+      const getTableMeta =
+        await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
+          entity_type,
+          entity_type,
+          'LIST',
+          loggedInUser?.organization_id,
+        );
+
+      const tableName = getTableMeta?.data_source;
+
+      if (!tableName) {
+        throw new Error('Invalid or missing table name in metadata');
+      }
+
+      // Query DB to get distinct column values and counts
+      const rawData: { column_value: string; count: number }[] =
+        await this.dataSource
+          .createQueryBuilder()
+          .select(`${column} AS column_value`)
+          .addSelect(`COUNT(*) AS count`)
+          .from(tableName, tableName)
+          .where(`${column} IS NOT NULL`)
+          .andWhere(`organization_id = :organizationId`, {
+            organizationId: loggedInUser?.organization_id,
+          })
+          .andWhere(`level_id = :levelId`, { levelId: loggedInUser?.level_id })
+          .andWhere(`level_type = :levelType`, {
+            levelType: loggedInUser?.level_type,
+          })
+          .groupBy(column)
+          .getRawMany();
+
+      if (!rawData.length) {
+        return [];
+      }
+
+      // Prepare payload for resolver
+      const payloadBeforeResolved = rawData.map((row) => ({
+        [column]: row?.column_value,
+      }));
+
+      // Resolve column values using resolverService
+      const resolvedEntityList = await Promise.all(
+        payloadBeforeResolved.map((row) =>
+          this.resolverService.getResolvedData(loggedInUser, row, entity_type),
+        ),
       );
 
-    const tableName = getTableMeta?.data_source;
-
-    if (!tableName) {
-      throw new Error('Invalid or missing table name in metadata');
+      // Merge resolved names with counts
+      const resolvedWithCounts = rawData.map((row, index) => {
+        const resolvedValue =
+          resolvedEntityList[index]?.[column] || row.column_value;
+        return {
+          resolvedValue,
+          count: Number(row.count),
+        };
+      });
+
+      // Sort based on sort_by parameter
+      switch (sort_by) {
+        case 'asc':
+          resolvedWithCounts.sort((a, b) =>
+            a.resolvedValue.localeCompare(b.resolvedValue),
+          );
+          break;
+        case 'dsc':
+          resolvedWithCounts.sort((a, b) =>
+            b.resolvedValue.localeCompare(a.resolvedValue),
+          );
+          break;
+        case 'count_asc':
+          resolvedWithCounts.sort((a, b) => a.count - b.count);
+          break;
+        case 'count_dsc':
+          resolvedWithCounts.sort((a, b) => b.count - a.count);
+          break;
+        default:
+          break;
+      }
+
+      // Return only the resolved value list
+      return resolvedWithCounts.map((item) => item.resolvedValue);
+    } catch (error) {
+      this.logger.error(`getColumnValue ERROR: ${error.message}`, error.stack);
+      return [];
     }
-
-    // Query to get counts of distinct values in the column
-    const rawData: { column_value: string; count: number }[] =
-      await this.dataSource
-        .createQueryBuilder()
-        .select(`${column} AS column_value`)
-        .addSelect(`COUNT(*) AS count`)
-        .from(tableName, tableName)
-        .where(`${column} IS NOT NULL`)
-        .andWhere(`organization_id = :organizationId`, {
-          organizationId: loggedInUser?.organization_id,
-        })
-        .andWhere(`level_id = :levelId`, { levelId: loggedInUser?.level_id })
-        .andWhere(`level_type = :levelType`, {
-          levelType: loggedInUser?.level_type,
-        })
-        .groupBy(column)
-        .getRawMany();
-
-    // Convert result to map and sort
-    const result = Object.fromEntries(
-      rawData.map((row) => [row.column_value, Number(row.count)]),
-    );
-
-    const entries = Object.entries(result);
-
-    switch (sort_by) {
-      case 'asc':
-        entries.sort(([a], [b]) => a.localeCompare(b));
-        break;
-      case 'dsc':
-        entries.sort(([a], [b]) => b.localeCompare(a));
-        break;
-      case 'count_asc':
-        entries.sort(([, countA], [, countB]) => countA - countB);
-        break;
-      case 'count_dsc':
-        entries.sort(([, countA], [, countB]) => countB - countA);
-        break;
-      default:
-        break;
-    }
-
-    return entries.map(([value]) => value);
   }
 }