rez_core 1.0.86 → 1.0.89

package/package.json

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

package/src/constant/global.constant.ts

@@ -12,6 +12,8 @@ export const ENTITYTYPE_LISTMASTERITEMS = 'LMI';
 export const ENTITYTYPE_SECTIONMASTER = 'SEC';
 export const ENTITYTYPE_FIELDMASTER = 'FLD';
 export const ENTITYTYPE_USRROLMAP = 'URM';
+export const ENTITYTYPE_SAVEDFILTERMASTER = 'SFM';
+export const ENTITYTYPE_SAVEDFILTERDETAIL = 'SFD';
 
 
 export const STORAGETYPE_SINGLEJSON = 'singlejson';

package/src/core.module.ts

@@ -8,6 +8,7 @@ import { ModuleModule } from './module/module/module.module';
 import { NotificationModule } from './module/notification/notification.module';
 import { LayoutModule } from './module/layout/layout.module';
 import { ListMasterModule } from './module/listmaster/listmaster.module';
+import { FilterModule } from './module/filter/filter.module';
 
 @Global()
 @Module({})
@@ -21,7 +22,7 @@ export class CoreModule {
       module: CoreModule,
       imports: [
         ConfigModule.forRoot({ isGlobal: true }),
-        dbModule, // ✅ Make sure it's resolved
+        dbModule, 
         EntityModule,
         EnterpriseModule,
         UtilsModule,
@@ -30,6 +31,7 @@ export class CoreModule {
         NotificationModule,
         LayoutModule,
         ListMasterModule,
+        FilterModule
       ],
       exports: [
         ConfigModule,
@@ -42,7 +44,7 @@ export class CoreModule {
         NotificationModule,
         LayoutModule,
         ListMasterModule,
-
+        FilterModule
       ],
     };
   }

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

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

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

@@ -0,0 +1,26 @@
+// src/module/filter/dto/filter-request.dto.ts
+export interface FilterCondition {
+  filter_attribute: string;
+  filter_operator: string;
+  filter_value?: string | number | boolean;
+}
+
+export interface TabsConfig {
+  columnName: string;
+  value: string;
+  sortBy?: 'ASC' | 'DSC';
+}
+export interface SortConfig {
+  sortColum: string;
+  sortType: 'ASC' | 'DSC';
+}
+export interface FilterRequestDto {
+  entity_type: string;
+  quickFilter?: FilterCondition[];
+  savedFilterCode?: string;
+  attributeFilter?: FilterCondition[];
+  sortby?: SortConfig[];
+  tabs?: TabsConfig;
+  page?: number;
+  size?: number;
+}

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

@@ -0,0 +1,23 @@
+import { ENTITYTYPE_SAVEDFILTERDETAIL } from "src/constant/global.constant";
+import { BaseEntity } from "src/module/meta/entity/base-entity.entity";
+import { Column, Entity } from "typeorm";
+
+@Entity({ name: 'cr_saved_filter_detail' })
+export class SavedFilterDetail extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ENTITYTYPE_SAVEDFILTERDETAIL;
+  }
+
+  @Column()
+  mapped_filter_code: string; // This links to SavedFilterMaster.code (no relation, manual)
+
+  @Column()
+  filter_attribute: string;
+
+  @Column()
+  filter_operator: string;
+
+  @Column()
+  filter_value: string;
+}

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

@@ -0,0 +1,23 @@
+import { ENTITYTYPE_SAVEDFILTERMASTER } from "src/constant/global.constant";
+import { BaseEntity } from "src/module/meta/entity/base-entity.entity";
+import { Column, Entity } from "typeorm";
+
+@Entity({ name: 'cr_saved_filter_master' })
+export class SavedFilterMaster extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ENTITYTYPE_SAVEDFILTERMASTER;
+  }
+
+  @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

@@ -0,0 +1,21 @@
+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';
+import { SavedFilterMaster } from './entity/saved-filter-master.entity';
+import { SavedFilterRepositoryService } from './repository/saved-filter.repository';
+import { EntityModule } from '../meta/entity.module';
+import { FilterService } from './service/filter.service';
+import { FilterController } from './controller/filter.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([SavedFilterDetail,SavedFilterMaster]),forwardRef(() => EntityModule)],
+  controllers: [FilterController],
+  providers: [
+    { provide: 'SavedFilterService', useClass: SavedFilterService },
+   SavedFilterRepositoryService,
+   FilterService
+  ],
+  exports: ['SavedFilterService', SavedFilterRepositoryService],
+})
+export class FilterModule {}

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

