rez_core 1.0.85 → 1.0.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "1.0.85",
+  "version": "1.0.88",
   "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,28 @@
+import { Controller, Post, Body } 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) {
+    const {
+      entity_type,
+      quickFilter,
+      savedFilterCode,
+      attributeFilter,
+      tabs,
+      sortby,
+    } = body;
+
+    return this.filterService.applyFilter({
+      entity_type,
+      quickFilter,
+      savedFilterCode,
+      attributeFilter,
+      tabs,
+      sortby,
+    });
+  }
+}

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

@@ -0,0 +1,24 @@
+// 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;
+}

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,14 @@
+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;
+}

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

@@ -0,0 +1,21 @@
+import { 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]),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,54 @@
+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 });
+  }
+  
+}

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

@@ -0,0 +1,260 @@
+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';
+
+@Injectable()
+export class FilterService {
+  constructor(
+    private dataSource: DataSource,
+    private readonly entityMasterService: EntityMasterService,
+    private readonly attributeMasterService: AttributeMasterService,
+    @Inject('SavedFilterService')
+    private readonly savedFilterService: SavedFilterService,
+  ) {}
+
+  private async getTabCounts(
+    tableName: string,
+    column: string | undefined,
+    whereClauses: any[],
+  ) {
+    if (!column) return [];
+
+    const qb = this.dataSource
+      .getRepository(tableName)
+      .createQueryBuilder('e')
+      .select(`e.${column}`, 'tabName')
+      .addSelect('COUNT(*)', 'tabCount')
+      .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);
+
+    return [
+      { tabName: 'All', tabCount: total },
+      ...rows.map((r) => ({
+        tabName: r.tabName || 'UNKNOWN',
+        tabCount: parseInt(r.tabCount),
+      })),
+    ];
+  }
+
+  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 attributeMeta =
+      await this.attributeMasterService.findAttributesByMappedEntityType(
+        entity_type,
+      );
+    const attributeMetaMap = attributeMeta.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.getTabCounts(
+      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
+    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',
+        );
+      });
+    }
+
+    const entity_list = await qb.getMany();
+
+    return {
+      success: true,
+      data: {
+        entity_tabs: allTabs,
+        entity_list,
+        pagination: [], // add pagination later if needed
+      },
+    };
+  }
+
+  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.db_datatype) {
+      case 'varchar':
+        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);
+      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}`);
+    }
+  }
+}

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

@@ -0,0 +1,101 @@
+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);
+  }
+}

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

@@ -87,6 +87,7 @@ import { EntityValidationService } from './service/entity-validation.service';
     SectionMasterService,
     FieldGroupService,
     'ViewMasterService',
+    AttributeMasterService
   ],
   controllers: [EntityController, MasterController, MediaController, ViewMasterController, MetaController],
 })

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

@@ -87,18 +87,24 @@ export class EntityListService {
       query += whereClause.query;
     }
     query += ' GROUP BY ' + entityTable.tab_column;
+  
     let tabs = await this.entityManager.query(query, whereClause.argumentList);
+  
     let all = 0;
     for (const i in tabs) {
       let tab = tabs[i] as EntityTab;
+      tab.tab_value = String(tab.tab_value).toUpperCase(); // Capitalize tab_value
       all += parseInt(String(tab.tab_value_count));
     }
+  
     let entityTab = new EntityTab();
     entityTab.tab_value = 'ALL';
     entityTab.tab_value_count = all;
     tabs.push(entityTab);
+  
     return tabs.reverse();
   }
+  
 
   private getQuery(source: string, groupByColumn: string | null) {
     if (groupByColumn) {

package/src/module/meta/service/media-data.service.ts

@@ -124,7 +124,7 @@ export class MediaDataService extends EntityServiceImpl {
         Key: mediaData.media_url,
         Expires: 60 * 5, // URL valid for 5 mins
       });
-      return {signedUrl,fileName: mediaData.file_name,id:mediaData.id};
+      return {signedUrl,name: mediaData.file_name,id:mediaData.id};
     } catch (error) {
       console.error('Error generating signed URL for media:', error);
       throw new Error('Failed to generate signed URL');

package/src/resources/dev.properties.yaml

@@ -1,8 +1,8 @@
 # DB_HOST: "13.234.25.234"
-DB_HOST: "localhost"
+DB_HOST: "13.234.25.234"
 DB_PORT: "3306"
 DB_USER: "root"
-DB_PASS: "root"
+DB_PASS: "Rezolut@123"
 DB_NAME: "core"
 MASTER_KEY: "0QZ2eRJv5oVILYnyBlC+FbSGVQiWKReh"
 MASTER_IV: "heuUQf5uPVtkotrFAOKUVw=="

package/src/resources/properties.yaml.ts

@@ -2,7 +2,7 @@ import { readFileSync } from 'fs';
 import * as yaml from 'js-yaml';
 import { join } from 'path';
 
-const YAML_CONFIG = `/uat.properties.yaml`;
+const YAML_CONFIG = `/dev.properties.yaml`;
 
 export default () => {
   return yaml.load(