rez_core 7.0.7 → 7.0.8

package/package.json

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

package/src/config/database.config.ts

@@ -36,7 +36,7 @@ export class PostgresConfiguration implements TypeOrmOptionsFactory {
       database: this.configService.get('DB_NAME') || 'core',
       schema: this.configService.get('DB_SCHEMA') || 'package',
       entities: [__dirname + '/../module/**/*.entity.{ts,js}'],
-      synchronize: true,
+      synchronize: false,
       autoLoadEntities: true,
       // Configure pg pool size via `extra.max` (pg uses node-postgres pool)
       extra: {

package/src/module/filter/controller/filter.controller.ts

@@ -86,4 +86,129 @@ export class FilterController {
     const loggedInUser = req.user.userData;
     return this.savedFilterService.getSavedFilterByCode(code, loggedInUser);
   }
+
+  // ========== NEW HIERARCHICAL FILTER ENDPOINTS ==========
+
+  /**
+   * Test endpoint for GetFilterData (Core query builder)
+   * POST /filter/get-filter-data
+   * Body: {
+   *   entity_type: string,
+   *   filterConditions?: FilterCondition[],
+   *   sortColumns?: { column: string, order: 'ASC' | 'DESC' }[],
+   *   columns?: string[],
+   *   flatJson?: boolean,
+   *   ids?: number[],
+   *   pagination?: { page: number, size: number }
+   * }
+   */
+  @Post('get-filter-data')
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  async getFilterData(
+    @Body() body: any,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    const {
+      entity_type,
+      filterConditions = [],
+      sortColumns = [],
+      columns = [],
+      flatJson = false,
+      ids = [],
+      pagination,
+    } = body;
+
+    return this.filterService.GetFilterData(
+      entity_type,
+      filterConditions,
+      sortColumns,
+      columns,
+      flatJson,
+      ids,
+      pagination,
+      loggedInUser,
+    );
+  }
+
+  /**
+   * Test endpoint for GetFilterDataInternal (Filter aggregation)
+   * POST /filter/get-filter-data-internal
+   * Body: {
+   *   entity_type: string,
+   *   filterCode?: string,
+   *   quickFilter?: FilterCondition[],
+   *   columns?: string[],
+   *   flatJson?: boolean,
+   *   ids?: number[]
+   * }
+   */
+  @Post('get-filter-data-internal')
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  async getFilterDataInternal(
+    @Body() body: any,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    const {
+      entity_type,
+      filterCode,
+      quickFilter = [],
+      columns = [],
+      flatJson = false,
+      ids = [],
+    } = body;
+
+    return this.filterService.GetFilterDataInternal(
+      entity_type,
+      filterCode,
+      quickFilter,
+      columns,
+      flatJson,
+      ids,
+      loggedInUser,
+    );
+  }
+
+  /**
+   * Test endpoint for GetFilterDataForListing (UI layer with layout preferences)
+   * POST /filter/get-filter-data-for-listing
+   * Body: {
+   *   entity_type: string,
+   *   quickFilter?: FilterCondition[],
+   *   filterCode?: string,
+   *   attributeFilter?: FilterCondition[],
+   *   sortColumn?: { column: string, order: 'ASC' | 'DESC' },
+   *   pagination?: { page: number, size: number }
+   * }
+   */
+  @Post('get-filter-data-for-listing')
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  async getFilterDataForListing(
+    @Body() body: any,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    const {
+      entity_type,
+      quickFilter = [],
+      filterCode,
+      attributeFilter = [],
+      sortColumn,
+      pagination,
+    } = body;
+
+    return this.filterService.GetFilterDataForListing(
+      entity_type,
+      quickFilter,
+      filterCode,
+      attributeFilter,
+      sortColumn,
+      pagination,
+      loggedInUser,
+    );
+  }
 }

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

@@ -536,11 +536,11 @@ export class FilterService {
       );
     }
 
