rez_core 1.1.5 → 1.1.7

package/package.json

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

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

@@ -79,9 +79,8 @@ export class FilterService {
     } = dto;
 
     // Fetch meta
-    const entityMeta =
-      await this.entityMasterService.getEntityData(entity_type);
-    const tableName = entityMeta?.db_table_name;
+    const entityMeta = await this.entityTableService.getEntityData(entity_type);
+    const tableName = entityMeta?.data_source; // data_souce is the table name
     if (!tableName)
       throw new BadRequestException(`Invalid entity_type: ${entity_type}`);
 
@@ -128,7 +127,7 @@ export class FilterService {
 
     // Build query for tab counts (no tab.value filter here)
     const allTabs = await this.gettab_value_counts(
-      tableName,
+      getTableMeta.data_source,
       tabs?.columnName,
       baseWhere,
     );
@@ -249,11 +248,13 @@ export class FilterService {
   ): { query: string; params: any } | null {
     if (!meta) return null;
 
-    const attr = filter.filter_attribute;
+    let attr = filter.filter_attribute;
     const val = filter.filter_value;
     const op = filter.filter_operator;
     const key = `param_${attr}_${Math.random().toString(36).substring(2, 8)}`;
 
+    if (meta.data_source_type === 'entity') attr = `${attr}_id`;
+
     switch (meta.data_type) {
       case 'text':
         return this.buildTextCondition(attr, op, val, key);
@@ -344,16 +345,16 @@ export class FilterService {
   ) {
     switch (op) {
       case 'equal':
-        return { query: `e.${attr}_id = :${key}`, params: { [key]: val } };
+        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
 
       case 'not_equal':
-        return { query: `e.${attr}_id != :${key}`, params: { [key]: val } };
+        return { query: `e.${attr} != :${key}`, params: { [key]: val } };
 
       case 'empty':
-        return { query: `e.${attr}_id IS NULL`, params: {} };
+        return { query: `e.${attr} IS NULL`, params: {} };
 
       case 'not_empty':
-        return { query: `e.${attr}_id IS NOT NULL`, params: {} };
+        return { query: `e.${attr} IS NOT NULL`, params: {} };
 
       default:
         throw new BadRequestException(`Unsupported operator for select: ${op}`);
@@ -361,41 +362,44 @@ export class FilterService {
   }
 
   private buildMultiSelectCondition(
-  attr: string,
-  op: string,
-  val: any,
-  key: string,
-) {
-  if ((op === 'equal' || op === 'not_equal') && !Array.isArray(val)) {
-    throw new BadRequestException(
-      `Value for multi-select must be an array for operator: ${op}`,
-    );
-  }
+    attr: string,
+    op: string,
+    val: any,
+    key: string,
+  ) {
+    if (Array.isArray(val) && val.length === 0) {
+      return { query: `e.${attr}`, params: {} };
+    }
 
-  switch (op) {
-    case 'equal':
-      return {
-        query: `e.${attr}_id IN (:${key})`, // ✅ use (:key)
-        params: { [key]: val },
-      };
+    if ((op === 'equal' || op === 'not_equal') && !Array.isArray(val)) {
+      throw new BadRequestException(
+        `Value for multi-select must be an array for operator: ${op}`,
+      );
+    }
 
-    case 'not_equal':
-      return {
-        query: `e.${attr}_id NOT IN (:${key})`, // ✅ use (:key)
-        params: { [key]: val },
-      };
+    switch (op) {
+      case 'equal':
+        return {
+          query: `e.${attr} IN (:${key})`, // ✅ use (:key)
+          params: { [key]: val },
+        };
 
-    case 'empty':
-      return { query: `e.${attr}_id IS NULL`, params: {} };
+      case 'not_equal':
+        return {
+          query: `e.${attr} NOT IN (:${key})`, // ✅ use (:key)
+          params: { [key]: val },
+        };
 
-    case 'not_empty':
-      return { query: `e.${attr}_id IS NOT NULL`, params: {} };
+      case 'empty':
+        return { query: `e.${attr} IS NULL`, params: {} };
 
-    default:
-      throw new BadRequestException(
-        `Unsupported operator for multiselect: ${op}`,
-      );
-  }
-}
+      case 'not_empty':
+        return { query: `e.${attr} IS NOT NULL`, params: {} };
 
+      default:
+        throw new BadRequestException(
+          `Unsupported operator for multiselect: ${op}`,
+        );
+    }
+  }
 }

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

@@ -24,7 +24,6 @@ export class MetaController {
     @Req() req: Request & { user: any },
   ) {
     const userId = req.user.userId;
-
     let entityTableDto =
       await this.entityTableService.getTableMetaDataForListing(
         entityType,

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

@@ -11,12 +11,18 @@ export class EntityTableRepository {
   ) {}
 
   async findByEntityTypeAndListType(entityType: string, listType: string) {
-    const temp =  await this.entityTableRepository.findOne({
+    const temp = await this.entityTableRepository.findOne({
       where: { mapped_entity_type: entityType, list_type: listType },
     });
     return temp;
   }
 
+  async findByMappedEntityType(mappedEntityType: string) {
+    return await this.entityTableRepository.findOne({
+      where: { mapped_entity_type: mappedEntityType, display_type: 'LIST' },
+    });
+  }
+
   async findByEntityTypeAndListTypeAndDisplayType(
     entityType: string,
     listType: string,

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

@@ -12,11 +12,29 @@ export class EntityTableService {
   constructor(
     private entityTableRepository: EntityTableRepository,
     private readonly entityTableColumnRepository: EntityTableColumnRepository,
-    @Inject(forwardRef(() => ListMasterService)) 
-  private readonly listMasterService: ListMasterService,
-  
-  private readonly savedFilterRepoService: SavedFilterRepositoryService,
-  ) {
+    @Inject(forwardRef(() => ListMasterService))
+    private readonly listMasterService: ListMasterService,
+
+    private readonly savedFilterRepoService: SavedFilterRepositoryService,
+  ) {}
+
+  async getEntityData(mappedEntityType: string | null) {
+    if (mappedEntityType) {
+      const tableMaster =
+        await this.entityTableRepository.findByMappedEntityType(
+          mappedEntityType,
+        );
+
+      if (!tableMaster) {
+        throw new Error(
+          `Entity with mappedEntityType "${mappedEntityType}" not found.`,
+        );
+      }
+
+      return tableMaster;
+    } else {
+      throw new Error();
+    }
   }
 
   async findByEntityTypeAndListType(entityType: string, listType: string) {
@@ -38,15 +56,24 @@ export class EntityTableService {
     );
   }
 
-  async getTableMetaDataForListing(entityType: string, listType: string,userId?: number) {
-    return await this.getTableMetaData(entityType, listType, DISPLAY_LIST,userId);
+  async getTableMetaDataForListing(
+    entityType: string,
+    listType: string,
+    userId?: number,
+  ) {
+    return await this.getTableMetaData(
+      entityType,
+      listType,
+      DISPLAY_LIST,
+      userId,
+    );
   }
 
   async getTableMetaData(
     entityType: string,
     listType: string,
     displayType: string,
-    userId?: number
+    userId?: number,
   ) {
     let entityTable = await this.findByEntityTypeAndListTypeAndDisplayType(
       entityType,
@@ -61,22 +88,27 @@ export class EntityTableService {
           entityTable.id,
           entityTable.entity_type,
         );
-        entityTableDto.operation_list = {
-          "text": await this.listMasterService.getDropdownOptions("OPT",{}),
-          "number": await this.listMasterService.getDropdownOptions("OPN",{}),
-          "date": await this.listMasterService.getDropdownOptions("OPD",{}),
-          "select": await this.listMasterService.getDropdownOptions("OPS",{}),
-          "multiselect": await this.listMasterService.getDropdownOptions("OPM",{})
-          // Add any other operations you want to include
-        };
-        entityTableDto.default_filter= await this.savedFilterRepoService.getDefaultFilterByEntityType(entityTable.list_type);  
-        if(userId){
-        entityTableDto.saved_filter = await this.savedFilterRepoService.getSavedFiltersByUserIdAndEntityType(userId, entityTable.list_type);  
-        }
+      entityTableDto.operation_list = {
+        text: await this.listMasterService.getDropdownOptions('OPT', {}),
+        number: await this.listMasterService.getDropdownOptions('OPN', {}),
+        date: await this.listMasterService.getDropdownOptions('OPD', {}),
+        select: await this.listMasterService.getDropdownOptions('OPS', {}),
+        multiselect: await this.listMasterService.getDropdownOptions('OPM', {}),
+        // Add any other operations you want to include
+      };
+      entityTableDto.default_filter =
+        await this.savedFilterRepoService.getDefaultFilterByEntityType(
+          entityTable.list_type,
+        );
+      if (userId) {
+        entityTableDto.saved_filter =
+          await this.savedFilterRepoService.getSavedFiltersByUserIdAndEntityType(
+            userId,
+            entityTable.list_type,
+          );
+      }
     }
 
-
-
     return entityTableDto;
   }
 }