rez_core 4.0.5 → 4.0.8

package/package.json

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

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

@@ -18,7 +18,10 @@ import {
   UpdateUserIntegrationDto,
 } from '../dto/create-config.dto';
 import { FieldMapperService } from '../../mapper/service/field-mapper.service';
-import { COMM_TEMPLATE, ENTITYTYPE_MEDIA } from '../../../constant/global.constant';
+import {
+  COMM_TEMPLATE,
+  ENTITYTYPE_MEDIA,
+} from '../../../constant/global.constant';
 import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
 import { MediaDataService } from '../../meta/service/media-data.service';
 import axios from 'axios';
@@ -90,12 +93,12 @@ export class IntegrationService {
     private readonly sendGridApiStrategy: SendGridApiStrategy,
     private readonly configService: ConfigService,
     private readonly mediaService: MediaDataService,
-    @Inject('FieldMapperService') private readonly fieldMapperService: FieldMapperService,
+    @Inject('FieldMapperService')
+    private readonly fieldMapperService: FieldMapperService,
     private readonly entityService: EntityServiceImpl,
     @Inject(forwardRef(() => IntegrationQueueService))
     private readonly queueService?: IntegrationQueueService,
-  ) {
-  }
+  ) {}
 
   private deriveServiceType(
     integration_type: string,
@@ -107,15 +110,15 @@ export class IntegrationService {
   }
 
   async sendMessage({
-                      levelId,
-                      levelType,
-                      app_code,
-                      to,
-                      message,
-                      mode,
-                      priority = 1,
-                      user_id,
-                    }: SendMessageDto): Promise<IntegrationResult> {
+    levelId,
+    levelType,
+    app_code,
+    to,
+    message,
+    mode,
+    priority = 1,
+    user_id,
+  }: SendMessageDto): Promise<IntegrationResult> {
     try {
       // Get active communication configs for the level
       const configs = await this.getActiveConfigs(
@@ -195,7 +198,9 @@ export class IntegrationService {
       .where('config.level_id = :levelId', { levelId })
       .andWhere('config.level_type = :levelType', { levelType })
       .andWhere('config.app_code = :app_code', { app_code })
-      .andWhere('config.integration_type = :integration_type', { integration_type })
+      .andWhere('config.integration_type = :integration_type', {
+        integration_type,
+      })
       .andWhere('config.status = 1')
       .orderBy('config.is_default', 'DESC')
       .addOrderBy('config.priority', 'ASC')
@@ -706,7 +711,7 @@ export class IntegrationService {
             if (configJson?.[field]) {
               safeConfig[
                 `has${field.charAt(0).toUpperCase() + field.slice(1)}`
-                ] = true;
+              ] = true;
             }
           });
 
@@ -813,8 +818,9 @@ export class IntegrationService {
         const did = config.config_json.did;
 
         if (did) {
-
-          await this.entityMapperRepository.delete({integration_config_id: config.id})
+          await this.entityMapperRepository.delete({
+            integration_config_id: config.id,
+          });
 
           const entityMapper = this.entityMapperRepository.create({
             integration_config_id: config.id,
@@ -964,7 +970,7 @@ export class IntegrationService {
                 templateId: externalTemplateId,
                 variables,
                 richText,
-                subject
+                subject,
               };
 
               // Handle user integration if user_id provided
@@ -1055,7 +1061,7 @@ export class IntegrationService {
               ...enhancedConfig,
               templateId: externalTemplateId,
               variables,
-              richText
+              richText,
             };
 
             // Handle user integration if user_id provided
@@ -1071,11 +1077,7 @@ export class IntegrationService {
               }
             }
 
-            const result = await strategy.sendMessage(
-              to,
-              message,
-              finalConfig,
-            );
+            const result = await strategy.sendMessage(to, message, finalConfig);
 
             if (result.success) {
               this.logger.log(
@@ -1291,12 +1293,21 @@ export class IntegrationService {
     });
   }
 
-  private async processTemplate(
+  public async processTemplate(
     templateId: number,
     entity_type: any,
     entity_id: any,
-  ): Promise<{ variables?: Record<string, any>; externalTemplateId?: string; rich_text?: string; subject?: string }> {
-    const commTemplate: any = await this.entityService.getEntityData(COMM_TEMPLATE, templateId, {} as any);
+  ): Promise<{
+    variables?: Record<string, any>;
+    externalTemplateId?: string;
+    rich_text?: string;
+    subject?: string;
+  }> {
+    const commTemplate: any = await this.entityService.getEntityData(
+      COMM_TEMPLATE,
+      templateId,
+      {} as any,
+    );
     if (!commTemplate) {
       return {
         variables: {},
@@ -1308,7 +1319,7 @@ export class IntegrationService {
     if (commTemplate.mapper_id) {
       variables = await this.fieldMapperService.resolveData(
         commTemplate.mapper_id,
-        "LOOKUP",
+        'LOOKUP',
         entity_type,
         entity_id,
         {} as any,
@@ -1320,10 +1331,16 @@ export class IntegrationService {
 
       if (!richText) {
         if (commTemplate.markup_id) {
-          let url = await this.mediaService.getMediaDownloadUrl(commTemplate.markup_id, {}, 60000);
+          let url = await this.mediaService.getMediaDownloadUrl(
+            commTemplate.markup_id,
+            {},
+            60000,
+          );
           if (url) {
-            let response = await axios.get(url.signedUrl, { responseType: 'text' });
-            richText = response.data
+            let response = await axios.get(url.signedUrl, {
+              responseType: 'text',
+            });
+            richText = response.data;
           }
         }
       }
@@ -1335,7 +1352,7 @@ export class IntegrationService {
 
       return {
         rich_text: richText,
-        subject: commTemplate.subject
+        subject: commTemplate.subject,
       };
     }
 
@@ -2023,10 +2040,10 @@ export class IntegrationService {
 
   async getIntegrationConfigById(hubId: number): Promise<
     | (IntegrationConfig & {
-    config: IntegrationConfig;
-    linkedSource?: string;
-    configDetails?: any;
-  })
+        config: IntegrationConfig;
+        linkedSource?: string;
+        configDetails?: any;
+      })
     | null
   > {
     try {
@@ -2518,7 +2535,8 @@ export class IntegrationService {
       if (!userIntegration) {
         return {
           success: false,
-          error: 'User integration mapping not found. Please configure agent details.',
+          error:
+            'User integration mapping not found. Please configure agent details.',
         };
       }
 

package/src/module/meta/controller/media.controller.ts

@@ -28,6 +28,8 @@ export class MediaController {
       attribute_key: string;
       mapped_entity_type?: string;
       mapped_entity_id?: number;
+      parent_id?: number;
+      parent_type?: string;
     },
     @Req() req: Request & { user: any },
     @Res() res: Response,
@@ -40,6 +42,8 @@ export class MediaController {
       loggedInUser,
       body.mapped_entity_type,
       body.mapped_entity_id,
+      body.parent_id,
+      body.parent_type,
     );
     if (result) {
       res.status(HttpStatus.OK).json({
@@ -81,12 +85,23 @@ export class MediaController {
   }
 
   @Post('generateUploadPath')
-  async generateUploadPath(@Req() req: Request & { user: any }, @Query('mapped_entity_type') mapped_entity_type: string,
-                           @Query('mapped_entity_id') mapped_entity_id?: number,
-                           @Query('parent_id') parent_id?: number,
-                           @Query('parent_type') parent_type?: string,
-                           ) {
+  async generateUploadPath(
+    @Req() req: Request & { user: any },
+    @Body()
+    body: {
+      mapped_entity_type: string;
+      mapped_entity_id?: number;
+      parent_id?: number;
+      parent_type?: string;
+    },
+  ) {
     const loggedInUser = req.user.userData;
-    return this.mediaDataService.buildUploadPathGeneric(mapped_entity_type, loggedInUser, mapped_entity_id,parent_id, parent_type)
+    return this.mediaDataService.buildUploadPathGeneric(
+      body.mapped_entity_type,
+      loggedInUser,
+      body.mapped_entity_id,
+      body.parent_id,
+      body.parent_type,
+    );
   }
 }

package/src/module/meta/service/media-data.service.ts

@@ -1,17 +1,16 @@
 import { Injectable } from '@nestjs/common';
-import { EntityServiceImpl } from './entity-service-impl.service';
-import { MediaDataRepository } from '../repository/media-data.repository';
 import { ConfigService } from '@nestjs/config';
 import { S3 } from 'aws-sdk';
-import { MediaData } from '../entity/media-data.entity';
+import axios from 'axios';
+import { DataSource } from 'typeorm';
+import { v4 as uuidv4 } from 'uuid';
 import {
   ENTITYTYPE_MEDIA,
   STATUS_PENDING,
 } from '../../../constant/global.constant';
-import { v4 as uuidv4 } from 'uuid';
-import { OrganizationService } from '../../enterprise/service/organization.service';
-import { EntityMasterService } from './entity-master.service';
-import { DataSource } from 'typeorm';
+import { MediaData } from '../entity/media-data.entity';
+import { MediaDataRepository } from '../repository/media-data.repository';
+import { EntityServiceImpl } from './entity-service-impl.service';
 
 @Injectable()
 export class MediaDataService extends EntityServiceImpl {
@@ -41,6 +40,8 @@ export class MediaDataService extends EntityServiceImpl {
     loggedInUser,
     mappedEntityType?: string,
     mappedEntityId?: number,
+    parentId?: number,
+    parentType?: string,
   ) {
     if (!fileName || !mappedAttributeKey) {
       return null;
@@ -49,8 +50,16 @@ export class MediaDataService extends EntityServiceImpl {
 
     const id = uuidv4();
 
-    //TODO:
-    const s3Key = `uploads/${id}.${ext}`;
+    const s3Path =
+      (await this.buildUploadPathGeneric(
+        mappedEntityType || '',
+        loggedInUser,
+        mappedEntityId,
+        parentId,
+        parentType,
+      )) || `uploads`;
+
+    const s3Key = `${s3Path}/${id}.${ext}`;
 
     const uploadUrl = await this.s3.getSignedUrlPromise('putObject', {
       Bucket: this.bucketName,
@@ -71,6 +80,7 @@ export class MediaDataService extends EntityServiceImpl {
     }
     mediaData.media_url = s3Key;
 
+    //INSERT RECORD IN DOC TABLE
     const savedEntity = await super.createEntity(mediaData, loggedInUser);
 
     if (savedEntity) {
@@ -134,10 +144,12 @@ export class MediaDataService extends EntityServiceImpl {
       const mediaData = entityData as MediaData;
       let fileSize: number | undefined;
       if (this.bucketName) {
-        const head = await this.s3.headObject({
-          Bucket: this.bucketName,
-          Key: mediaData.media_url,
-        }).promise();
+        const head = await this.s3
+          .headObject({
+            Bucket: this.bucketName,
+            Key: mediaData.media_url,
+          })
+          .promise();
         fileSize = head.ContentLength;
       }
 
@@ -146,14 +158,19 @@ export class MediaDataService extends EntityServiceImpl {
         Key: mediaData.media_url,
         Expires: Number(expiresIn) || 60 * 5,
       });
-      return { signedUrl, fileName: mediaData.file_name, id: mediaData.id, size: fileSize };
+      return {
+        signedUrl,
+        fileName: mediaData.file_name,
+        id: mediaData.id,
+        size: fileSize,
+      };
     } catch (error) {
       console.error('Error generating signed URL for media:', error);
       throw new Error('Failed to generate signed URL');
     }
   }
 
-  public async buildUploadPathGeneric(
+  public async buildUploadPathGenericdd(
     mappedEntityType: string,
     loggedInUser,
     mappedEntityId?: number,
@@ -161,7 +178,10 @@ export class MediaDataService extends EntityServiceImpl {
     parentType?: string,
   ) {
     // 1️⃣ Fetch entity metadata
-    const entityMaster = await this.entityMasterService.getEntityData(mappedEntityType, loggedInUser);
+    const entityMaster = await this.entityMasterService.getEntityData(
+      mappedEntityType,
+      loggedInUser,
+    );
     if (!entityMaster) {
       throw new Error(`Entity master not found for ${mappedEntityType}`);
     }
@@ -177,17 +197,115 @@ export class MediaDataService extends EntityServiceImpl {
     const replacements: Record<string, string | null> = {};
 
     // --- ORG ---
-    let organizationData = await this.dataSource.query('SELECT * FROM sso_organization WHERE id = ?', [loggedInUser.organization_id]);
+    let organizationData = await this.dataSource.query(
+      'SELECT * FROM sso_organization WHERE id = ?',
+      [loggedInUser.organization_id],
+    );
     replacements['org_code'] = organizationData[0].code;
 
     // --- LEVEL CODE ---
-    // Determine which entity to use for level_code
-    const levelEntityId = entityOverwrite ? mappedEntityId : loggedInUser.level_id;
-    const levelEntityData = await super.getEntityData(loggedInUser.level_type, levelEntityId, loggedInUser);
+    // Priority: If parent is provided, use parent for level_code; otherwise use normal logic
+    let levelEntityId: number;
+    let levelEntityType: string;
+
+    if (parentId && parentType) {
+      // When parent is provided, parent becomes the level_code
+      levelEntityId = parentId;
+      levelEntityType = parentType;
+    } else {
+      // Normal logic: determine which entity to use for level_code
+      levelEntityId = entityOverwrite ? mappedEntityId : loggedInUser.level_id;
+      levelEntityType = entityOverwrite
+        ? mappedEntityType
+        : loggedInUser.level_type;
+    }
+
+    // Get entity data for level_code
+    const getEntityData = await this.dataSource.query(
+      `SELECT * FROM cr_entity_master WHERE mapped_entity_type = ? and organization_id = ?`,
+      [levelEntityType, loggedInUser.organization_id],
+    );
+
+    if (getEntityData.length == 0) return null;
+    const levelEntityDataResult = await this.dataSource.query(
+      `SELECT * FROM ${getEntityData[0]?.db_table_name} WHERE id = ?`,
+      [levelEntityId],
+    );
+
+    const levelEntityData = levelEntityDataResult[0] || null;
+
     if (levelEntityData?.code) {
       replacements['level_code'] = levelEntityData.code; // universal alias
     }
 
+    // --- MAPPED ENTITY CODE (when parent is provided) ---
+    // When parent is provided, the mapped entity becomes an additional level
+    if (parentId && parentType && mappedEntityId && mappedEntityType) {
+      const mappedEntityKey = `${mappedEntityType.toLowerCase()}_code`;
+      const mappedEntityData = await super.getEntityData(
+        mappedEntityType,
+        mappedEntityId,
+        loggedInUser,
+      );
+      if (mappedEntityData?.code) {
+        replacements[mappedEntityKey] = mappedEntityData.code;
+
+        // Modify path template to include mapped entity
+        // Example: ${org_code}/${level_code} becomes ${org_code}/${level_code}/${tem_code}
+        const mappedVariable = `\${${mappedEntityKey}}`;
+        if (!pathTemplate.includes(mappedVariable)) {
+          pathTemplate = pathTemplate + `/${mappedVariable}`;
+        }
+      }
+    }
+
+    // --- TEMPLATE CODE (if parent is provided) ---
+    // Special handling for template_code when parent_id and parent_type are provided
+    if (parentId && parentType) {
+      // const templateEntityData = await super.getEntityData(
+      //   parentType,
+      //   parentId,
+      //   loggedInUser,
+      // );
+
+      // Get entity data for level_code
+      const getEntityData = await this.dataSource.query(
+        `SELECT * FROM cr_entity_master WHERE mapped_entity_type = ? and organization_id = ?`,
+        [mappedEntityType, loggedInUser.organization_id],
+      );
+
+      if (getEntityData.length == 0) return null;
+      const levelEntityDataResult = await this.dataSource.query(
+        `SELECT * FROM ${getEntityData[0]?.db_table_name} WHERE id = ?`,
+        [mappedEntityId],
+      );
+
+      if (
+        levelEntityDataResult?.[0].code &&
+        parentType != 'SCH' &&
+        loggedInUser.level_type != 'SCH'
+      ) {
+        replacements['template_code'] = levelEntityDataResult[0].code;
+        // If we have parent template, modify the path to include it
+        pathTemplate = '${org_code}/template/${template_code}';
+      } else {
+        const getEntityData = await this.dataSource.query(
+          `SELECT * FROM cr_entity_master WHERE mapped_entity_type = ? and organization_id = ?`,
+          [mappedEntityType, loggedInUser.organization_id],
+        );
+
+        if (getEntityData.length == 0) return null;
+        const levelEntityDataResult = await this.dataSource.query(
+          `SELECT * FROM ${getEntityData[0]?.db_table_name} WHERE id = ?`,
+          [mappedEntityId],
+        );
+
+        replacements['template_code'] = levelEntityDataResult?.[0].code;
+
+        pathTemplate = '${org_code}/${level_code}/template/${template_code}';
+      }
+    }
+
     // --- Dynamic variables inside path ---
     const matches = pathTemplate.match(/\$\{(\w+)\}/g) || [];
 
@@ -196,29 +314,48 @@ export class MediaDataService extends EntityServiceImpl {
       if (replacements[key]) continue; // already resolved
 
       if (key === 'org_code') continue; // already set
+      if (key === 'level_code') continue; // already set above
+      if (key === 'template_code') continue; // handled above if parent is provided
+
       if (key.endsWith('_code')) {
         // derive entity type dynamically
         const entityType = key.replace('_code', '').toUpperCase();
 
         let entityId: number | undefined;
-        if (parentType?.toUpperCase() === entityType && parentId) {
-          entityId = parentId;
+
+        // Special handling for template_code - use parent if available, otherwise mapped entity
+        if (key === 'template_code') {
+          if (parentType?.toUpperCase() === 'TEMPLATE' && parentId) {
+            entityId = parentId;
+          } else if (mappedEntityType === 'TEMPLATE') {
+            entityId = mappedEntityId;
+          }
         } else {
-          entityId = mappedEntityId;
+          // For other _code variables, check if parent matches the entity type
+          if (parentType?.toUpperCase() === entityType && parentId) {
+            entityId = parentId;
+          } else if (mappedEntityType === entityType) {
+            entityId = mappedEntityId;
+          }
         }
 
         // Generic lookup
         if (entityId) {
-          const entityData = await super.getEntityData(entityType, entityId, loggedInUser);
+          const entityData = await super.getEntityData(
+            entityType,
+            entityId,
+            loggedInUser,
+          );
           replacements[key] = entityData?.code ?? null;
         }
       }
     }
 
     // --- ORG special case ---
-    // If ORG level & overwrite = 0 → remove level_code variable
+    // If ORG level & overwrite = 0 → use org_code, otherwise use the mapped entity's code
     if (loggedInUser.level_type === 'ORG' && entityOverwrite === 0) {
-      replacements['level_code'] = null;
+      // When overwrite is 0 and user is ORG level, but we want to use mapped entity
+      // Don't set level_code to null - it should already be set above based on entityOverwrite logic
     }
 
     // 3️⃣ Final substitution and cleanup
@@ -229,12 +366,140 @@ export class MediaDataService extends EntityServiceImpl {
     return null;
   }
 
+  public async buildUploadPathGeneric(
+    mappedEntityType: string,
+    loggedInUser,
+    mappedEntityId?: number,
+    parentId?: number,
+    parentType?: string,
+  ) {
+    //APPCODE
+    let appCode = '';
+
+    let org_id = loggedInUser.organization_id;
+    let level_type = loggedInUser.level_type;
+    let level_id =
+      loggedInUser.level_type == 'ORG' && mappedEntityType == 'SCH'
+        ? mappedEntityId
+        : loggedInUser.level_id;
+
+    let organizationData = {};
+    let levelData = {};
+    let mappedEntityData = {};
+
+    if (loggedInUser && loggedInUser.appcode) {
+      appCode = loggedInUser.appcode;
+    }
+
+    if (appCode && appCode != 'ADM') {
+      const baseUrl = this.configService.get<string>('REDIRECT_BE_URL');
+
+      // Prepare the query string
+      const queryParams = new URLSearchParams({
+        loggedInUser: JSON.stringify(loggedInUser),
+      }).toString();
+
+      organizationData = await axios
+        .get(`${baseUrl}/organization/public/?${queryParams}`)
+        .then((res) => res.data)
+        .catch((err) => {
+          console.error('Error fetching organization data:', err.message);
+          return null;
+        });
+
+      levelData = await axios
+        .get(`${baseUrl}/school/public/?${queryParams}`)
+        .then((res) => res.data)
+        .catch((err) => {
+          console.error('Error fetching school data:', err.message);
+          return null;
+        });
+    } else {
+      organizationData = await this.dataSource.query(
+        'SELECT * FROM adm_org_profile WHERE id = ?',
+        [loggedInUser.organization_id],
+      );
+      levelData = await this.dataSource.query(
+        'SELECT * FROM adm_school_profile WHERE id = ?',
+        [loggedInUser.level_id],
+      );
+    }
+
+    console.log(levelData);
+
+    // 1️⃣ Fetch entity metadata
+    // const uploadEntity = await this.entityMasterService.getEntityData(
+    //   mappedEntityType,
+    //   loggedInUser,
+    // );
+    // if (!uploadEntity) {
+    //   throw new Error(`Entity master not found for ${mappedEntityType}`);
+    // }
+
+    let subfolder =
+      mappedEntityType == level_type
+        ? 'data'
+        : parentType
+          ? `${parentType}/${parentId}/${mappedEntityType}`
+          : mappedEntityType;
+    let path =
+      '${org_code}/${level_code}/' +
+      (subfolder !== 'data'
+        ? `${subfolder}/${mappedEntityId}`
+        : `${subfolder}`);
+
+    // 2️⃣ Prepare replacement map
+    const replacements: Record<string, string | null> = {};
+    replacements['org_code'] = organizationData[0]?.code;
+    replacements['level_code'] = levelData[0]?.code; // universal alias
+
+    // 3️⃣ Final substitution and cleanup
+    if (path) {
+      const finalPath = this.resolveUploadPath(path, replacements);
+      return finalPath;
+    }
+    return null;
+  }
+
   /**
    * Replace placeholders with actual values, remove missing variables
    */
-  private resolveUploadPath(template: string, replacements: Record<string, string | null>) {
+  private resolveUploadPath(
+    template: string,
+    replacements: Record<string, string | null>,
+  ) {
     let path = template;
     path = path.replace(/\$\{(\w+)\}/g, (_, key) => replacements[key] || '');
     return path.replace(/\/+/g, '/').replace(/\/$/, '');
   }
+
+  /**
+   * Helper method to build upload path for different scenarios
+   *
+   * @param mappedEntityType - The main entity type (e.g., 'LEAD', 'SCH')
+   * @param loggedInUser - Current user context
+   * @param mappedEntityId - ID of the main entity
+   * @param parentId - Optional parent entity ID (e.g., template ID)
+   * @param parentType - Optional parent entity type (e.g., 'TEMPLATE')
+   * @returns Promise<string | null> - The resolved upload path
+   *
+   * Examples:
+   * - buildUploadPath('LEAD', user, 123) -> "ORG1/template/SCH1"
+   * - buildUploadPath('LEAD', user, 123, 456, 'TEMPLATE') -> "ORG1/template/SCH1/TEMPLATE1"
+   */
+  async buildUploadPath(
+    mappedEntityType: string,
+    loggedInUser: any,
+    mappedEntityId?: number,
+    parentId?: number,
+    parentType?: string,
+  ): Promise<string | null> {
+    return this.buildUploadPathGeneric(
+      mappedEntityType,
+      loggedInUser,
+      mappedEntityId,
+      parentId,
+      parentType,
+    );
+  }
 }

package/src/module/meta/service/view-master.service.ts

@@ -90,7 +90,7 @@ export class ViewMasterService extends EntityServiceImpl {
 
       // Make the GET request with query parameters
       const response = await axios.get<any>(
-        `${baseUrl}/school/theme_json/${loggedInUserData?.level_id}`,
+        `${baseUrl}/school/public/theme_json/${loggedInUserData?.level_id}`,
 
         {
           headers: {