-    // const resolvedEntityList = await Promise.all(
-    //   formattedEntityList.map((row) =>
-    //     this.resolverService.getResolvedData(loggedInUser, row, entity_type),
-    //   ),
-    // );
+    const resolvedEntityList = await Promise.all(
+      formattedEntityList.map((row) =>
+        this.resolverService.getResolvedData(loggedInUser, row, entity_type),
+      ),
+    );
 
     let resolvedTabs = await Promise.all(
       filteredTabs.map(async (tab) => {
@@ -591,7 +591,7 @@ export class FilterService {
       success: true,
       data: {
         entity_tabs: resolvedTabs,
-        entity_list: finalEntityList,
+        entity_list: resolvedEntityList,
         is_hierarchical: isHierarchical,
         pagination: {
           total,
@@ -1379,6 +1379,339 @@ if (op === 'not_equal') {
     }
   }
 
+  /**
+   * Core filter data retrieval method
+   * @param entityType - Entity type to query
+   * @param filterConditions - Array of filter conditions
+   * @param sortColumns - Array of sort columns with order
+   * @param columns - Array of attribute keys to select (if empty, returns id and name)
+   * @param flatJson - Whether to use flat JSON structure
+   * @param ids - Optional array of IDs to filter by
+   * @param pagination - Pagination parameters (page, size)
+   * @param userData - Logged in user data
+   * @returns Object with entity_list and pagination info
+   */
+  async GetFilterData(
+    entityType: string,
+    filterConditions: FilterCondition[] = [],
+    sortColumns: { column: string; order: 'ASC' | 'DESC' }[] = [],
+    columns: string[] = [],
+    flatJson: boolean = false,
+    ids: number[] = [],
+    pagination?: { page: number; size: number },
+    userData?: any,
+  ) {
+    console.log('🔹 [GetFilterData] Starting with params:', {
+      entityType,
+      filterConditions,
+      sortColumns,
+      columns,
+      flatJson,
+      ids,
+      pagination,
+    });
+
+    // Get EntityMaster by EntityType
+    const entityMeta = await this.entityMasterService.getEntityData(
+      entityType,
+      userData,
+    );
+    const tableName = entityMeta?.data_source;
+
+    if (!tableName) {
+      throw new BadRequestException(`Invalid entity_type: ${entityType}`);
+    }
+
+    // Get AttributeMaster by EntityType
+    const getAttributeColumnMeta =
+      await this.attributeMasterService.findAttributesByMappedEntityType(
+        entityType,
+        userData,
+      );
+
+    const attributeMetaMap = getAttributeColumnMeta.reduce(
+      (acc, attr) => {
+        acc[attr.attribute_key] = attr;
+        return acc;
+      },
+      {} as Record<string, any>,
+    );
+
+    // Build WHERE clauses using existing function
+    const whereClauses = this.buildWhereClauses(
+      filterConditions,
+      attributeMetaMap,
+    );
+
+    // Add IDs condition if provided
+    if (ids && ids.length > 0) {
+      const idsStr = ids.map((id) => String(id));
+      whereClauses.push({
+        query: 'e.id::text = ANY(:ids)',
+        params: { ids: `{${idsStr.join(',')}}` },
+      });
+    }
+
+    // Build SELECT clause
+    let selectClause = 'e.*'; // Default to all columns
+    if (columns && columns.length > 0) {
+      // Select specific columns
+      const validColumns = columns
+        .filter((col) => attributeMetaMap[col])
+        .map((col) => `e.${col}`)
+        .join(', ');
+      selectClause = validColumns || 'e.id, e.name';
+    } else {
+      // If columns is empty, return id and name
+      selectClause = 'e.id, e.name';
+    }
+
+    // Build query
+    let qb = this.entityManager
+      .createQueryBuilder()
+      .select(selectClause)
+      .from(`${this.schema}.${tableName}`, 'e');
+
+    // Apply WHERE clauses
+    whereClauses.forEach((clause) => qb.andWhere(clause.query, clause.params));
+
+    // Build SORT clauses
+    if (sortColumns && sortColumns.length > 0) {
+      sortColumns.forEach(({ column, order }) => {
+        if (attributeMetaMap[column]) {
+          qb.addOrderBy(`e.${column}`, order);
+        }
+      });
+    }
+
+    // Apply pagination if provided
+    let page = 1;
+    let size = 10;
+    if (pagination && pagination.page > 0 && pagination.size > 0) {
+      page = pagination.page;
+      size = pagination.size;
+      qb.skip((page - 1) * size).take(size);
+    }
+
+    // Execute query
+    const query = qb.getQuery();
+    console.log('🔹 [GetFilterData] Executing query:', query);
+
+    const entity_list = await qb.getRawMany();
+
+    // Get total count
+    const countQb = this.entityManager
+      .createQueryBuilder()
+      .select('COUNT(*)', 'count')
+      .from(`${this.schema}.${tableName}`, 'e');
+    whereClauses.forEach((clause) =>
+      countQb.andWhere(clause.query, clause.params),
+    );
+    const countResult = await countQb.getRawOne();
+    const total = parseInt(countResult.count, 10);
+
+    console.log(
+      `🔹 [GetFilterData] Fetched ${entity_list.length} records, total: ${total}`,
+    );
+
+    const result: any = {
+      entity_list,
+    };
+
+    // Add pagination info if pagination was requested
+    if (pagination) {
+      result.pagination = {
+        total,
+        page,
+        size,
+        totalPages: Math.ceil(total / size),
+        hasNextPage: page * size < total,
+        hasPreviousPage: page > 1,
+      };
+    }
+
+    return result;
+  }
+
+  /**
+   * Internal filter data retrieval with filter code resolution
+   * @param entityType - Entity type to query
+   * @param filterCode - Saved filter code to resolve
+   * @param quickFilter - Quick filter conditions
+   * @param columns - Array of attribute keys to select
+   * @param flatJson - Whether to use flat JSON structure
+   * @param ids - Optional array of IDs to filter by
+   * @param userData - Logged in user data
+   * @returns Object with entity_list and pagination info
+   */
+  async GetFilterDataInternal(
+    entityType: string,
+    filterCode?: string,
+    quickFilter: FilterCondition[] = [],
+    columns: string[] = [],
+    flatJson: boolean = false,
+    ids: number[] = [],
+    userData?: any,
+  ) {
+    console.log('🔸 [GetFilterDataInternal] Starting with params:', {
+      entityType,
+      filterCode,
+      quickFilter,
+      columns,
+      flatJson,
+      ids,
+    });
+
+    // Aggregate filterCode + quickfilter
+    const savedFilters = await this.getSavedFilters(filterCode);
+
+    // Normalize saved filters to FilterCondition format
+    const savedFiltersNormalized = savedFilters.map((f) => ({
+      filter_attribute: f.filter_attribute,
+      filter_operator: f.filter_operator,
+      filter_value: f.filter_value,
+      filter_entity_type: entityType,
+    }));
+
+    // Merge all filters
+    const allFilters = [...quickFilter, ...savedFiltersNormalized].filter(
+      (f) => f.filter_value !== '' && f.filter_value != null,
+    );
+
+    console.log('🔸 [GetFilterDataInternal] Aggregated filters:', allFilters);
+
+    // Call GetFilterData
+    return await this.GetFilterData(
+      entityType,
+      allFilters,
+      [], // No sort columns at this level
+      columns,
+      flatJson,
+      ids,
+      undefined, // No pagination at this level
+      userData,
+    );
+  }
+
+  /**
+   * Filter data retrieval for listing with layout preferences
+   * @param entityType - Entity type to query
+   * @param quickFilter - Quick filter conditions
+   * @param filterCode - Saved filter code to resolve
+   * @param attributeFilter - Attribute filter conditions
+   * @param sortColumn - Sort column with order (will be overridden by layout preference)
+   * @param pagination - Pagination parameters
+   * @param userData - Logged in user data
+   * @returns Object with entity_list and pagination info
+   */
+  async GetFilterDataForListing(
+    entityType: string,
+    quickFilter: FilterCondition[] = [],
+    filterCode?: string,
+    attributeFilter: FilterCondition[] = [],
+    sortColumn?: { column: string; order: 'ASC' | 'DESC' },
+    pagination?: { page: number; size: number },
+    userData?: any,
+  ) {
+    console.log('🔷 [GetFilterDataForListing] Starting with params:', {
+      entityType,
+      quickFilter,
+      filterCode,
+      attributeFilter,
+      sortColumn,
+      pagination,
+    });
+
+    const { level_type, level_id, id: user_id } = userData || {};
+
+    // Check flat_json by EntityMaster
+    const entityMeta = await this.entityMasterService.getEntityData(
+      entityType,
+      userData,
+    );
+    const flatJson = (entityMeta as any)?.flat_json || false;
+
+    // Aggregate quickfilter[], attributeFilter[] and filterCode
+    const savedFilters = await this.getSavedFilters(filterCode);
+    const savedFiltersNormalized = savedFilters.map((f) => ({
+      filter_attribute: f.filter_attribute,
+      filter_operator: f.filter_operator,
+      filter_value: f.filter_value,
+      filter_entity_type: entityType,
+    }));
+
+    const allFilters = [
+      ...quickFilter,
+      ...attributeFilter,
+      ...savedFiltersNormalized,
+    ].filter((f) => f.filter_value !== '' && f.filter_value != null);
+
+    console.log('🔷 [GetFilterDataForListing] Aggregated filters:', allFilters);
+
+    // Get LayoutPreference by (EntityType, user_id, type:layout)
+    let layoutPreferenceRepo =
+      this.reflectionHelper.getRepoService('LayoutPreference');
+
+    const layoutPreference = await layoutPreferenceRepo.findOne({
+      where: {
+        user_id: user_id,
+        mapped_entity_type: entityType,
+        mapped_level_id: level_id,
+        mapped_level_type: level_type,
+        type: 'layout',
+      },
+    });
+
+    // Get col[] from LayoutPreference
+    let columns: string[] = [];
+    if (layoutPreference?.mapped_json?.columns) {
+      columns = layoutPreference.mapped_json.columns.map(
+        (col: any) => col.attribute_key || col,
+      );
+    } else {
+      // Default columns when no layout preference exists
+      columns = ['id', 'name', 'code', 'status', 'description'];
+    }
+
+    console.log('🔷 [GetFilterDataForListing] Layout columns:', columns);
+
+    // Get sortColumns[] from LayoutPreference (override sortColumn if exists)
+    let sortColumns: { column: string; order: 'ASC' | 'DESC' }[] = [];
+
+    if (layoutPreference?.mapped_json?.sorting?.sortby) {
+      // Layout preference sorting exists - override sortColumn
+      sortColumns = layoutPreference.mapped_json.sorting.sortby.map(
+        (sort: any) => ({
+          column: sort.column,
+          order: sort.order?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC',
+        }),
+      );
+      console.log(
+        '🔷 [GetFilterDataForListing] Using layout preference sorting:',
+        sortColumns,
+      );
+    } else if (sortColumn) {
+      // No layout preference - use provided sortColumn
+      sortColumns = [sortColumn];
+      console.log(
+        '🔷 [GetFilterDataForListing] Using provided sortColumn:',
+        sortColumns,
+      );
+    }
+
+    // Call GetFilterData
+    return await this.GetFilterData(
+      entityType,
+      allFilters,
+      sortColumns,
+      columns,
+      flatJson,
+      [],
+      pagination,
+      userData,
+    );
+  }
+
   async queryWithSchema(sql: string, params: any[] = []) {
     await this.entityManager.query('BEGIN');
     await this.entityManager.query(`SET LOCAL search_path TO ${this.schema}`);

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

@@ -15,6 +15,8 @@ import { FilterService } from 'src/module/filter/service/filter.service';
 export class LinkedAttributesService extends EntityServiceImpl {
   constructor(
     private readonly dataSource: DataSource,
+    @Inject('EntityMasterService')
+    protected readonly entityMasterService: EntityMasterService,
     @Inject('AttributeMasterService')
     private readonly attributeMasterService: AttributeMasterService,
     @Inject('SavedFilterService')

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

@@ -8,7 +8,8 @@ export class ListMasterItemsRepository {
   constructor(
     @InjectRepository(ListMasterItems)
     private repo: Repository<ListMasterItems>,
-  ) { }
+  ) {
+  }
 
   async create(item: Partial<ListMasterItems>) {
     const newItem = this.repo.create(item);
@@ -26,19 +27,53 @@ export class ListMasterItemsRepository {
     storage_type?,
     enterprise_id?: number,
     params?: Record<string, string>,
-    values?: any[]
+    values?: any[],
+    inactiveIds?: number[],
   ) {
     let orderBy: Record<string, 'ASC' | 'DESC'> = {};
 
+    if (values?.length) {
+      if (storage_type === 'code') {
+        const itemValues = await this.repo.find({
+          where: {
+            listtype: type,
+            code: In(values),
+          },
+          order: orderBy,
+        });
+
+        const itemsMapped = itemValues.map((i) => ({
+          label: `${i.name} [INACTIVE]`,
+          value: String(i.code),
+        }));
+
+        return [...itemsMapped];
+      } else {
+        const itemValues = await this.repo.find({
+          where: {
+            listtype: type,
+            id: In(values),
+          },
+          order: orderBy,
+        });
+
+        const itemsMapped = itemValues.map((i) => ({
+          label: `${i.name}`,
+          value: String(i.id),
+        }));
+
+        return [...itemsMapped];
+      }
+    }
+
+
     // Initial where clause
     const whereClause: any = {
       listtype: type,
-      // enterprise_id: enterprise_id,
+      enterprise_id: enterprise_id,
       status: 'ACTIVE',
     };
 
-
-
     // Helper to check numeric
     const isNumeric = (value: any) => !isNaN(Number(value));
 
@@ -88,21 +123,22 @@ export class ListMasterItemsRepository {
       value: storage_type === 'code' ? i.code : String(i.id),
     }));
 
+
     // Handle inactive items if specified
-    if (values?.length) {
+    if (inactiveIds?.length) {
       if (storage_type === 'code') {
         const inactiveItems = await this.repo.find({
           where: {
             listtype: type,
             enterprise_id: enterprise_id,
-            code: In(values),
+            code: In(inactiveIds),
           },
           order: orderBy,
         });
 
         const inactiveMapped = inactiveItems.map((i) => ({
           label: `${i.name} [INACTIVE]`,
-          value: String(i.id),
+          value: String(i.code),
         }));
 
         result = [...result, ...inactiveMapped];
@@ -111,7 +147,7 @@ export class ListMasterItemsRepository {
           where: {
             listtype: type,
             // enterprise_id: enterprise_id,
-            id: In(values),
+            id: In(inactiveIds),
           },
           order: orderBy,
         });