rez_core 4.0.184 → 4.0.187

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

@@ -3,6 +3,7 @@ import { DataSource } from 'typeorm';
 import { GenericMessageDto, IntegrationService } from './integration.service';
 import { GoogleService } from './calendar-event.service';
 import { IcsMeetingService } from 'src/module/ics/service/ics.service';
+import { LoggingService } from 'src/utils/service/loggingUtil.service';
 
 @Injectable()
 export class WrapperService {
@@ -13,6 +14,7 @@ export class WrapperService {
     private readonly integrationService: IntegrationService,
     private readonly googleService: GoogleService,
     private readonly icsService: IcsMeetingService,
+    private readonly loggingService: LoggingService,
   ) {}
 
   /**
@@ -20,15 +22,27 @@ export class WrapperService {
    */
   async sendMailWrapper(payload: any, loggedInUser: any) {
     try {
-      this.logger.log(
-        `sendMailWrapper called. User: ${JSON.stringify(loggedInUser)}, Payload: ${JSON.stringify(payload)}`,
+      this.loggingService.log(
+        'debug',
+        'wrapperService',
+        'sendMailWrapper',
+        `sendMailWrapper called. User: ${JSON.stringify(
+          loggedInUser,
+        )}, Payload: ${JSON.stringify(payload)}`,
+        [],
+        [],
       );
 
       const { level_id, level_type, organization_id } = loggedInUser;
 
       // 1. Check for config at user’s level
-      this.logger.debug(
+      this.loggingService.log(
+        'debug',
+        'wrapperService',
+        'sendMailWrapper',
         `Fetching configs for level_id=${level_id}, level_type=${level_type}`,
+        [],
+        [],
       );
       const configs = await this.datasource.query(
         `SELECT * FROM frm_integration_config 
@@ -38,27 +52,51 @@ export class WrapperService {
            AND integration_type = 'EMAIL'`,
         [level_id, level_type],
       );
-      this.logger.debug(`Configs found: ${JSON.stringify(configs)}`);
+
+      this.loggingService.log(
+        'debug',
+        'wrapperService',
+        'sendMailWrapper',
+        `Configs found: ${JSON.stringify(configs)}`,
+        [],
+        [],
+      );
 
       let templateCode: string | undefined;
 
       if (payload.templateCode) {
-        this.logger.debug(
+        this.loggingService.log(
+          'debug',
+          'wrapperService',
+          'sendMailWrapper',
           `Looking up templateCode=${payload.templateCode} for current level`,
+          [],
+          [],
         );
+
         const template = await this.datasource.query(
           `SELECT rich_text FROM frm_wf_comm_template WHERE code = $1 AND level_id = $2 AND level_type = $3 LIMIT 1`,
           [payload.templateCode, level_id, level_type],
         );
-        this.logger.debug(
+        this.loggingService.log(
+          'debug',
+          'wrapperService',
+          'sendMailWrapper',
           `Template lookup result: ${JSON.stringify(template)}`,
+          [],
+          [],
         );
 
         if (template && template.length > 0) {
           templateCode = template[0]?.rich_text;
         } else {
-          this.logger.warn(
+          this.loggingService.log(
+            'warn',
+            'wrapperService',
+            'sendMailWrapper',
             `No template found for templateCode=${payload.templateCode} and current level`,
+            [],
+            [],
           );
         }
       }
@@ -66,7 +104,15 @@ export class WrapperService {
       let payloadSendMail: GenericMessageDto;
 
       if (configs && configs.length > 0) {
-        this.logger.debug(`Using user-level configs`);
+        this.loggingService.log(
+          'debug',
+          'wrapperService',
+          'sendMailWrapper',
+          `Using user-level configs`,
+          [],
+          [],
+        );
+
         payloadSendMail = {
           levelId: level_id,
           levelType: level_type,
@@ -84,21 +130,40 @@ export class WrapperService {
           organization_id: loggedInUser.organization_id,
         };
       } else {
-        this.logger.warn(
+        this.loggingService.log(
+          'warn',
+          'wrapperService',
+          'sendMailWrapper',
           `No user-level configs found. Falling back to ORG-level`,
+          [],
+          [],
         );
+
         const fallbackConfigs = await this.datasource.query(
           `SELECT * FROM frm_integration_config 
            WHERE level_type = 'ORG' 
              AND integration_type = 'EMAIL'
              AND status = 1`,
         );
-        this.logger.debug(
+
+        this.loggingService.log(
+          'debug',
+          'wrapperService',
+          'sendMailWrapper',
           `ORG-level configs: ${JSON.stringify(fallbackConfigs)}`,
+          [],
+          [],
         );
 
         if (!fallbackConfigs || fallbackConfigs.length === 0) {
-          this.logger.warn('No active email communication config found');
+          this.loggingService.log(
+            'warn',
+            'wrapperService',
+            'sendMailWrapper',
+            'No active email communication config found',
+            [],
+            [],
+          );
         }
 
         payloadSendMail = {
@@ -119,15 +184,27 @@ export class WrapperService {
         };
       }
 
-      this.logger.debug(
-        `Final payload for IntegrationService: ${JSON.stringify(payloadSendMail)}`,
+      this.loggingService.log(
+        'debug',
+        'wrapperService',
+        'sendMailWrapper',
+        `Final payload for IntegrationService: ${JSON.stringify(
+          payloadSendMail,
+        )}`,
+        [],
+        [],
       );
 
       const result =
         await this.integrationService.sendGenericMessage(payloadSendMail);
 
-      this.logger.log(
+      this.loggingService.log(
+        'log',
+        'wrapperService',
+        'sendMailWrapper',
         `sendMailWrapper SUCCESS. Result: ${JSON.stringify(result)}`,
+        [],
+        [],
       );
 
       return {
@@ -135,7 +212,14 @@ export class WrapperService {
         data: result,
       };
     } catch (error: any) {
-      this.logger.error(`sendMailWrapper ERROR: ${error.message}`, error.stack);
+      this.loggingService.log(
+        'error',
+        'wrapperService',
+        'sendMailWrapper',
+        `sendMailWrapper ERROR: ${error.message}`,
+        [],
+        [error.stack], // Sending stack trace as additional data
+      );
       return {
         success: false,
         error: error.message,
@@ -149,17 +233,29 @@ export class WrapperService {
 
   async sendCommunicationWrapperService(entity: any, loggedInUser: any) {
     try {
-      this.logger.log(
+      this.loggingService.log(
+        'log',
+        'wrapperService',
+        'sendCommunicationWrapperService',
         `sendCommunicationWrapper called. User: ${JSON.stringify(
           loggedInUser,
         )}, Payload: ${JSON.stringify(entity)}`,
+        [],
+        [],
       );
 
       const { level_id, level_type, appcode, organization_id } = loggedInUser;
 
       // Check if active configs exist for current user's level
-      this.logger.debug(
-        `Checking active ${entity.type || 'EMAIL'} configs for level_id=${level_id}, level_type=${level_type}, app_code=${appcode}`,
+      this.loggingService.log(
+        'debug',
+        'wrapperService',
+        'sendCommunicationWrapperService',
+        `Checking active ${
+          entity.type || 'EMAIL'
+        } configs for level_id=${level_id}, level_type=${level_type}, app_code=${appcode}`,
+        [],
+        [],
       );
 
       let configs = await this.integrationService.getActiveConfigs(
@@ -174,8 +270,13 @@ export class WrapperService {
 
       // Fallback to ORG-level if no configs found
       if (!configs || configs.length === 0) {
-        this.logger.warn(
+        this.loggingService.log(
+          'warn',
+          'wrapperService',
+          'sendCommunicationWrapperService',
           `No active configs found for ${level_type}:${level_id}, falling back to ORG-level`,
+          [],
+          [],
         );
 
         configs = await this.integrationService.getActiveConfigs(
@@ -190,7 +291,14 @@ export class WrapperService {
       }
 
       if (!configs || configs.length === 0) {
-        this.logger.error('No active configurations found at any level.');
+        this.loggingService.log(
+          'error',
+          'wrapperService',
+          'sendCommunicationWrapperService',
+          'No active configurations found at any level.',
+          [],
+          [],
+        );
         throw new Error('No active configurations found.');
       }
 
@@ -198,8 +306,13 @@ export class WrapperService {
       let resolvedTemplateId = entity?.templateId;
 
       if (entity.template_code) {
-        this.logger.debug(
+        this.loggingService.log(
+          'debug',
+          'wrapperService',
+          'sendCommunicationWrapperService',
           `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
@@ -214,8 +327,13 @@ export class WrapperService {
 
         // Fallback to ORG + organization_id if not found
         if (!templates || templates.length === 0) {
-          this.logger.warn(
+          this.loggingService.log(
+            'warn',
+            'wrapperService',
+            'sendCommunicationWrapperService',
             `No template found for ${entity.template_code} at provided level. Falling back to ORG-level.`,
+            [],
+            [],
           );
 
           templates = await this.datasource.query(
@@ -230,12 +348,22 @@ export class WrapperService {
 
         if (templates && templates.length > 0) {
           resolvedTemplateId = templates[0]?.id;
-          this.logger.debug(
+          this.loggingService.log(
+            'debug',
+            'wrapperService',
+            'sendCommunicationWrapperService',
             `Template resolved for code=${entity.template_code}, id=${resolvedTemplateId}`,
+            [],
+            [],
           );
         } else {
-          this.logger.warn(
+          this.loggingService.log(
+            'warn',
+            'wrapperService',
+            'sendCommunicationWrapperService',
             `No template found for code=${entity.template_code} at any level.`,
+            [],
+            [],
           );
         }
       }
@@ -261,23 +389,37 @@ export class WrapperService {
         organization_id: organization_id,
       } as any;
 
-      this.logger.debug(
+      this.loggingService.log(
+        'debug',
+        'wrapperService',
+        'sendCommunicationWrapperService',
         `Final payload for sendGenericMessage: ${JSON.stringify(mailPayload)}`,
+        [],
+        [],
       );
 
       // Step 5️⃣ Send via Integration Service
       const result =
         await this.integrationService.sendGenericMessage(mailPayload);
 
-      this.logger.log(
+      this.loggingService.log(
+        'log',
+        'wrapperService',
+        'sendCommunicationWrapperService',
         `sendCommunicationWrapper SUCCESS. Result: ${JSON.stringify(result)}`,
+        [],
+        [],
       );
 
       return result;
     } catch (error: any) {
-      this.logger.error(
+      this.loggingService.log(
+        'error',
+        'wrapperService',
+        'sendCommunicationWrapperService',
         `sendCommunicationWrapper ERROR: ${error.message}`,
-        error.stack,
+        [],
+        [error.stack],
       );
       return {
         success: false,
@@ -296,8 +438,15 @@ export class WrapperService {
     mapped_entities?: any,
   ) {
     try {
-      this.logger.log(
-        `scheduleMeetingWrapper called by user=${loggedInUser?.id || 'unknown'} Payload=${JSON.stringify(payload)}`,
+      this.loggingService.log(
+        'log',
+        'wrapperService',
+        'scheduleMeetingWrapper',
+        `scheduleMeetingWrapper called by user=${
+          loggedInUser?.id || 'unknown'
+        } Payload=${JSON.stringify(payload)}`,
+        [],
+        [],
       );
 
       // Normalize emails (to, cc, bcc → attendees)
@@ -342,7 +491,14 @@ export class WrapperService {
       }
 
       // ---- Step 2: Check ORG-level configs ----
-      this.logger.log(`No user-level config found, checking ORG-level...`);
+      this.loggingService.log(
+        'log',
+        'wrapperService',
+        'scheduleMeetingWrapper',
+        `No user-level config found, checking ORG-level...`,
+        [],
+        [],
+      );
 
       const orgConfigs = await this.datasource.query(
         `SELECT * FROM frm_integration_config 
@@ -361,7 +517,14 @@ export class WrapperService {
         'EMAIL',
       );
 
-      this.logger.debug(`ORG configs found: ${JSON.stringify(orgConfigs)}`);
+      this.loggingService.log(
+        'debug',
+        'wrapperService',
+        'scheduleMeetingWrapper',
+        `ORG configs found: ${JSON.stringify(orgConfigs)}`,
+        [],
+        [],
+      );
 
       if (integrationConfig) {
         return {
@@ -377,9 +540,13 @@ export class WrapperService {
         };
       }
     } catch (error: any) {
-      this.logger.error(
+      this.loggingService.log(
+        'error',
+        'wrapperService',
+        'scheduleMeetingWrapper',
         `scheduleMeetingWrapper ERROR: ${error.message}`,
-        error.stack,
+        [],
+        [error.stack],
       );
       return { success: false, error: error.message };
     }
@@ -389,14 +556,28 @@ export class WrapperService {
    * Fetch credentials JSON by config ID
    */
   private async getConfigCred(configId: number) {
-    this.logger.debug(`Fetching config JSON for configId=${configId}`);
+    this.loggingService.log(
+      'debug',
+      'wrapperService',
+      'getConfigCred',
+      `Fetching config JSON for configId=${configId}`,
+      [],
+      [],
+    );
     const configRes = await this.datasource.query(
       `SELECT config_json 
        FROM frm_integration_config 
        WHERE id = $1`,
       [configId],
     );
-    this.logger.debug(`Config fetch result: ${JSON.stringify(configRes)}`);
+    this.loggingService.log(
+      'debug',
+      'wrapperService',
+      'getConfigCred',
+      `Config fetch result: ${JSON.stringify(configRes)}`,
+      [],
+      [],
+    );
     return configRes?.[0]?.config_json || null;
   }
 
@@ -408,7 +589,14 @@ export class WrapperService {
     organizationId: number,
     mapped_entities?: any,
   ) {
-    this.logger.log(`Generating ICS file. Payload: ${JSON.stringify(payload)}`);
+    this.loggingService.log(
+      'log',
+      'wrapperService',
+      'sendIcsInvite',
+      `Generating ICS file. Payload: ${JSON.stringify(payload)}`,
+      [],
+      [],
+    );
 
     if (payload.template_code) {
       let templates = await this.datasource.query(
@@ -435,9 +623,16 @@ export class WrapperService {
       payload,
       activeConfig?.config_json,
     );
-    this.logger.debug(`ICS generated (base64 length: ${base64String?.length})`);
+    this.loggingService.log(
+      'debug',
+      'wrapperService',
+      'sendIcsInvite',
+      `ICS generated (base64 length: ${base64String?.length})`,
+      [],
+      [],
+    );
 
-    //  Normalize attendees
+    // Normalize attendees
     const attendeeEmails =
       payload.attendees?.flatMap((a) =>
         Array.isArray(a.email) ? a.email : [a.email],
@@ -483,12 +678,24 @@ export class WrapperService {
       mapped_entities,
     };
 
-    this.logger.debug(
+    this.loggingService.log(
+      'debug',
+      'wrapperService',
+      'sendIcsInvite',
       `Final payload for ICS send: ${JSON.stringify(payloadSendMail)}`,
+      [],
+      [],
     );
     const result =
       await this.integrationService.sendGenericMessage(payloadSendMail);
-    this.logger.log(`ICS mail send result: ${JSON.stringify(result)}`);
+    this.loggingService.log(
+      'log',
+      'wrapperService',
+      'sendIcsInvite',
+      `ICS mail send result: ${JSON.stringify(result)}`,
+      [],
+      [],
+    );
     return result;
   }
 }

package/src/module/linked_attributes/controller/linked_attributes.controller.ts

@@ -0,0 +1,10 @@
+import { Controller, Inject } from '@nestjs/common';
+import { LinkedAttributesService } from '../service/linked_attributes.service';
+
+@Controller('linked-attributes')
+export class LinkedAttributesController {
+  constructor(
+    @Inject('LinkedAttributesService')
+    private readonly linkedAttributesService: LinkedAttributesService,
+  ) {}
+}

package/src/module/linked_attributes/entity/linked_attribute.entity.ts

@@ -0,0 +1,48 @@
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'frm_linked_attribute' })
+export class LinkedAttributes extends BaseEntity {
+  @Column({ name: 'field_name', type: 'varchar', length: 100, nullable: true })
+  field_name: string;
+
+  @Column({
+    name: 'attribute_key',
+    type: 'varchar',
+    length: 100,
+    nullable: true,
+  })
+  attribute_key: string;
+
+  @Column({
+    name: 'applicable_attribute_key',
+    type: 'varchar',
+    length: 100,
+    nullable: true,
+  })
+  applicable_attribute_key: string;
+
+  @Column({
+    name: 'mapped_entity_type',
+    type: 'varchar',
+    length: 50,
+    nullable: true,
+  })
+  mapped_entity_type: string;
+
+  @Column({
+    name: 'applicable_entity_type',
+    type: 'varchar',
+    length: 50,
+    nullable: true,
+  })
+  applicable_entity_type: string;
+
+  @Column({
+    name: 'saved_filter_code',
+    type: 'varchar',
+    length: 100,
+    nullable: true,
+  })
+  saved_filter_code: string;
+}

package/src/module/linked_attributes/linked_attributes.module.ts

@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common';
+import { EntityModule } from '../meta/entity.module';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { LinkedAttributes } from './entity/linked_attribute.entity';
+import { LinkedAttributesController } from './controller/linked_attributes.controller';
+import { LinkedAttributesService } from './service/linked_attributes.service';
+
+@Module({
+  imports: [EntityModule, TypeOrmModule.forFeature([LinkedAttributes])],
+  controllers: [LinkedAttributesController],
+  providers: [
+    { provide: 'LinkedAttributesService', useClass: LinkedAttributesService },
+  ],
+  exports: ['LinkedAttributesService'],
+})
+export class LinkedAttributesModule {}

package/src/module/linked_attributes/repository/linked_attribute.repository.ts

@@ -0,0 +1,12 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { LinkedAttributes } from '../entity/linked_attribute.entity';
+
+@Injectable()
+export class LinkedAttributesRepository {
+  constructor(
+    @InjectRepository(LinkedAttributes)
+    private readonly linkedAttributesRepo: Repository<LinkedAttributes>,
+  ) {}
+}

package/src/module/linked_attributes/service/linked_attributes.service.ts

@@ -0,0 +1,22 @@
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+
+@Injectable()
+export class LinkedAttributesService extends EntityServiceImpl {
+  constructor() {
+    super();
+  }
+
+  async createEntity(payload: any, loggedInUser: any): Promise<any> {
+    // Auto-generate attribute_key if missing OR empty
+    if (!payload.attribute_key || payload.attribute_key.trim() === '') {
+      payload.attribute_key = payload.field_name
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, '_'); // replace spaces with underscore
+    }
+
+    // Pass to base class create method
+    return super.createEntity(payload, loggedInUser);
+  }
+}

package/src/module/mapper/service/field-mapper.service.ts

@@ -151,12 +151,13 @@ export class FieldMapperService extends EntityServiceImpl {
               const targetEntityIds = relations.map((r) => r.target_entity_id);
 
               this.loggingService.log(
-                'package',
+                'debug',
                 'fieldMapperService',
-                'targetEntityIds',
-                targetEntityIds,
+                'resolveData',
+                `Resolved targetEntityIds: ${targetEntityIds} for entityType: ${entityType}`,
+                [parent_type, parent_id, field.mapped_entity_type],
+                [],
               );
-
               if (targetEntityIds.length > 0) {
                 if (filterCode && filterCode !== 'default') {
                   let filterResponse =
@@ -177,10 +178,14 @@ export class FieldMapperService extends EntityServiceImpl {
                     });
 
                   this.loggingService.log(
-                    'package',
+                    'debug',
                     'fieldMapperService',
-                    'filterResponse',
-                    `${filterResponse}`,
+                    'resolveData',
+                    `Filter response for filterCode: ${filterCode} is ${JSON.stringify(
+                      filterResponse,
+                    )}`,
+                    [entityType, filterCode, targetEntityIds],
+                    [],
                   );
 
                   inMemory[entityType][filterCode] =