rez_core 2.0.57 → 2.0.59

package/package.json

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

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

@@ -6,6 +6,7 @@ import { SavedFilterService } from './saved-filter.service';
 import { FilterRequestDto } from '../dto/filter-request.dto';
 import { EntityTableService } from 'src/module/meta/service/entity-table.service';
 import { EntityTableColumnService } from 'src/module/meta/service/entity-table-column.service';
+import { get } from 'http';
 
 @Injectable()
 export class FilterService {
@@ -22,28 +23,47 @@ export class FilterService {
   private async gettab_value_counts(
     tableName: string,
     column: string | undefined,
-    whereClauses: any[],
+    whereClauses: { query: string; params: Record<string, any> }[],
   ) {
     if (!column) return [];
 
-    const qb = this.dataSource
-      .getRepository(tableName)
-      .createQueryBuilder('e')
-      .select(`e.${column}`, 'tab_value')
-      .addSelect('COUNT(*)', 'tab_value_count')
-      .groupBy(`e.${column}`);
+    let whereSQL = '';
+    const values: any[] = [];
+
+    // Convert whereClauses to SQL
+    if (whereClauses.length > 0) {
+      const clauseParts = whereClauses.map((clause) => {
+        let parsedQuery = clause.query.replace(/\be\./g, ''); // removes e. prefix
+        Object.entries(clause.params).forEach(([key, val]) => {
+          parsedQuery = parsedQuery.replace(new RegExp(`:${key}`, 'g'), '?');
+          values.push(val);
+        });
+        return parsedQuery;
+      });
+
+      whereSQL = `WHERE ${clauseParts.join(' AND ')}`;
+    }
 
-    whereClauses.forEach((clause) => qb.andWhere(clause.query, clause.params));
+    // Construct raw SQL
+    const rawSQL = `
+  SELECT ${column} AS tab_value, COUNT(*) AS tab_value_count
+  FROM ${tableName}
+  ${whereSQL}
+  GROUP BY ${column}
+`;
 
-    const rows = await qb.getRawMany();
+    const rows = await this.dataSource.query(rawSQL, values);
 
-    const total = rows.reduce((sum, r) => sum + parseInt(r.tab_value_count), 0);
+    const total = rows.reduce(
+      (sum, r) => sum + parseInt(r.tab_value_count, 10),
+      0,
+    );
 
     return [
       { tab_value: 'All', tab_value_count: total },
       ...rows.map((r) => ({
-        tab_value: r.tab_value || 'UNKNOWN',
-        tab_value_count: parseInt(r.tab_value_count),
+        tab_value: r.tab_value ?? 'UNKNOWN',
+        tab_value_count: parseInt(r.tab_value_count, 10),
       })),
     ];
   }
@@ -59,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}`);
 
@@ -108,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,
     );
@@ -130,10 +149,16 @@ export class FilterService {
       }
     }
 
-    // Final query for filtered data
-    // Final query for filtered data
-    const qb = this.dataSource.getRepository(tableName).createQueryBuilder('e');
-    dataWhere.forEach((clause) => qb.andWhere(clause.query, clause.params));
+    // Build raw SQL base
+    const qb = this.dataSource
+      .createQueryBuilder()
+      .select('e.*')
+      .from(tableName, 'e');
+
+    // Apply WHERE clauses
+    dataWhere.forEach((clause) => {
+      qb.andWhere(clause.query, clause.params);
+    });
 
     // Optional sorting
     if (Array.isArray(sortby)) {
@@ -150,7 +175,19 @@ export class FilterService {
     const size = dto.size && dto.size > 0 ? dto.size : 10;
     qb.skip((page - 1) * size).take(size);
 
-    const [entity_list, total] = await qb.getManyAndCount();
+    // Get paginated data
+    const entity_list = await qb.getRawMany();
+
+    // Count query (without pagination)
+    const countQb = this.dataSource
+      .createQueryBuilder()
+      .select('COUNT(*)', 'count')
+      .from(tableName, 'e');
+    dataWhere.forEach((clause) => {
+      countQb.andWhere(clause.query, clause.params);
+    });
+    const countResult = await countQb.getRawOne();
+    const total = parseInt(countResult.count, 10);
 
     return {
       success: true,
@@ -191,7 +228,6 @@ export class FilterService {
     if (!savedFilter) {
       throw new BadRequestException(`Saved filter not found for code: ${code}`);
     }
-
     return savedFilter;
   }
 
@@ -212,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);
@@ -227,7 +265,7 @@ export class FilterService {
       case 'select':
         return this.buildSelectCondition(attr, op, val, key);
       case 'multiselect':
-        return this.buildMultiSelectCondition(attr, val, key);
+        return this.buildMultiSelectCondition(attr, op, val, key);
       default:
         return null;
     }
@@ -298,6 +336,7 @@ export class FilterService {
     }
   }
 
+  // this can be inproved
   private buildSelectCondition(
     attr: string,
     op: string,
@@ -308,18 +347,59 @@ export class FilterService {
       case 'equal':
         return { query: `e.${attr} = :${key}`, params: { [key]: val } };
 
+      case 'not_equal':
+        return { query: `e.${attr} != :${key}`, params: { [key]: val } };
+
+      case 'empty':
+        return { query: `e.${attr} IS NULL`, params: {} };
+
+      case 'not_empty':
+        return { query: `e.${attr} IS NOT NULL`, params: {} };
+
       default:
         throw new BadRequestException(`Unsupported operator for select: ${op}`);
     }
   }
 
-  private buildMultiSelectCondition(attr: string, val: any[], key: string) {
-    if (!Array.isArray(val)) {
-      throw new BadRequestException(`Expected array for multiselect: ${attr}`);
+  private buildMultiSelectCondition(
+    attr: string,
+    op: string,
+    val: any,
+    key: string,
+  ) {
+    if (Array.isArray(val) && val.length === 0) {
+      return { query: '1=1', params: {} };
+    }
+
+    if ((op === 'equal' || op === 'not_equal') && !Array.isArray(val)) {
+      throw new BadRequestException(
+        `Value for multi-select must be an array for operator: ${op}`,
+      );
+    }
+
+    switch (op) {
+      case 'equal':
+        return {
+          query: `e.${attr} IN (:${key})`,
+          params: { [key]: val },
+        };
+
+      case 'not_equal':
+        return {
+          query: `e.${attr} NOT IN (:${key})`,
+          params: { [key]: val },
+        };
+
+      case 'empty':
+        return { query: `e.${attr} IS NULL`, params: {} };
+
+      case 'not_empty':
+        return { query: `e.${attr} IS NOT NULL`, params: {} };
+
+      default:
+        throw new BadRequestException(
+          `Unsupported operator for multiselect: ${op}`,
+        );
     }
-    return {
-      query: `e.${attr} IN (:...${key})`,
-      params: { [key]: val },
-    };
   }
 }

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;
   }
 }

package/src/module/user/controller/login.controller.ts

@@ -67,17 +67,10 @@ export class LoginController {
       appcode: string;
     },
   ): Promise<any> {
-    const userId = req.user.userData.id;
-
-    const currentUserLevelType = req.user.userData.level_type;
-    const currentUserLevelId = req.user.userData.level_id;
-    const currentUserOrganization_id = req.user.userData.organization_id;
+    const currentUser = req.user.userData;
 
     return await this.userSessionService.switchCurrentLevelService(
-      userId,
-      currentUserLevelType,
-      currentUserLevelId,
-      currentUserOrganization_id,
+      currentUser,
       data,
     );
   }

package/src/module/user/service/user-session.service.ts

@@ -65,10 +65,7 @@ export class UserSessionService {
   }
 
   async switchCurrentLevelService(
-    userId: number,
-    currentUserLevelType: string,
-    currentUserLevelId: string,
-    currentUserOrgId: number,
+    currentUser: any,
     data: any,
   ): Promise<{ success: boolean; access_token: string; appcode: string }> {
     let payload;
@@ -89,15 +86,15 @@ export class UserSessionService {
     //   }
 
     payload = {
-      id: userId,
-      level_id: currentUserLevelId,
-      level_type: currentUserLevelType,
+      ...currentUser,
+      level_id: data.level_id,
+      level_type: data.level_type,
       appcode: data.appcode,
     };
 
     await this.dataSource.query(
       `UPDATE cr_user SET last_app_access = ? WHERE id = ?`,
-      [data.appcode, userId],
+      [data.appcode, currentUser.id],
     );
 
     // }