rez_core 1.0.88 → 1.0.89

package/package.json

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

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

@@ -1,4 +1,4 @@
-import { Controller, Post, Body } from '@nestjs/common';
+import { Controller, Post, Body, Query, ParseIntPipe } from '@nestjs/common';
 import { FilterService } from '../service/filter.service';
 
 @Controller('filter')
@@ -6,7 +6,11 @@ export class FilterController {
   constructor(private readonly filterService: FilterService) {}
 
   @Post()
-  async applyFilter(@Body() body: any) {
+  async applyFilter(
+    @Body() body: any,
+    @Query('page', ParseIntPipe) page: number = 1,
+    @Query('size', ParseIntPipe) size: number = 10,
+  ) {
     const {
       entity_type,
       quickFilter,
@@ -23,6 +27,8 @@ export class FilterController {
       attributeFilter,
       tabs,
       sortby,
+      page,
+      size,
     });
   }
 }

package/src/module/filter/dto/filter-request.dto.ts

@@ -21,4 +21,6 @@ export interface FilterRequestDto {
   attributeFilter?: FilterCondition[];
   sortby?: SortConfig[];
   tabs?: TabsConfig;
+  page?: number;
+  size?: number;
 }

package/src/module/filter/entity/saved-filter-master.entity.ts

@@ -11,4 +11,13 @@ export class SavedFilterMaster extends BaseEntity {
 
   @Column({ length: 50, type: 'varchar', nullable: true })
   app_code: string;
+
+  @Column({ length: 50, type: 'varchar', nullable: true })
+  mapped_entity_type: string;
+
+  @Column({ type: 'int', nullable: true })
+  user_id: number;
+
+  @Column({ type: 'boolean', default: false })
+  is_default: boolean;
 }

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

@@ -1,4 +1,4 @@
-import { Module } from '@nestjs/common';
+import { forwardRef, Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { SavedFilterService } from './service/saved-filter.service';
 import { SavedFilterDetail } from './entity/saved-filter-detail.entity';
@@ -9,7 +9,7 @@ import { FilterService } from './service/filter.service';
 import { FilterController } from './controller/filter.controller';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([SavedFilterDetail,SavedFilterMaster]),EntityModule],
+  imports: [TypeOrmModule.forFeature([SavedFilterDetail,SavedFilterMaster]),forwardRef(() => EntityModule)],
   controllers: [FilterController],
   providers: [
     { provide: 'SavedFilterService', useClass: SavedFilterService },

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

@@ -51,4 +51,37 @@ export class SavedFilterRepositoryService {
     await this.savedFilterMasterRepo.update(id, { code });
   }
   
+  async getDefaultFilterByEntityType(entityType: string): Promise<{ label: string; value: number } | null> {
+    const filter = await this.savedFilterMasterRepo.findOne({
+      where: {
+        mapped_entity_type: entityType,
+        is_default: true,
+      },
+    });
+  
+    return filter ? { label: filter.name, value: filter.id } : null;
+  }
+  
+  async getSavedFiltersByUserIdAndEntityType(
+    userId: number,
+    entityType: string
+  ){
+    const filters = await this.savedFilterMasterRepo.find({
+      where: {
+        user_id: userId,
+        mapped_entity_type: entityType,
+      },
+      order: {
+        modified_date: 'DESC',
+      },
+    });
+  
+    return filters.map(filter => ({
+      label: filter.name,
+      value: filter.id,
+    }));
+  }
+  
+  
+  
 }

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

@@ -4,6 +4,9 @@ import { EntityMasterService } from 'src/module/meta/service/entity-master.servi
 import { DataSource } from 'typeorm';
 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 {
@@ -11,11 +14,13 @@ export class FilterService {
     private dataSource: DataSource,
     private readonly entityMasterService: EntityMasterService,
     private readonly attributeMasterService: AttributeMasterService,
+    private readonly entityTableService: EntityTableService,
+    private readonly entityTableColumnService: EntityTableColumnService,
     @Inject('SavedFilterService')
     private readonly savedFilterService: SavedFilterService,
   ) {}
 
-  private async getTabCounts(
+  private async gettab_value_counts(
     tableName: string,
     column: string | undefined,
     whereClauses: any[],
@@ -25,21 +30,21 @@ export class FilterService {
     const qb = this.dataSource
       .getRepository(tableName)
       .createQueryBuilder('e')
-      .select(`e.${column}`, 'tabName')
-      .addSelect('COUNT(*)', 'tabCount')
+      .select(`e.${column}`, 'tab_value')
+      .addSelect('COUNT(*)', 'tab_value_count')
       .groupBy(`e.${column}`);
 
     whereClauses.forEach((clause) => qb.andWhere(clause.query, clause.params));
 
     const rows = await qb.getRawMany();
 
-    const total = rows.reduce((sum, r) => sum + parseInt(r.tabCount), 0);
+    const total = rows.reduce((sum, r) => sum + parseInt(r.tab_value_count), 0);
 
     return [
-      { tabName: 'All', tabCount: total },
+      { tab_value: 'All', tab_value_count: total },
       ...rows.map((r) => ({
-        tabName: r.tabName || 'UNKNOWN',
-        tabCount: parseInt(r.tabCount),
+        tab_value: r.tab_value || 'UNKNOWN',
+        tab_value_count: parseInt(r.tab_value_count),
       })),
     ];
   }
@@ -61,11 +66,30 @@ export class FilterService {
     if (!tableName)
       throw new BadRequestException(`Invalid entity_type: ${entity_type}`);
 
-    const attributeMeta =
-      await this.attributeMasterService.findAttributesByMappedEntityType(
+    const getTableMeta =
+      await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
         entity_type,
+        entity_type,
+        'LIST',
+      );
+
+    if (!getTableMeta) {
+      throw new BadRequestException(
+        `Table meta not found for entity_type: ${entity_type}`,
       );
-    const attributeMetaMap = attributeMeta.reduce(
+    }
+    const getTableColumnMeta =
+      await this.entityTableColumnService.findByParentIdAndParentType(
+        getTableMeta.id,
+        getTableMeta.entity_type,
+        true,
+      );
+
+    // const attributeMeta =
+    //   await this.attributeMasterService.findAttributesByMappedEntityType(
+    //     entity_type,
+    //   );
+    const attributeMetaMap = getTableColumnMeta.reduce(
       (acc, attr) => {
         acc[attr.attribute_key] = attr;
         return acc;
@@ -83,7 +107,7 @@ export class FilterService {
     const baseWhere = this.buildWhereClauses(baseFilters, attributeMetaMap);
 
     // Build query for tab counts (no tab.value filter here)
-    const allTabs = await this.getTabCounts(
+    const allTabs = await this.gettab_value_counts(
       tableName,
       tabs?.columnName,
       baseWhere,
@@ -106,6 +130,7 @@ 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));
@@ -120,14 +145,26 @@ export class FilterService {
       });
     }
 
-    const entity_list = await qb.getMany();
+    // Pagination
+    const page = dto.page && dto.page > 0 ? dto.page : 1;
+    const size = dto.size && dto.size > 0 ? dto.size : 10;
+    qb.skip((page - 1) * size).take(size);
+
+    const [entity_list, total] = await qb.getManyAndCount();
 
     return {
       success: true,
       data: {
         entity_tabs: allTabs,
         entity_list,
-        pagination: [], // add pagination later if needed
+        pagination: {
+          total,
+          page,
+          size,
+          totalPages: Math.ceil(total / size),
+          hasNextPage: page * size < total,
+          hasPreviousPage: page > 1,
+        },
       },
     };
   }
@@ -181,13 +218,17 @@ export class FilterService {
     const op = filter.filter_operator;
     const key = `param_${attr}_${Math.random().toString(36).substring(2, 8)}`;
 
-    switch (meta.db_datatype) {
-      case 'varchar':
+    switch (meta.data_type) {
+      case 'text':
         return this.buildTextCondition(attr, op, val, key);
       case 'number':
         return this.buildNumberCondition(attr, op, val, key);
       case 'date':
         return this.buildDateCondition(attr, op, val, key);
+      case 'select':
+        return this.buildSelectCondition(attr, op, val, key);
+      case 'multiselect':
+        return this.buildMultiSelectCondition(attr, val, key);
       default:
         return null;
     }
@@ -257,4 +298,29 @@ export class FilterService {
         throw new BadRequestException(`Unsupported operator for date: ${op}`);
     }
   }
+
+  private buildSelectCondition(
+    attr: string,
+    op: string,
+    val: any,
+    key: string,
+  ) {
+    switch (op) {
+      case 'equal':
+        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
+
+      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}`);
+    }
+    return {
+      query: `e.${attr} IN (:...${key})`,
+      params: { [key]: val },
+    };
+  }
 }

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

@@ -98,4 +98,6 @@ export class SavedFilterService extends EntityServiceImpl {
   async getDetailsByCode(code: string): Promise<SavedFilterDetail[]> {
     return this.savedFilterRepo.getDetailsByCode(code);
   }
+
+ 
 }

package/src/module/listmaster/listmaster.module.ts

@@ -1,4 +1,4 @@
-import { Module } from '@nestjs/common';
+import { forwardRef, Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { ListMasterData } from './entity/list-master.entity';
 import { ListMasterItems } from './entity/list-master-items.entity';
@@ -11,8 +11,9 @@ import { ThirdPartyModule } from '../third-party-module/third-party.module';
 import { HttpModule } from '@nestjs/axios';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([ListMasterData, ListMasterItems]),EntityModule, ThirdPartyModule, HttpModule],
+  imports: [TypeOrmModule.forFeature([ListMasterData, ListMasterItems]),forwardRef(() => EntityModule), ThirdPartyModule, HttpModule],
   providers: [ListMasterRepository, ListMasterItemsRepository, ListMasterService],
-  controllers: [ListMasterController]
+  controllers: [ListMasterController],
+  exports:[ListMasterService]
 })
 export class ListMasterModule {}

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

@@ -10,17 +10,18 @@ import { ApiRegistryService } from '../../third-party-module/service/api-registr
 import { firstValueFrom } from 'rxjs';
 import { HttpService } from '@nestjs/axios';
 import { EntityManager } from 'typeorm';
+import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
 
 @Injectable()
-export class ListMasterService extends EntityServiceImpl {
+export class ListMasterService  {
   constructor(
     private readonly entityManager: EntityManager,
+    private readonly entityMasterService: EntityMasterService,
     private readonly listMasterRepo: ListMasterRepository,
     private readonly listItemsRepo: ListMasterItemsRepository,
     private readonly apiRegistryService: ApiRegistryService,
     private readonly httpService: HttpService,
   ) {
-    super();
   }
 
   async getDropdownOptions(type: string, params: Record<string, string>) {

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

@@ -1,4 +1,4 @@
-import { Controller, HttpStatus, Post, Query, Res, UseGuards } from '@nestjs/common';
+import { Controller, HttpStatus, Post, Query, Req, Res, UseGuards } from '@nestjs/common';
 import { EntityTableService } from '../service/entity-table.service';
 import { Response } from 'express';
 import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
@@ -11,8 +11,11 @@ export class MetaController {
   @Post('get-table-data')
   async getTableMetaData(@Query('entity_type') entityType: string,
                          @Query('list_type') listType: string,
-                         @Res() response: Response) {
-    let entityTableDto = await this.entityTableService.getTableMetaDataForListing(entityType, listType);
+                         @Res() response: Response,
+                        @Req() req: Request & { user: any }) {
+                          const userId = req.user.userId;
+                          console.log(userId)
+    let entityTableDto = await this.entityTableService.getTableMetaDataForListing(entityType, listType,userId);
     return response.status(HttpStatus.OK).json({
       success: true,
       data: entityTableDto,

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

@@ -3,4 +3,8 @@ import { EntityTableColumn } from '../entity/entity-table-column.entity';
 
 export class EntityTableDto extends EntityTable{
   column_list: EntityTableColumn[];
+  operation_list:{};
+  default_filter:{} | null;
+  saved_filter:{ label: string; value: number }[]
+  | null;
 }

package/src/module/meta/entity.module.ts

@@ -1,4 +1,4 @@
-import { Module } from '@nestjs/common';
+import { forwardRef, Module } from '@nestjs/common';
 import { EntityMasterService } from './service/entity-master.service';
 import { EntityServiceImpl } from './service/entity-service-impl.service';
 import { EntityController } from './controller/entity.controller';
@@ -36,6 +36,8 @@ import { ViewMasterController } from './controller/view-master.controller';
 import { ViewMaterRespository } from './repository/view-master.repository';
 import { MetaController } from './controller/meta.controller';
 import { EntityValidationService } from './service/entity-validation.service';
+import { ListMasterModule } from '../listmaster/listmaster.module';
+import { FilterModule } from '../filter/filter.module';
 
 @Module({
   imports: [
@@ -52,8 +54,9 @@ import { EntityValidationService } from './service/entity-validation.service';
       SectionMaster,
       FieldGroup,
     ]),
-    UtilsModule,
-  ],
+    forwardRef(() => ListMasterModule),
+    forwardRef(() => FilterModule),
+    UtilsModule  ],
   providers: [
     EntityMasterService,
     EntityServiceImpl,
@@ -80,15 +83,21 @@ import { EntityValidationService } from './service/entity-validation.service';
     EntityServiceImpl,
     PreferenceService,
     EntityListService,
-    EntityTableService,
     EntityValidationService,
+    EntityTableService,
     EntityTableColumnService,
     MediaDataService,
     SectionMasterService,
     FieldGroupService,
     'ViewMasterService',
-    AttributeMasterService
+    AttributeMasterService,
+  ],
+  controllers: [
+    EntityController,
+    MasterController,
+    MediaController,
+    ViewMasterController,
+    MetaController,
   ],
-  controllers: [EntityController, MasterController, MediaController, ViewMasterController, MetaController],
 })
 export class EntityModule {}

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

@@ -10,23 +10,27 @@ export class EntityTableColumnRepository {
     private entityTableColumnRepository: Repository<EntityTableColumn>,
   ) {}
 
-  async findByParentIdAndParentType(parentId: number, parentType: string, nonVisible?) {
-    if (nonVisible) {
+  async findByParentIdAndParentType(
+    parentId: number,
+    parentType: string,
+    isVisible?: boolean,
+  ) {
+    if (isVisible) {
       return await this.entityTableColumnRepository.find({
         where: {
           parent_id: parentId,
           parent_type: parentType,
         },
-        order: { col_position: 'ASC' }
+        order: { col_position: 'ASC' },
       });
     }
     return await this.entityTableColumnRepository.find({
       where: {
         parent_id: parentId,
         parent_type: parentType,
-        visible: "1",
+        visible: '1',
       },
-      order: { col_position: 'ASC' }
+      order: { col_position: 'ASC' },
     });
   }
 }

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

@@ -1,8 +1,7 @@
-import { Injectable } from "@nestjs/common";
-import { InjectRepository } from "@nestjs/typeorm";
-import { In } from "typeorm";
-import { AttributeMasterRepository } from "../repository/attribute-master.repository";
-
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { In } from 'typeorm';
+import { AttributeMasterRepository } from '../repository/attribute-master.repository';
 
 @Injectable()
 export class AttributeMasterService {
@@ -10,8 +9,9 @@ export class AttributeMasterService {
     private readonly attributeMasterRepository: AttributeMasterRepository,
   ) {}
 
-  async findAttributesByMappedEntityType(entity_type){
-    return await this.attributeMasterRepository.findAttributesByMappedEntityType(entity_type);
+  async findAttributesByMappedEntityType(entity_type) {
+    return await this.attributeMasterRepository.findAttributesByMappedEntityType(
+      entity_type,
+    );
   }
-
-}
+}

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

@@ -21,11 +21,16 @@ export class EntityTableColumnService {
     return attributeJson;
   }
 
-  async findByParentIdAndParentType(parentId: number, parentType: string) {
+  async findByParentIdAndParentType(
+    parentId: number,
+    parentType: string,
+    isVisible?: boolean,
+  ) {
     let entityTableColumns =
       await this.entityTableColumnRepository.findByParentIdAndParentType(
         parentId,
         parentType,
+        isVisible,
       );
     return entityTableColumns;
   }

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

@@ -1,15 +1,23 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { EntityTableRepository } from '../repository/entity-table.repository';
 import { EntityTableColumnRepository } from '../repository/entity-table-column.repository';
 import { EntityTableDto } from '../dto/entity-table.dto';
 import { DISPLAY_LIST } from '../../../constant/global.constant';
+import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
+import { SavedFilterService } from 'src/module/filter/service/saved-filter.service';
+import { SavedFilterRepositoryService } from 'src/module/filter/repository/saved-filter.repository';
 
 @Injectable()
 export class EntityTableService {
   constructor(
     private entityTableRepository: EntityTableRepository,
     private readonly entityTableColumnRepository: EntityTableColumnRepository,
-  ) {}
+    @Inject(forwardRef(() => ListMasterService)) 
+  private readonly listMasterService: ListMasterService,
+  
+  private readonly savedFilterRepoService: SavedFilterRepositoryService,
+  ) {
+  }
 
   async findByEntityTypeAndListType(entityType: string, listType: string) {
     return await this.entityTableRepository.findByEntityTypeAndListType(
@@ -30,14 +38,15 @@ export class EntityTableService {
     );
   }
 
-  async getTableMetaDataForListing(entityType: string, listType: string) {
-    return await this.getTableMetaData(entityType, listType, DISPLAY_LIST);
+  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
   ) {
     let entityTable = await this.findByEntityTypeAndListTypeAndDisplayType(
       entityType,
@@ -52,7 +61,18 @@ export class EntityTableService {
           entityTable.id,
           entityTable.entity_type,
         );
+        entityTableDto.operation_list = {
+          "text": await this.listMasterService.getDropdownOptions("OPT",{})
+          // 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/module/entity/module.entity.ts

@@ -35,7 +35,9 @@ export class ModuleData {
   @Column({ type: 'varchar', length: 100, nullable: true })
   title: string;
 
+  @Column({ type: 'varchar', length: 100, nullable: true })
+  component_name: string;
+
   @Column({ type: 'json', nullable: true })
   ui_config: JSON;
-
 }