rez_core 5.0.85 → 5.0.86

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

@@ -1,23 +1,18 @@
 import { Injectable, Logger } from '@nestjs/common';
-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';
-import { MediaDataService } from 'src/module/meta/service/media-data.service';
-import axios from 'axios';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 
 @Injectable()
 export class WrapperService {
   private readonly logger = new Logger(WrapperService.name);
 
   constructor(
-    private readonly datasource: DataSource,
     private readonly integrationService: IntegrationService,
-    private readonly googleService: GoogleService,
     private readonly icsService: IcsMeetingService,
     private readonly loggingService: LoggingService,
-    private readonly mediaService: MediaDataService,
+    private readonly reflectionHelper: ReflectionHelper,
   ) {}
 
   /**
@@ -47,14 +42,16 @@ export class WrapperService {
         [],
         [],
       );
-      const configs = await this.datasource.query(
-        `SELECT * FROM frm_integration_config 
-         WHERE level_id = $1
-           AND level_type = $2 
-           AND status = 1
-           AND integration_type = 'EMAIL'`,
-        [level_id, level_type],
-      );
+      const intergrationConfigRepo =
+        this.reflectionHelper.getRepoService('IntegrationConfig');
+      const configs = await intergrationConfigRepo.find({
+        where: {
+          level_id: level_id,
+          level_type: level_type,
+          status: 1,
+          integration_type: 'EMAIL',
+        },
+      });
 
       this.loggingService.log(
         'debug',
@@ -77,10 +74,17 @@ export class WrapperService {
           [],
         );
 
-        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],
-        );
+        const templateRepo =
+          this.reflectionHelper.getRepoService('CommTemplate');
+
+        const template = await templateRepo.findOne({
+          where: {
+            code: payload.templateCode,
+            level_id: level_id,
+            level_type: level_type,
+          },
+        });
+
         this.loggingService.log(
           'debug',
           'wrapperService',
@@ -90,8 +94,8 @@ export class WrapperService {
           [],
         );
 
-        if (template && template.length > 0) {
-          templateCode = template[0]?.rich_text;
+        if (template) {
+          templateCode = template.rich_text;
         } else {
           this.loggingService.log(
             'warn',
@@ -142,12 +146,13 @@ export class WrapperService {
           [],
         );
 
-        const fallbackConfigs = await this.datasource.query(
-          `SELECT * FROM frm_integration_config 
-           WHERE level_type = 'ORG' 
-             AND integration_type = 'EMAIL'
-             AND status = 1`,
-        );
+        const fallbackConfigs = await intergrationConfigRepo.find({
+          where: {
+            level_type: 'ORG',
+            integration_type: 'EMAIL',
+            status: 1,
+          },
+        });
 
         this.loggingService.log(
           'debug',
@@ -319,14 +324,15 @@ export class WrapperService {
         );
 
         // Try to find template at user's level first
-        let templates = await this.datasource.query(
-          `SELECT id FROM frm_wf_comm_template 
-         WHERE code = $1 
-           AND level_id = $2 
-           AND level_type = $3 
-         LIMIT 1`,
-          [entity.template_code, level_id, level_type],
-        );
+        const commTemplateRepo =
+          this.reflectionHelper.getRepoService('CommTemplate');
+        let templates = await commTemplateRepo.find({
+          where: {
+            code: entity.template_code,
+            level_id: level_id,
+            level_type: level_type,
+          },
+        });
 
         // Fallback to ORG + organization_id if not found
         if (!templates || templates.length === 0) {
@@ -339,14 +345,12 @@ export class WrapperService {
             [],
           );
 
-          templates = await this.datasource.query(
-            `SELECT id FROM frm_wf_comm_template 
-           WHERE code = $1 
-             AND level_type = 'ORG' 
-             AND organization_id = $2 
-           LIMIT 1`,
-            [entity.template_code, organization_id],
-          );
+          templates = await commTemplateRepo.find({
+            where: {
+              code: entity.template_code,
+              organization_id: organization_id,
+            },
+          });
         }
 
         if (templates && templates.length > 0) {
@@ -387,45 +391,11 @@ export class WrapperService {
         user_id: loggedInUser.id,
         entity_type: entity.entity_type,
         entity_id: entity.entity_id,
-        attachments: [],
+        attachments: entity.attachments,
         mediaUrl: entity.mediaUrl,
         organization_id: organization_id,
       } as any;
 
-      // attachments: [1, 2, 3, 4]
-
-      if (entity.attachments && entity.attachments.length > 0) {
-        mailPayload.attachments = [];
-
-        for (const attachmentId of entity.attachments) {
-          // Step 1: Download or get media file
-          const url = await this.mediaService.getMediaDownloadUrl(
-            attachmentId,
-            {},
-            60000,
-          );
-
-          if (!url?.signedUrl) continue;
-
-          // Step 2: Fetch file content
-          const response = await axios.get(url.signedUrl, {
-            responseType: 'arraybuffer',
-          });
-
-          // Step 3: Convert to base64
-          const base64Content = Buffer.from(response.data).toString('base64');
-
-          // Step 4: Push formatted attachment
-          mailPayload.attachments.push({
-            content: base64Content,
-            type:
-              response.headers['content-type'] || 'application/octet-stream',
-            filename: url.fileName,
-            disposition: 'attachment',
-          });
-        }
-      }
-
       this.loggingService.log(
         'debug',
         'wrapperService',
@@ -537,15 +507,18 @@ export class WrapperService {
         [],
       );
 
-      const orgConfigs = await this.datasource.query(
-        `SELECT * FROM frm_integration_config 
-       WHERE level_id = 1
-         AND level_type = 'ORG' 
-         AND integration_type = 'EMAIL'
-         AND app_code ='DEFAULT'
-         AND status = 1`,
-        [],
-      );
+      const integrationConfigRepo =
+        this.reflectionHelper.getRepoService('IntegrationConfig');
+
+      const orgConfigs = await integrationConfigRepo.find({
+        where: {
+          level_id: 1,
+          level_type: 'ORG',
+          integration_type: 'EMAIL',
+          app_code: 'DEFAULT',
+          status: 1,
+        },
+      });
 
       integrationConfig = await this.integrationService.getSingleActiveConfig(
         1,
@@ -601,12 +574,16 @@ export class WrapperService {
       [],
       [],
     );
-    const configRes = await this.datasource.query(
-      `SELECT config_json 
-       FROM frm_integration_config 
-       WHERE id = $1`,
-      [configId],
-    );
+
+    const integrationConfigRepo =
+      this.reflectionHelper.getRepoService('IntegrationConfig');
+
+    const configRes = await integrationConfigRepo.findOne({
+      where: {
+        id: configId,
+      },
+    });
+
     this.loggingService.log(
       'debug',
       'wrapperService',
@@ -615,7 +592,7 @@ export class WrapperService {
       [],
       [],
     );
-    return configRes?.[0]?.config_json || null;
+    return configRes?.config_json || null;
   }
 
   private async sendIcsInvite(
@@ -636,15 +613,16 @@ export class WrapperService {
     );
 
     if (payload.template_code) {
-      let templates = await this.datasource.query(
-        `SELECT id FROM frm_wf_comm_template 
-         WHERE code = $1 
-           AND level_id = $2 
-           AND level_type = $3 
-         LIMIT 1`,
-        [payload.template_code, levelId, levelType],
-      );
-      this.logger.log(`template by code  ${JSON.stringify(payload)}`);
+      const commTemplateRepo =
+        this.reflectionHelper.getRepoService('CommTemplate');
+      let templates = await commTemplateRepo.find({
+        where: {
+          code: payload.template_code,
+          level_id: levelId,
+          levelType: levelType,
+        },
+      });
+
       if (templates && templates.length > 0) {
         payload['templateId'] = templates[0].id;
       }

package/src/module/listmaster/repository/list-master.repository.ts

@@ -43,4 +43,14 @@ export class ListMasterRepository {
 
     return await qb.getMany();
   }
+
+  async findByOrganizationIdAndSource(organization_id, source) {
+    return await this.repo
+      .createQueryBuilder("lm")
+      .select("lm.name", "label")
+      .addSelect("lm.type", "value")
+      .where("lm.organization_id = :orgId", { orgId: organization_id })
+      .andWhere("lm.source = :source", { source })
+      .getRawMany();
+  }
 }

package/src/module/listmaster/service/list-master-item.service.ts

@@ -1,22 +1,17 @@
 import { DataSource } from 'typeorm';
-import {
-  BadRequestException,
-  forwardRef,
-  Inject,
-  Injectable,
-  NotFoundException,
-} from '@nestjs/common';
+import { BadRequestException, forwardRef, Inject, Injectable, NotFoundException } from '@nestjs/common';
 import { ListMasterItemsRepository } from '../repository/list-master-items.repository';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { CodeGeneratorService } from 'src/utils/service/codeGenerator.service';
 import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
+import { ListMasterRepository } from '../repository/list-master.repository';
 
 @Injectable()
 export class ListMasterItemService extends EntityServiceImpl {
   constructor(
     private readonly listItemsRepo: ListMasterItemsRepository,
-    private readonly listMasterRepo: ListMasterItemsRepository,
+    private readonly listMasterRepo: ListMasterRepository,
     @Inject(forwardRef(() => EntityServiceImpl))
     private readonly entityServiceImpl: EntityServiceImpl,
     protected readonly attributeMasterService: AttributeMasterService,
@@ -189,13 +184,7 @@ export class ListMasterItemService extends EntityServiceImpl {
     loggedInUser: UserData,
     source: string,
   ): Promise<any> {
-    const data = await this.dataSource.query(
-      `SELECT name AS label, type AS value
-     FROM frm_list_master
-     WHERE organization_id = $1 AND source = $2`,
-      [loggedInUser.organization_id, source],
-    );
-    return data;
+    return await this.listMasterRepo.findByOrganizationIdAndSource(loggedInUser.organization_id, source);
   }
 
   // async getResolvedListMasterItems(

package/src/module/meta/repository/attribute-master.repository.ts

@@ -1,15 +1,17 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { AttributeMaster } from '../entity/attribute-master.entity';
-import { In, Repository, DataSource } from 'typeorm';
+import { EntityManager, Repository } from 'typeorm';
 import { UserData } from 'src/module/user/entity/user.entity';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 
 @Injectable()
 export class AttributeMasterRepository {
   constructor(
     @InjectRepository(AttributeMaster)
     private readonly attributeMasterRepository: Repository<AttributeMaster>,
-    private readonly dataSource: DataSource,
+    private readonly entityManger: EntityManager,
+    private readonly reflectionHelper: ReflectionHelper,
   ) {}
 
   // ---------- Existing Methods ----------
@@ -101,21 +103,33 @@ return dropdownData;
     entityType: string,
     loggedInUser: UserData,
   ): Promise<string | null> {
-    const result = await this.dataSource.query(
-      `SELECT db_table_name FROM frm_entity_master WHERE mapped_entity_type = $1 AND organization_id = $2`,
-      [entityType, loggedInUser.organization_id],
-    );
-    return result.length ? result[0].db_table_name : null;
+    const entityMasterRepo = this.reflectionHelper.getRepoService('EntityMaster');
+    const result = await entityMasterRepo.findOne({
+      where: {
+        mapped_entity_type: entityType,
+        organization_id: loggedInUser.organization_id,
+      },
+    });
+    if (result) {
+      return result.db_table_name;
+    }
+    return null;
   }
 
   async checkIfColumnExists(
     tableName: string,
     columnName: string,
   ): Promise<boolean> {
-    const result = await this.dataSource.query(
-      `SHOW COLUMNS FROM \`${tableName}\` LIKE $1`,
-      [columnName],
+    const result = await this.entityManger.query(
+      `
+    SELECT column_name 
+    FROM information_schema.columns
+    WHERE table_name = $1
+      AND column_name = $2
+  `,
+      [tableName, columnName],
     );
+
     return result.length > 0;
   }
 
@@ -124,8 +138,12 @@ return dropdownData;
     columnName: string,
     columnType: string,
   ): Promise<void> {
-    const alterQuery = `ALTER TABLE \`${tableName}\` ADD COLUMN \`${columnName}\` ${columnType} NULL`;
-    await this.dataSource.query(alterQuery);
+    const alterQuery = `
+        ALTER TABLE "${tableName}"
+            ADD COLUMN IF NOT EXISTS "${columnName}" ${columnType}
+    `;
+
+    await this.entityManger.query(alterQuery);
   }
 
   async findByMappedEntityTypeAndAttributeKeyAndOrganizationId(mapped_entity_type: string, attribute_key: string, organization_id: number) {

package/src/module/meta/service/entity-dynamic.service.ts

@@ -1,20 +1,18 @@
 import { BadRequestException, Injectable } from '@nestjs/common';
 import { STATUS_ACTIVE } from 'src/constant/global.constant';
-import { DataSource,In } from 'typeorm';
+import { EntityManager, In } from 'typeorm';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { MediaDataService } from './media-data.service';
 import { ResolverService } from './resolver.service';
-import { ConfigService } from '@nestjs/config';
 import { EntityMasterRepository } from '../repository/entity-master.repository';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 
 @Injectable()
 export class EntityDynamicService {
   constructor(
-    private readonly dataSource: DataSource,
+    private readonly entityManager: EntityManager,
     private readonly mediaDataService: MediaDataService,
     private readonly resolverService: ResolverService,
-    private readonly configService: ConfigService,
     private readonly entityMasterRepo: EntityMasterRepository,
     private readonly reflectionHelper: ReflectionHelper,
   ) {}
@@ -59,15 +57,14 @@ export class EntityDynamicService {
     // -------------------------------------------------------
     // STATUS
     // -------------------------------------------------------
-    const statusList = await this.dataSource.query(
-      `
-          SELECT id
-          FROM frm_list_master_items
-          WHERE code = $1
-            AND organization_id = $2
-      `,
-      [STATUS_ACTIVE, organizationId],
-    );
+    const listMasterItemsRepo =
+      this.reflectionHelper.getRepoService('ListMasterItems');
+    const statusList = listMasterItemsRepo.find({
+      where: {
+        code: STATUS_ACTIVE,
+        organization_id: organizationId,
+      },
+    });
 
     if (!entityData.status) entityData.status = statusList[0]?.id;
 
@@ -76,7 +73,7 @@ export class EntityDynamicService {
     // -------------------------------------------------------
     if (!entityData.code && entityData.entity_type) {
       // Extract integer suffix
-      const result = await this.dataSource.query(
+      const result = await this.entityManager.query(
         `
             SELECT MAX(id) AS max_seq_no
             FROM ${tableName}
@@ -148,7 +145,7 @@ export class EntityDynamicService {
         VALUES (${placeholderList}) RETURNING id
     `;
 
-    const result = await this.dataSource.query(sql, values);
+    const result = await this.entityManager.query(sql, values);
     return result[0];
   }
 
@@ -162,14 +159,14 @@ export class EntityDynamicService {
   ): Promise<any> {
     const organizationId = loggedInUser.organization_id;
 
-     const repo = this.reflectionHelper.getRepoService('EntityRelation')
+    const repo = this.reflectionHelper.getRepoService('EntityRelation');
 
-   const getRelation = await repo.find({
-      where:{
-          organization_id:organizationId,
-        source_entity_type:entityType,
-      }
-    })
+    const getRelation = await repo.find({
+      where: {
+        organization_id: organizationId,
+        source_entity_type: entityType,
+      },
+    });
 
     // const getRelation = await this.dataSource.query(
     //   `SELECT *
@@ -215,7 +212,8 @@ export class EntityDynamicService {
             mainID, // this will pass for parent_id
           );
 
-          const relationRepo = this.reflectionHelper.getRepoService('EntityRelationData')
+          const relationRepo =
+            this.reflectionHelper.getRepoService('EntityRelationData');
 
           await relationRepo.save({
             organizationId: organizationId,
@@ -223,8 +221,8 @@ export class EntityDynamicService {
             source_entity_type: entityType,
             target_entity_id: createdRelatedEntity.id,
             targetEntityType: targetEntityType,
-            relation_type: relationType
-          })
+            relation_type: relationType,
+          });
 
           // await this.dataSource.query(
           //   `INSERT INTO frm_entity_relation_data (organization_id, source_entity_id, source_entity_type,
@@ -264,13 +262,14 @@ export class EntityDynamicService {
       loggedInUser,
     );
     const relationRepo = this.reflectionHelper.getRepoService('EntityRelation');
-    const relatedEntityRepo = this.reflectionHelper.getRepoService('EntityRelationData');
+    const relatedEntityRepo =
+      this.reflectionHelper.getRepoService('EntityRelationData');
 
     const relations = await relationRepo.find({
-      where: {source_entity_type: entityType}
-    })
+      where: { source_entity_type: entityType },
+    });
 
-    const targetTypes = relations.map(r=> r.target_entity_type)
+    const targetTypes = relations.map((r) => r.target_entity_type);
 
     if (targetTypes.length === 0) {
       return {
@@ -352,13 +351,14 @@ export class EntityDynamicService {
     const updatedRelations: Record<string, any> = {};
 
     if (mappedEntities) {
-      const getRelationDefs = await this.dataSource.query(
-        `SELECT *
-         FROM frm_entity_relation
-         WHERE organization_id = $1
-           AND source_entity_type = $2`,
-        [organizationId, entityType],
-      );
+      const entityRelationRepo =
+        this.reflectionHelper.getRepoService('EntityRelation');
+      const getRelationDefs = await entityRelationRepo.find({
+        where: {
+          organization_id: organizationId,
+          source_entity_type: entityType,
+        },
+      });
 
       for (const [targetEntityType, rawEntityData] of Object.entries(
         mappedEntities,
@@ -374,15 +374,6 @@ export class EntityDynamicService {
           : [rawEntityData];
 
         // Delete previous relations and related entities
-        const existingRelationsForType = await this.dataSource.query(
-          `SELECT *
-           FROM frm_entity_relation_data
-           WHERE source_entity_type = $1
-             AND source_entity_id = $2
-             AND target_entity_type = $3`,
-          [entityType, id, targetEntityType],
-        );
-
         // Create/update new entities & relations
         const updatedEntities: any[] = [];
 
@@ -435,20 +426,16 @@ export class EntityDynamicService {
             );
 
             // Insert relation as per new entity created
-            await this.dataSource.query(
-              `INSERT INTO frm_entity_relation_data
-               (organization_id, source_entity_id, source_entity_type, target_entity_id, target_entity_type,
-                relation_type)
-               VALUES ($1, $2, $3, $4, $5, $6)`,
-              [
-                organizationId,
-                id,
-                entityType,
-                targetEntityId,
-                targetEntityType,
-                relationType,
-              ],
-            );
+            const entityRelationDataRepo =
+              this.reflectionHelper.getRepoService('EntityRelationData');
+            await entityRelationDataRepo.save({
+              organizationId: organizationId,
+              source_entity_id: id,
+              source_entity_type: entityType,
+              target_entity_id: targetEntityId,
+              targetEntityType: targetEntityType,
+              relation_type: relationType,
+            });
           }
 
           if (relationType === 'ONE_TO_MANY') {
@@ -562,7 +549,7 @@ export class EntityDynamicService {
         WHERE id = ${idPlaceholder}
     `;
 
-    return await this.dataSource.query(updateQuery, values);
+    return await this.entityManager.query(updateQuery, values);
   }
 
   async getEntityByDataSource(
@@ -589,7 +576,7 @@ export class EntityDynamicService {
                          FROM ${dataSource}
                          WHERE id = $1`;
 
-    const result = await this.dataSource.query(selectQuery, [id]);
+    const result = await this.entityManager.query(selectQuery, [id]);
     if (!result.length) return null;
 
     const row = result[0];
@@ -644,7 +631,7 @@ export class EntityDynamicService {
                          FROM ${tableName} t
                          WHERE id = $1`;
 
-    const result = await this.dataSource.query(selectQuery, [id]);
+    const result = await this.entityManager.query(selectQuery, [id]);
     if (!result.length) return null;
 
     const row = result[0];
@@ -713,13 +700,15 @@ export class EntityDynamicService {
     organizationId: string,
     isHidden = true,
   ) {
-    const qb = this.dataSource
-      .createQueryBuilder()
+    const attributeMasterRepo =
+      this.reflectionHelper.getRepoService('AttributeMaster');
+
+    const qb = attributeMasterRepo
+      .createQueryBuilder('fea')
       .select('fea.attribute_key', 'attribute_key')
       .addSelect('MAX(fea.db_datatype)', 'db_datatype')
       .addSelect('MAX(fea.element_type)', 'element_type')
-      .addSelect('BOOL_OR(fea.is_hidden)', 'is_hidden') // ✅ FIXED for Postgres
-      .from('frm_entity_attribute', 'fea')
+      .addSelect('bool_or(fea.is_hidden)', 'is_hidden')
       .where('fea.mapped_entity_type = :entityType', { entityType })
       .andWhere('fea.organization_id = :organizationId', { organizationId });
 
@@ -751,7 +740,7 @@ export class EntityDynamicService {
     const deleteQuery = `DELETE
                          FROM \`${tableName}\`
                          WHERE id = $1`;
-    const result = await this.dataSource.query(deleteQuery, [id]);
+    const result = await this.entityManager.query(deleteQuery, [id]);
     return result;
   }
 
@@ -773,7 +762,7 @@ export class EntityDynamicService {
       params.push(appcode);
     }
 
-    const dropdown = await this.dataSource.query(query, params);
+    const dropdown = await this.entityManager.query(query, params);
     return dropdown;
   }
 
@@ -796,7 +785,7 @@ export class EntityDynamicService {
     const tableName = result.db_table_name;
 
     // 2. Get current max sequence number from that table
-    const seqResult = await this.dataSource.query(
+    const seqResult = await this.entityManager.query(
       `SELECT MAX(id) AS max_seq_no
        FROM ${tableName}
        WHERE entity_type = $1`,