rez_core 5.0.167 → 5.0.169

package/package.json

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

package/src/module/entity_json/service/entity_json.service.ts

@@ -25,6 +25,7 @@ export class EntityJSONService extends EntityServiceImpl {
     flag?: 'flat_json' | 'dropdown' | 'all',
   ) {
     const orgId = loggedInUser.organization_id;
+    const entId = loggedInUser.entId;
 
     await this.loggerService.log('info', 'EntityJSONService', 'getAttributeForFlatJSON', `Loading attributes for entity: ${entityType}, org: ${orgId}`);
 
@@ -33,7 +34,7 @@ export class EntityJSONService extends EntityServiceImpl {
       .createQueryBuilder('attr')
       .select(['attr.id', 'attr.name', 'attr.flat_json_key', 'attr.attribute_key'])
       .where('attr.mapped_entity_type = :entityType', { entityType })
-      .andWhere('attr.organization_id = :orgId', { orgId })
+      .andWhere('attr.enterprise_id = :entId', { entId })
       .getMany();
 
     await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Loaded ${mainAttributes.length} main attributes`);
@@ -43,7 +44,7 @@ export class EntityJSONService extends EntityServiceImpl {
       .createQueryBuilder('rel')
       .select(['rel.target_entity_type'])
       .where('rel.source_entity_type = :entityType', { entityType })
-      .andWhere('rel.organization_id = :orgId', { orgId })
+      .andWhere('rel.enterprise_id = :entId', { entId })
       .andWhere('rel.relation_type = :relationType', { relationType: 'ONE_TO_ONE' })
       .getRawMany();
 
@@ -57,7 +58,7 @@ export class EntityJSONService extends EntityServiceImpl {
         .createQueryBuilder('attr')
         .select(['attr.id', 'attr.name', 'attr.flat_json_key', 'attr.mapped_entity_type', 'attr.attribute_key'])
         .where('attr.mapped_entity_type IN (:...types)', { types: relatedTypesList })
-        .andWhere('attr.organization_id = :orgId', { orgId })
+        .andWhere('attr.enterprise_id = :entId', { entId })
         .getMany()
       : [];
 
@@ -79,7 +80,7 @@ export class EntityJSONService extends EntityServiceImpl {
         'attr.name AS name',
         'attr.id AS id',
       ])
-      .where('attr.organization_id = :orgId', { orgId })
+      .where('attr.enterprise_id = :entId', { entId })
       .getRawMany();
 
     await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Loaded ${linkedAttributes.length} linked attributes`);
@@ -219,7 +220,6 @@ export class EntityJSONService extends EntityServiceImpl {
 
     const dto: any = {
       entity_type: childEntityType,
-      loggedInUser,
       savedFilterCode,
       page: 1,
       size: 1,

package/src/module/filter/repository/saved-filter.repository.ts

@@ -5,7 +5,8 @@ import { SavedFilterMaster } from '../entity/saved-filter-master.entity';
 import { SavedFilterDetail } from '../entity/saved-filter-detail.entity';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
-import { log } from 'console';
+import { ConfigService } from '@nestjs/config';
+import axios from 'axios';
 
 @Injectable()
 export class SavedFilterRepositoryService {
@@ -15,6 +16,7 @@ export class SavedFilterRepositoryService {
     @InjectRepository(SavedFilterDetail)
     private readonly savedFilterDetailRepo: Repository<SavedFilterDetail>,
     private readonly reflectionHelper: ReflectionHelper,
+    private readonly configService: ConfigService,
   ) {}
 
   async isFilterNameExists({
@@ -88,12 +90,13 @@ export class SavedFilterRepositoryService {
   }
 
   async getSavedFiltersByUserIdAndEntityType(
-    userId: number,
+    loggedInUser: UserData,
+    // userId: number,
     entityType: string,
   ) {
     const filters = await this.savedFilterMasterRepo.find({
       where: {
-        user_id: userId,
+        user_id: loggedInUser.id,
         mapped_entity_type: entityType,
         status: 'ACTIVE',
       },
@@ -102,12 +105,39 @@ export class SavedFilterRepositoryService {
       },
     });
 
-    return filters.map((filter) => ({
-      label: filter.name,
-      value: filter.id,
-      code: filter.code,
-    }));
-    // return filters;
+    if (!filters?.length) {
+      for (const filter of filters) {
+        try {
+          const baseUrl = this.configService.get<string>('REDIRECT_BE_URL');
+          const queryParams = new URLSearchParams({
+            loggedInUser: JSON.stringify(loggedInUser),
+          }).toString();
+
+          const createdBy = await axios.get(
+            `${baseUrl}/users/profile-image-url/${filter.created_by}?entity_type=USR&${queryParams}`,
+            { headers: { 'Content-Type': 'application/json' } },
+          );
+
+          const modifiedBy = await axios.get(
+            `${baseUrl}/users/profile-image-url/${filter.modified_by}?entity_type=USR&${queryParams}`,
+            { headers: { 'Content-Type': 'application/json' } },
+          );
+
+          filter.created_by = createdBy.data.name;
+          filter.modified_by = modifiedBy.data.name;
+        } catch (err) {
+          console.error('⚠ Error fetching profile:', err.message);
+        }
+      }
+    }
+
+    // return filters.map((filter) => ({
+    //   label: filter.name,
+    //   value: filter.id,
+    //   code: filter.code,
+    // }));
+
+    return filters;
   }
 
   async getSharedFiltersByLevelTypeAndLevelId(
@@ -128,6 +158,32 @@ export class SavedFilterRepositoryService {
       },
     });
 
+    if (!filters?.length) {
+      for (const filter of filters) {
+        try {
+          const baseUrl = this.configService.get<string>('REDIRECT_BE_URL');
+          const queryParams = new URLSearchParams({
+            loggedInUser: JSON.stringify(loggedInUser),
+          }).toString();
+
+          const createdBy = await axios.get(
+            `${baseUrl}/users/profile-image-url/${filter.created_by}?entity_type=USR&${queryParams}`,
+            { headers: { 'Content-Type': 'application/json' } },
+          );
+
+          const modifiedBy = await axios.get(
+            `${baseUrl}/users/profile-image-url/${filter.modified_by}?entity_type=USR&${queryParams}`,
+            { headers: { 'Content-Type': 'application/json' } },
+          );
+
+          filter.created_by = createdBy.data.name;
+          filter.modified_by = modifiedBy.data.name;
+        } catch (err) {
+          console.error('⚠ Error fetching profile:', err.message);
+        }
+      }
+    }
+
     return filters;
 
     // return filters.map((filter) => ({

package/src/module/filter/service/filter.service.ts

@@ -78,11 +78,12 @@ export class FilterService {
 
     const rawSQL = `
         SELECT ${column} AS tab_value, COUNT(*) AS tab_value_count
-        FROM ${tableName} ${whereSQL}
+        FROM ${this.schema}.${tableName} ${whereSQL}
         GROUP BY ${column}
     `;
 
-    const rows = await this.queryWithSchema(rawSQL, values);
+
+    const rows = await this.entityManager.query(rawSQL, values);
 
     const total = rows.reduce(
       (sum, r) => sum + parseInt(r.tab_value_count, 10),
@@ -166,7 +167,7 @@ export class FilterService {
         entity_type,
         subEntityType,
         subEntityIds,
-        dto.loggedInUser.organization_id,
+        dto.loggedInUser.enterprise_id,
       );
 
       intersectionIds =
@@ -1310,8 +1311,7 @@ export class FilterService {
 
   async queryWithSchema(sql: string, params: any[] = []) {
     await this.entityManager.query('BEGIN');
-    const schema = this.configService.get<string>('DB_SCHEMA');
-    await this.entityManager.query(`SET LOCAL search_path TO ${schema}`);
+    await this.entityManager.query(`SET LOCAL search_path TO ${this.schema}`);
     const result = await this.entityManager.query(sql, params);
     await this.entityManager.query('COMMIT');
     return result;

package/src/module/meta/dto/entity-table.dto.ts

@@ -5,8 +5,8 @@ export class EntityTableDto extends EntityTable {
   column_list: EntityTableColumn[];
   operation_list: {};
   default_filter: {} | null;
-  saved_filter: { label: string; value: number }[] | null;
+  // saved_filter: { label: string; value: number }[] | null;
   // shared_filter: { label: string; value: number }[] | null;
   shared_filter: any[] | null;
-  // saved_filter: any[] | null;
+  saved_filter: any[] | null;
 }

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

@@ -4,6 +4,7 @@ import { AttributeMaster } from '../entity/attribute-master.entity';
 import { EntityManager, Repository } from 'typeorm';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
+import { ConfigService } from '@nestjs/config';
 
 @Injectable()
 export class AttributeMasterRepository {
@@ -12,7 +13,11 @@ export class AttributeMasterRepository {
     private readonly attributeMasterRepository: Repository<AttributeMaster>,
     private readonly entityManger: EntityManager,
     private readonly reflectionHelper: ReflectionHelper,
-  ) {}
+    private readonly configService: ConfigService,
+  ) {
+  }
+
+  schema = this.configService.get('DB_SCHEMA');
 
   // ---------- Existing Methods ----------
   async findByMappedEntityIdAndMappedEntityTypeAndAttributeKeyAndOrganizationId(
@@ -38,7 +43,7 @@ export class AttributeMasterRepository {
     return await this.attributeMasterRepository.find({
       where: {
         mapped_entity_type: entityType,
-        organization_id: loggedInUser.organization_id,
+        enterprise_id: loggedInUser.enterprise_id,
       },
     });
   }
@@ -61,25 +66,27 @@ export class AttributeMasterRepository {
     return await this.attributeMasterRepository.findOne({ where: { id } });
   }
 
-  async getAllAttributeByEntity(entity_type:string,loggedInUser):Promise<{ label: string; value: any }[]> {
-let data = await this.attributeMasterRepository.find({
-  where: {
-    organization_id: loggedInUser.organization_id,
-    mapped_entity_type: entity_type
-  }
-});
- if(data) {
-const dropdownData = data.map((attribute) => {
-  return {"label": attribute.name,
-    "value":attribute.attribute_key,
-    "data_type":attribute.data_type,
-    "data_source_list":attribute.datasource_list
+  async getAllAttributeByEntity(entity_type: string, loggedInUser): Promise<{ label: string; value: any }[]> {
+    let data = await this.attributeMasterRepository.find({
+      where: {
+        enterprise_id: loggedInUser.enterprise_id,
+        mapped_entity_type: entity_type,
+      },
+    });
+    if (data) {
+      const dropdownData = data.map((attribute) => {
+        return {
+          'label': attribute.name,
+          'value': attribute.attribute_key,
+          'data_type': attribute.data_type,
+          'data_source_list': attribute.datasource_list,
+        };
+      });
+
+      return dropdownData;
+    }
+    return [];
   }
-})
-
-return dropdownData;
- }
- return [];  }
 
   async getAttributesDropdownList(
     entityType: string,
@@ -88,7 +95,7 @@ return dropdownData;
     const data = await this.attributeMasterRepository.find({
       where: {
         mapped_entity_type: entityType,
-        organization_id: loggedInUser.organization_id,
+        enterprise_id: loggedInUser.enterprise_id,
       },
     });
 
@@ -107,7 +114,7 @@ return dropdownData;
     const result = await entityMasterRepo.findOne({
       where: {
         mapped_entity_type: entityType,
-        organization_id: loggedInUser.organization_id,
+        enterprise_id: loggedInUser.enterprise_id,
       },
     });
     if (result) {
@@ -122,11 +129,11 @@ return dropdownData;
   ): Promise<boolean> {
     const result = await this.entityManger.query(
       `
-    SELECT column_name 
-    FROM information_schema.columns
-    WHERE table_name = $1
-      AND column_name = $2
-  `,
+          SELECT column_name
+          FROM information_schema.columns
+          WHERE table_name = $1
+            AND column_name = $2
+      `,
       [tableName, columnName],
     );
 
@@ -138,19 +145,20 @@ return dropdownData;
     columnName: string,
     columnType: string,
   ): Promise<void> {
+
     const alterQuery = `
-        ALTER TABLE "${tableName}"
-            ADD COLUMN IF NOT EXISTS "${columnName}" ${columnType}
+        ALTER TABLE ${this.schema}.${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) {
+  async findByMappedEntityTypeAndAttributeKeyAndOrganizationId(mapped_entity_type: string, attribute_key: string, enterprise_id: number) {
     return await this.attributeMasterRepository.findOne({
       where: {
-        mapped_entity_type, attribute_key, organization_id
-      }
-    })
+        mapped_entity_type, attribute_key, enterprise_id,
+      },
+    });
   }
 }

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

@@ -49,12 +49,8 @@ export class EntityMasterRepository {
       .getRawMany();
 
     // console.log(relations,"-------------")
-    let parentEntityLabelName = await this.entityMasterRepository.findOne({
-      where: {
-        organization_id: loggedInUser.organization_id,
-        mapped_entity_type: entity_type,
-      },
-    });
+    let parentEntityLabelName = await this.getEntityByMappedEntityType(entity_type, loggedInUser.enterprise_id);
+
     let dropdownData: any[] = [...relations];
     if (parentEntityLabelName) {
       dropdownData.push({
@@ -68,12 +64,12 @@ export class EntityMasterRepository {
 
   async getEntityByMappedEntityType(
     mappedEntityType: string,
-    organizationId: any,
+    enterprise_id: any,
   ): Promise<EntityMaster | null> {
     return await this.entityMasterRepository.findOne({
       where: {
         mapped_entity_type: mappedEntityType,
-        organization_id: organizationId,
+        enterprise_id: enterprise_id,
       },
     });
   }
@@ -92,13 +88,13 @@ export class EntityMasterRepository {
   }
 
   async getAttributesOfTypeDate(entity_type, loggedInUser) {
-    const organization_id = loggedInUser.organization_id;
+    const enterprise_id = loggedInUser.enterprise_id;
 
     const attributes = await this.attributeMasterRepository.find({
       where: {
         mapped_entity_type: entity_type,
         data_type: 'DATE',
-        organization_id
+        enterprise_id
       }
     })
 

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

@@ -25,6 +25,7 @@ export class AttributeMasterService {
     loggedInUser: UserData,
   ): Promise<AttributeMaster> {
     attributeData.organization_id = loggedInUser.organization_id;
+    attributeData.enterprise_id = loggedInUser.enterprise_id;
     attributeData.level_type = loggedInUser.level_type;
     attributeData.level_id = loggedInUser.level_id;
 
@@ -124,7 +125,7 @@ export class AttributeMasterService {
     return await this.attributeMasterRepository.findByMappedEntityTypeAndAttributeKeyAndOrganizationId(
       mapped_entity_type,
       attribute_key,
-      loggedInUser.organization_id
+      loggedInUser.enterprise_id
     );
   }
 }

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

@@ -29,8 +29,9 @@ export class EntityDynamicService {
     mainID?: number,
   ): Promise<any> {
     const organizationId = loggedInUser.organization_id;
+    const enterprise_id = loggedInUser.enterprise_id;
 
-    const tableName = await this.getTableName(entityType, organizationId);
+    const tableName = await this.getTableName(entityType, enterprise_id);
     const validAttributes = await this.getAttributeCodes(
       entityType,
       organizationId,
@@ -75,7 +76,7 @@ export class EntityDynamicService {
     // -------------------------------------------------------
     // AUTO-CODE GENERATION (POSTGRES SAFE)
     // -------------------------------------------------------
-    const entityMaster = await this.entityMasterRepo.getEntityByMappedEntityType(entityType, loggedInUser.organization_id)
+    const entityMaster = await this.entityMasterRepo.getEntityByMappedEntityType(entityType, loggedInUser.enterprise_id)
 
     if (!entityData.code && entityData.entity_type && entityMaster) {
       // Extract integer suffix
@@ -444,8 +445,9 @@ export class EntityDynamicService {
     mainID?: number,
   ): Promise<any> {
     const organizationId = loggedInUser.organization_id;
+    const enterprise_id = loggedInUser.enterprise_id;
 
-    const tableName = await this.getTableName(entityType, organizationId);
+    const tableName = await this.getTableName(entityType, enterprise_id);
     const validAttributes = await this.getAttributeCodes(
       entityType,
       organizationId,
@@ -529,10 +531,11 @@ export class EntityDynamicService {
     loggedInUser: any,
   ): Promise<any> {
     const organizationId = loggedInUser.organization_id;
+    const enterprise_id = loggedInUser.enterprise_id;
 
     const dataSource = await this.getEntitySourceTableName(
       entityType,
-      organizationId,
+      enterprise_id,
     );
     const validAttributes = await this.getAttributeCodes(
       entityType,
@@ -583,9 +586,10 @@ export class EntityDynamicService {
     id: number | string,
     loggedInUser: any,
   ): Promise<any> {
+    const enterprise_id = loggedInUser.enterprise_id;
     const organizationId = loggedInUser.organization_id;
 
-    const entityMaster = await this.entityMasterRepo.getEntityByMappedEntityType(entityType, organizationId);
+    const entityMaster = await this.entityMasterRepo.getEntityByMappedEntityType(entityType, enterprise_id);
     if(!entityMaster) return null;
 
     const validAttributes = await this.getAttributeCodes(
@@ -638,11 +642,11 @@ export class EntityDynamicService {
 
   private async getEntitySourceTableName(
     entityType: string,
-    organizationId: string,
+    enterprise_id: string,
   ): Promise<string> {
     const result = await this.entityMasterRepo.getEntityByMappedEntityType(
       entityType,
-      organizationId,
+      enterprise_id,
     );
 
     if (!result) {
@@ -656,11 +660,11 @@ export class EntityDynamicService {
   // -----------------------------
   private async getTableName(
     entityType: string,
-    organizationId: string,
+    enterprise_id: string,
   ): Promise<string> {
     let entityMaster = await this.entityMasterRepo.getEntityByMappedEntityType(
       entityType,
-      organizationId,
+      enterprise_id,
     );
 
     if (!entityMaster) {
@@ -709,12 +713,12 @@ export class EntityDynamicService {
     id: number | string,
     loggedInUser: any,
   ): Promise<any> {
-    const organizationId = loggedInUser.organization_id;
+    const enterprise_id = loggedInUser.enterprise_id;
 
-    const tableName = await this.getTableName(entityType, organizationId);
+    const tableName = await this.getTableName(entityType, enterprise_id);
 
     const deleteQuery = `DELETE
-                         FROM \`${tableName}\`
+                         FROM ${this.schema}.${tableName}
                          WHERE id = $1`;
     const result = await this.entityManager.query(deleteQuery, [id]);
     return result;
@@ -743,18 +747,18 @@ export class EntityDynamicService {
   }
 
   async getCode(entityType: string, loggedInUser: any): Promise<string> {
-    const organizationId = loggedInUser.organization_id;
+    const enterprise_id = loggedInUser.enterprise_id;
 
     // 1. Get db_table_name from entity master
 
     const result = await this.entityMasterRepo.getEntityByMappedEntityType(
       entityType,
-      organizationId,
+      enterprise_id,
     );
 
     if (!result) {
       throw new Error(
-        `Entity type '${entityType}' not found in frm_entity_master for org '${organizationId}'`,
+        `Entity type '${entityType}' not found in frm_entity_master for enterprise '${enterprise_id}'`,
       );
     }
 

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

@@ -36,7 +36,7 @@ export class EntityMasterService {
     if (mappedEntityType) {
       let filterCondition = {
         mapped_entity_type: mappedEntityType,
-        organization_id: loggedInUser.organization_id,
+        enterprise_id: loggedInUser.enterprise_id,
       };
       if (mapped_entity_id) {
         filterCondition['id'] = mapped_entity_id;
@@ -83,7 +83,7 @@ export class EntityMasterService {
     const entityMasterData =
       await this.entityMasterRepo.getEntityByMappedEntityType(
         entityType,
-        loggedInUser.organization_id,
+        loggedInUser.enterprise_id,
       );
 
     if (!entityMasterData) {

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

@@ -25,11 +25,11 @@ export class EntityRelationService extends EntityServiceImpl {
         'er.id AS id',
       ])
       .where('er.source_entity_type = :entityType', { entityType })
-      .andWhere('er.organization_id = :orgId', { orgId: loggedInUser.organization_id })
+      .andWhere('er.enterprise_id = :entId', { entId: loggedInUser.enterprise_id })
       .getRawMany();
 
     if (includeSelf) {
-      const entity = await this.entityMasterRepo.getEntityByMappedEntityType(entityType, loggedInUser.organization_id);
+      const entity = await this.entityMasterRepo.getEntityByMappedEntityType(entityType, loggedInUser.enterprise_id);
 
       if (entity) {
         relations.unshift({
@@ -47,7 +47,7 @@ export class EntityRelationService extends EntityServiceImpl {
     sourceEntity: string,
     targetEntity: string,
     targetIds: number[],
-    orgId: number,
+    enterpriseId: number,
   ): Promise<number[]> {
 
     if (!targetIds.length) return [];
@@ -59,7 +59,7 @@ export class EntityRelationService extends EntityServiceImpl {
       .where('erd.source_entity_type = :sourceEntity', { sourceEntity })
       .andWhere('erd.target_entity_type = :targetEntity', { targetEntity })
       .andWhere('erd.target_entity_id IN (:...targetIds)', { targetIds })
-      .andWhere('erd.organization_id = :orgId', { orgId })
+      .andWhere('erd.enterprise_id = :enterpriseId', { enterpriseId })
       .getRawMany();
 
     return rows.map((r) => Number(r.source_entity_id));

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

@@ -140,12 +140,12 @@ export class ResolverService {
     }
 
     // fetch attribute meta only for the given attributeKey
-    const attr = await this.attributeMasterRepo.findByMappedEntityTypeAndAttributeKeyAndOrganizationId(entityType, attrKey, loggedInUser.organization_id);
+    const attr = await this.attributeMasterRepo.findByMappedEntityTypeAndAttributeKeyAndOrganizationId(entityType, attrKey, loggedInUser.enterprise_id);
     if (!attr) return rawValue;
 
     // -------- ENTITY data_source_type --------
     if (attr.data_source_type === 'entity') {
-      const entityDef = await this.entityMasterRepo.getEntityByMappedEntityType(attr.datasource_list, loggedInUser.organization_id);
+      const entityDef = await this.entityMasterRepo.getEntityByMappedEntityType(attr.datasource_list, loggedInUser.enterprise_id);
 
       if (!entityDef) return rawValue;
 
@@ -241,13 +241,13 @@ export class ResolverService {
     }
 
     // fetch attribute meta
-    const attr = await this.attributeMasterRepo.findByMappedEntityTypeAndAttributeKeyAndOrganizationId(entityType, attrKey, loggedInUser.organization_id);
+    const attr = await this.attributeMasterRepo.findByMappedEntityTypeAndAttributeKeyAndOrganizationId(entityType, attrKey, loggedInUser.enterprise_id);
 
     if (!attr) return displayValue;
 
     // -------- ENTITY data_source_type --------
     if (attr.data_source_type === 'entity') {
-      const entityDef =await this.entityMasterRepo.getEntityByMappedEntityType(attr.datasource_list, loggedInUser.organization_id);
+      const entityDef =await this.entityMasterRepo.getEntityByMappedEntityType(attr.datasource_list, loggedInUser.enterprise_id);
 
       if (!entityDef) return displayValue;