@@ -0,0 +1,87 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository, Not } from 'typeorm';
+import { SavedFilterMaster } from '../entity/saved-filter-master.entity';
+import { SavedFilterDetail } from '../entity/saved-filter-detail.entity';
+
+@Injectable()
+export class SavedFilterRepositoryService {
+  constructor(
+    @InjectRepository(SavedFilterMaster)
+    private readonly savedFilterMasterRepo: Repository<SavedFilterMaster>,
+    @InjectRepository(SavedFilterDetail)
+    private readonly savedFilterDetailRepo: Repository<SavedFilterDetail>,
+  ) {}
+
+  async isFilterNameExists(
+    name: string,
+    orgId: number,
+    entId: number,
+    excludeId?: number,
+  ): Promise<boolean> {
+    const where: any = {
+      name,
+      organization_id: orgId,
+      enterprise_id: entId,
+    };
+    if (excludeId) {
+      where.id = Not(excludeId);
+    }
+
+    const existing = await this.savedFilterMasterRepo.findOne({ where });
+    return !!existing;
+  }
+
+  async getDetailsByCode(code: string): Promise<SavedFilterDetail[]> {
+    return this.savedFilterDetailRepo.find({
+      where: { mapped_filter_code: code },
+    });
+  }
+
+  async deleteDetailsByCode(code: string): Promise<void> {
+    await this.savedFilterDetailRepo.delete({ mapped_filter_code: code });
+  }
+
+  async saveDetails(details: Partial<SavedFilterDetail>[]): Promise<void> {
+    const entities = this.savedFilterDetailRepo.create(details);
+    await this.savedFilterDetailRepo.save(entities);
+  }
+
+  async updateCode(id: number, code: string): Promise<void> {
+    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

@@ -0,0 +1,326 @@
+import { Injectable, BadRequestException, Inject } from '@nestjs/common';
+import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
+import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
+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 {
+  constructor(
+    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 gettab_value_counts(
+    tableName: string,
+    column: string | undefined,
+    whereClauses: 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}`);
+
+    whereClauses.forEach((clause) => qb.andWhere(clause.query, clause.params));
+
+    const rows = await qb.getRawMany();
+
+    const total = rows.reduce((sum, r) => sum + parseInt(r.tab_value_count), 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),
+      })),
+    ];
+  }
+
+  async applyFilter(dto: FilterRequestDto) {
+    const {
+      entity_type,
+      quickFilter,
+      savedFilterCode,
+      attributeFilter,
+      tabs,
+      sortby,
+    } = dto;
+
+    // Fetch meta
+    const entityMeta =
+      await this.entityMasterService.getEntityData(entity_type);
+    const tableName = entityMeta?.db_table_name;
+    if (!tableName)
+      throw new BadRequestException(`Invalid entity_type: ${entity_type}`);
+
+    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 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;
+      },
+      {} as Record<string, any>,
+    );
+
+    // Get and parse filters
+    const savedFilters = await this.getSavedFilters(savedFilterCode);
+    const baseFilters = [
+      ...(quickFilter || []),
+      ...savedFilters,
+      ...(attributeFilter || []),
+    ];
+    const baseWhere = this.buildWhereClauses(baseFilters, attributeMetaMap);
+
+    // Build query for tab counts (no tab.value filter here)
+    const allTabs = await this.gettab_value_counts(
+      tableName,
+      tabs?.columnName,
+      baseWhere,
+    );
+
+    // Add tab.value filter only if present
+    const dataWhere = [...baseWhere];
+    if (tabs?.columnName && tabs?.value) {
+      const tabAttrMeta = attributeMetaMap[tabs.columnName];
+      const tabCondition = this.buildCondition(
+        {
+          filter_attribute: tabs.columnName,
+          filter_operator: 'equal',
+          filter_value: tabs.value,
+        },
+        tabAttrMeta,
+      );
+      if (tabCondition) {
+        dataWhere.push(tabCondition);
+      }
+    }
+
+    // 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));
+
+    // Optional sorting
+    if (Array.isArray(sortby)) {
+      sortby.forEach(({ sortColum, sortType }) => {
+        qb.addOrderBy(
+          `e.${sortColum}`,
+          sortType.toUpperCase() === 'DSC' ? 'DESC' : 'ASC',
+        );
+      });
+    }
+
+    // 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: {
+          total,
+          page,
+          size,
+          totalPages: Math.ceil(total / size),
+          hasNextPage: page * size < total,
+          hasPreviousPage: page > 1,
+        },
+      },
+    };
+  }
+
+  private parseFilters(raw: any, isSingle = false): any[] {
+    if (!raw) return [];
+
+    if (typeof raw === 'string') {
+      try {
+        const parsed = JSON.parse(raw);
+        return isSingle ? [parsed] : parsed;
+      } catch {
+        throw new BadRequestException('Invalid JSON in filter input');
+      }
+    }
+
+    return isSingle ? [raw] : Array.isArray(raw) ? raw : [];
+  }
+
+  private async getSavedFilters(code?: string): Promise<any[]> {
+    if (!code) return [];
+
+    const savedFilter = await this.savedFilterService.getDetailsByCode(code);
+    if (!savedFilter) {
+      throw new BadRequestException(`Saved filter not found for code: ${code}`);
+    }
+
+    console.log(savedFilter);
+    return savedFilter;
+  }
+
+  private buildWhereClauses(
+    filters: any[],
+    attributeMeta: Record<string, any>,
+  ) {
+    return filters
+      .map((f) => this.buildCondition(f, attributeMeta[f.filter_attribute]))
+      .filter(
+        (clause): clause is { query: string; params: any } => clause !== null,
+      );
+  }
+
+  private buildCondition(
+    filter: any,
+    meta: any,
+  ): { query: string; params: any } | null {
+    if (!meta) return null;
+
+    const 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)}`;
+
+    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;
+    }
+  }
+
+  private buildTextCondition(attr: string, op: string, val: any, key: string) {
+    switch (op) {
+      case 'contains':
+        return {
+          query: `LOWER(e.${attr}) LIKE :${key}`,
+          params: { [key]: `%${val.toLowerCase()}%` },
+        };
+      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 text: ${op}`);
+    }
+  }
+
+  private buildNumberCondition(
+    attr: string,
+    op: string,
+    val: any,
+    key: string,
+  ) {
+    switch (op) {
+      case 'equal':
+        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
+      case 'not_equal':
+        return { query: `e.${attr} != :${key}`, params: { [key]: val } };
+      case 'greater_than':
+        return { query: `e.${attr} > :${key}`, params: { [key]: val } };
+      case 'less_than':
+        return { query: `e.${attr} < :${key}`, params: { [key]: val } };
+      default:
+        throw new BadRequestException(`Unsupported operator for number: ${op}`);
+    }
+  }
+
+  private buildDateCondition(attr: string, op: string, val: any, key: string) {
+    switch (op) {
+      case 'equal':
+        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
+      case 'before':
+        return { query: `e.${attr} < :${key}`, params: { [key]: val } };
+      case 'after':
+        return { query: `e.${attr} > :${key}`, params: { [key]: val } };
+      default:
+        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

@@ -0,0 +1,103 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+import { UserData } from '../../user/entity/user.entity';
+import { SavedFilterMaster } from '../entity/saved-filter-master.entity';
+import { SavedFilterDetail } from '../entity/saved-filter-detail.entity';
+import { ENTITYTYPE_SAVEDFILTERMASTER } from 'src/constant/global.constant';
+import { SavedFilterRepositoryService } from '../repository/saved-filter.repository';
+
+@Injectable()
+export class SavedFilterService extends EntityServiceImpl {
+  constructor(private readonly savedFilterRepo: SavedFilterRepositoryService) {
+    super();
+  }
+
+  async createEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData | null,
+  ): Promise<BaseEntity> {
+    const master = entityData as SavedFilterMaster;
+  
+    const exists = await this.savedFilterRepo.isFilterNameExists(
+      master.name,
+      master.organization_id,
+      master.enterprise_id,
+    );
+  
+    if (exists) {
+      throw new BadRequestException('Saved filter name already exists.');
+    }
+  
+    // Save the master record without code
+    const savedMaster = await super.createEntity(master, loggedInUser);
+  
+    // Generate the code like SFM00001 using the saved ID
+    const code = `SFM${savedMaster.id.toString().padStart(5, '0')}`;
+  
+    // Update the code
+    savedMaster.code = code;
+    await this.savedFilterRepo.updateCode(savedMaster.id, code);
+  
+    // Save filter details using generated code
+    const details = (entityData as any).filterDetails ?? [];
+    if (details.length) {
+      const prepared = details.map((detail: any) => ({
+        ...detail,
+        mapped_filter_code: savedMaster.code,
+      }));
+  
+      await this.savedFilterRepo.saveDetails(prepared);
+    }
+  
+    return savedMaster;
+  }
+
+  async updateEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData | null,
+  ): Promise<BaseEntity> {
+    const master = entityData as SavedFilterMaster;
+
+    const existing = await this.getEntityData(
+      ENTITYTYPE_SAVEDFILTERMASTER,
+      master.id,
+    );
+    if (!existing) {
+      throw new BadRequestException('Saved filter not found.');
+    }
+
+    const nameExists = await this.savedFilterRepo.isFilterNameExists(
+      master.name,
+      master.organization_id,
+      master.enterprise_id,
+      master.id,
+    );
+
+    if (nameExists) {
+      throw new BadRequestException('Saved filter name already exists.');
+    }
+
+    const { filterDetails, ...persistableData } = master as any;
+    const updated = await super.updateEntity(persistableData, loggedInUser);
+
+    if (filterDetails?.length) {
+      await this.savedFilterRepo.deleteDetailsByCode(updated.code);
+
+      const prepared = filterDetails.map((detail: any) => ({
+        ...detail,
+        mapped_filter_code: updated.code,
+      }));
+
+      await this.savedFilterRepo.saveDetails(prepared);
+    }
+
+    return updated;
+  }
+
+  async getDetailsByCode(code: string): Promise<SavedFilterDetail[]> {
+    return this.savedFilterRepo.getDetailsByCode(code);
+  }
+
+ 
+}