rez_core 2.1.47 → 2.1.49

package/package.json

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

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

@@ -1,6 +1,6 @@
-import { ENTITYTYPE_SAVEDFILTERDETAIL } from "src/constant/global.constant";
-import { BaseEntity } from "src/module/meta/entity/base-entity.entity";
-import { Column, Entity } from "typeorm";
+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 {
@@ -20,4 +20,7 @@ export class SavedFilterDetail extends BaseEntity {
 
   @Column()
   filter_value: string;
+
+  @Column({ nullable: true })
+  data_type: string;
 }

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

@@ -77,7 +77,7 @@ export class SavedFilterRepositoryService {
         status: 'ACTIVE',
       },
       order: {
-        modified_date: 'DESC',
+        created_date: 'DESC',
       },
     });
 
@@ -91,7 +91,7 @@ export class SavedFilterRepositoryService {
     {
       filter_attribute: string;
       filter_operator: string;
-      filter_value: string;
+      filter_value: any;
     }[]
   > {
     const saveFilterMasterData = await this.savedFilterMasterRepo.findOne({
@@ -107,7 +107,12 @@ export class SavedFilterRepositoryService {
     return filterDetails.map((detail) => ({
       filter_attribute: detail.filter_attribute,
       filter_operator: detail.filter_operator,
-      filter_value: detail.filter_value,
+      filter_value:
+        detail.data_type === 'multiselect'
+          ? detail.filter_value?.trim() === ''
+            ? []
+            : detail.filter_value.split(',')
+          : detail.filter_value,
     }));
   }
 }

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

@@ -121,7 +121,7 @@ export class FilterService {
       {} as Record<string, any>,
     );
 
-    // Get and parse filters
+    // Get and parse saved filters
     const savedFilters = await this.getSavedFilters(savedFilterCode);
     const baseFilters = [
       ...(quickFilter || []).filter((f) => f.filter_value !== ''),
@@ -129,8 +129,10 @@ export class FilterService {
       ...(attributeFilter || []).filter((f) => f.filter_value !== ''),
     ];
 
+    // Build where clauses
     const baseWhere = this.buildWhereClauses(baseFilters, attributeMetaMap);
 
+    // check level_id and level_type
     if (level_type && level_id) {
       baseWhere.push({
         query: 'e.level_type = :level_type AND e.level_id = :level_id',
@@ -148,10 +150,11 @@ export class FilterService {
       });
     }
 
+    // layout preference query
     const layoutPreference = await this.dataSource.query(
       `SELECT layout_json
-   FROM cr_layout_preference
-   WHERE user_id = ? AND mapped_entity_type = ?`,
+      FROM cr_layout_preference
+      WHERE user_id = ? AND mapped_entity_type = ?`,
       [user_id, entity_type],
     );
 
@@ -191,13 +194,13 @@ export class FilterService {
 
       // Separate out 'all' tab before sorting
       const allTab = filteredTabs.find(
-        (tab) => tab.tab_value.toLowerCase() === 'all',
+        (tab) => tab.tab_value?.toLowerCase() === 'all',
       );
       filteredTabs = filteredTabs.filter(
-        (tab) => tab.tab_value.toLowerCase() !== 'all',
+        (tab) => tab.tab_value?.toLowerCase() !== 'all',
       );
 
-      // 🔽 SORTING LOGIC
+      // SORTING LOGIC
       if (layout.sorting === 'asc') {
         filteredTabs.sort((a, b) =>
           a.tab_value.toLowerCase().localeCompare(b.tab_value.toLowerCase()),
@@ -270,7 +273,8 @@ export class FilterService {
               {
                 filter_attribute: tabs.columnName,
                 filter_operator: 'not_equal',
-                filter_value: value,
+                filter_value: [value],
+                skip_id: true,
               },
               tabAttrMeta,
             );
@@ -285,7 +289,8 @@ export class FilterService {
           {
             filter_attribute: tabs.columnName,
             filter_operator: 'equal',
-            filter_value: tabs.value,
+            filter_value: [tabs.value],
+            skip_id: true,
           },
           tabAttrMeta,
         );
@@ -356,40 +361,31 @@ export class FilterService {
     // Get paginated data
     const entity_list = await qb.getRawMany();
 
-    // const formatDatesInRow = (row: any) => {
-    //   const formattedRow = { ...row };
-    //   for (const key of Object.keys(row)) {
-    //     if (key.endsWith('_date') && row[key]) {
-    //       formattedRow[key] = moment(row[key]).format('MMM DD, YYYY');
-    //     }
-    //   }
-    //   return formattedRow;
-    // };
-
     // 1. Extract all date-type attribute keys
-    // const dateAttributes = Object.entries(attributeMetaMap)
-    //   .filter(([_, attr]) => attr.data_type === 'date')
-    //   .map(([key]) => key); // only the keys (e.g., 'created_date', 'modified_date')
-
-    // // 2. Format function using moment
-    // const formatDate = (dateStr: string | null): string | null => {
-    //   if (!dateStr) return null;
-    //   return moment(dateStr).format('MMM DD, YYYY'); // e.g., "Jun 25, 2025"
-    // };
-
-    // // 3. Function to format only those keys in each entity row
-    // const formatDatesInRow = (row: any): any => {
-    //   const formattedRow = { ...row };
-    //   for (const key of dateAttributes) {
-    //     if (formattedRow[key]) {
-    //       formattedRow[key] = formatDate(formattedRow[key]);
-    //     }
-    //   }
-    //   return formattedRow;
-    // };
-
-    // // 4. Final transformation
-    // const formattedEntityList = entity_list.map(formatDatesInRow);
+    const dateAttributes = Object.entries(attributeMetaMap)
+      .filter(([_, attr]) => attr.data_type === 'date')
+      .map(([key]) => key);
+
+    // 2. Format function using moment
+    const formatDate = (dateStr: string | null): string | null => {
+      if (!dateStr) return '';
+      const date = moment(dateStr).format('DD-MM-YYYY'); // converted
+      return date;
+    };
+
+    // 3. Function to format only those keys in each entity row
+    const formatDatesInRow = (row: any): any => {
+      const formattedRow = { ...row };
+      for (const key of dateAttributes) {
+        if (formattedRow[key]) {
+          formattedRow[key] = formatDate(formattedRow[key]);
+        }
+      }
+      return formattedRow;
+    };
+
+    // 4. Final transformation
+    const formattedEntityList = entity_list.map(formatDatesInRow);
 
     // Count query (without pagination)
     const countQb = this.dataSource
@@ -406,7 +402,7 @@ export class FilterService {
       success: true,
       data: {
         entity_tabs: filteredTabs,
-        entity_list,
+        entity_list: formattedEntityList,
         pagination: {
           total,
           page,
@@ -466,7 +462,8 @@ export class FilterService {
     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`;
+    if (meta.data_source_type === 'entity' && !filter.skip_id)
+      attr = `${attr}_id`;
 
     switch (meta.data_type) {
       case 'text':
@@ -479,6 +476,10 @@ export class FilterService {
         return this.buildMultiSelectCondition(attr, op, val, key);
       case 'multiselect':
         return this.buildMultiSelectCondition(attr, op, val, key);
+      case 'checkbox':
+        return this.buildMultiSelectCondition(attr, op, val, key);
+      case 'radio':
+        return this.buildMultiSelectCondition(attr, op, val, key);
       case 'year':
         return this.buildYearCondition(attr, op, val, key);
       default:
@@ -533,6 +534,15 @@ export class FilterService {
         return { query: `e.${attr} > :${key}`, params: { [key]: val } };
       case 'less_than':
         return { query: `e.${attr} < :${key}`, params: { [key]: val } };
+      case 'less_than_qual_to':
+        return { query: `e.${attr} <= :${key}`, params: { [key]: val } };
+      case 'greater_than_qual_to':
+        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 number: ${op}`);
     }
@@ -561,6 +571,31 @@ export class FilterService {
           },
         };
       }
+
+      case 'today': {
+        const today = new Date().toISOString().split('T')[0]; // 'YYYY-MM-DD'
+
+        return {
+          query: `DATE(e.${attr}) = :today`,
+          params: {
+            today,
+          },
+        };
+      }
+
+      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 date: ${op}`);
     }
@@ -613,6 +648,16 @@ export class FilterService {
           query: `e.${attr} NOT IN (:${key})`,
           params: { [key]: val },
         };
+      case 'contains':
+        return {
+          query: `e.${attr} LIKE :${key}`,
+          params: { [key]: `%${val}%` },
+        };
+      case 'not_contains':
+        return {
+          query: `e.${attr} NOT LIKE :${key}`,
+          params: { [key]: `%${val}%` },
+        };
       case 'empty':
         return { query: `e.${attr} IS NULL`, params: {} };
       case 'not_empty':

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

@@ -32,6 +32,7 @@ export class SavedFilterService extends EntityServiceImpl {
     }
 
     entityData.user_id = loggedInUser?.id ?? null;
+
     // Save the master record without code
     const savedMaster = await super.createEntity(master, loggedInUser);
 
@@ -45,10 +46,22 @@ export class SavedFilterService extends EntityServiceImpl {
     // 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,
-      }));
+      const prepared = details.map((detail: any) => {
+        // If detail.filter_value is an array, join it with comma
+        if (Array.isArray(detail.filter_value)) {
+          return {
+            ...detail,
+            mapped_filter_code: savedMaster.code,
+            filter_value: detail.filter_value.join(','),
+            data_type: 'multiselect',
+          };
+        }
+        // Otherwise, just add mapped_filter_code
+        return {
+          ...detail,
+          mapped_filter_code: savedMaster.code,
+        };
+      });
 
       await this.savedFilterRepo.saveDetails(prepared);
     }
@@ -98,11 +111,35 @@ export class SavedFilterService extends EntityServiceImpl {
     return updated;
   }
 
+  async deleteEntity(entityType: string, entityId: number) {
+    const entityMaster =
+      await this.entityMasterService.getEntityData(entityType);
+
+    const repoService = this.reflectionHelper.getRepoService(
+      entityMaster.entity_data_class,
+    );
+    if (!repoService) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityType}`,
+      );
+    }
+
+    const entityData = await repoService.findOne({ where: { id: entityId } });
+
+    if (!entityData) {
+      throw new Error(`Entity not found for entityType: ${entityType}`);
+    }
+
+    await this.savedFilterRepo.deleteDetailsByCode(entityData.code);
+
+    await repoService.delete(entityId);
+  }
+
   async getDetailsByCode(code: string): Promise<SavedFilterDetail[]> {
     return this.savedFilterRepo.getDetailsByCode(code);
   }
 
   async getFilterById(id: number) {
-    return this.savedFilterRepo.getFilterById(id);
+    return await this.savedFilterRepo.getFilterById(id);
   }
 }

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

@@ -144,6 +144,47 @@ export class EntityController {
     };
   }
 
+  @Post('delete/:id')
+  @HttpCode(200)
+  async delete(
+    @Param('id') id: number,
+    @Query('entity_type') entityType: string,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+
+    if (!entityType) {
+      throw new BadRequestException(
+        'Query parameter "entity_type" is required',
+      );
+    }
+
+    const entityMaster =
+      await this.entityMasterService.getEntityData(entityType);
+
+    const entityService =
+      await this.reflectionHelper.getBean<EntityServiceImpl>(
+        entityMaster.entity_service,
+      );
+
+    if (!entityService) {
+      throw new InternalServerErrorException(
+        `No service found for entity_type "${entityType}"`,
+      );
+    }
+
+    const existingEntity = await entityService.getEntityData(entityType, id);
+    if (!existingEntity) {
+      throw new NotFoundException(`No entity found for id "${id}"`);
+    }
+
+    await entityService.deleteEntity(entityType, id);
+
+    return {
+      success: true,
+    };
+  }
+
   @Post('getFilteredDataWithTabs/:entity_type')
   async getFilterDataWithTabs(
     @Param('entity_type') entityType: string,

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

@@ -94,11 +94,27 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
     return repo.save(entityData);
   }
 
-  deleteEntity(
-    entityType: string,
-    entityId: number,
-    loggedInUserData: UserData,
-  ) {}
+  async deleteEntity(entityType: string, entityId: number) {
+    const entityMaster =
+      await this.entityMasterService.getEntityData(entityType);
+
+    const repoService = this.reflectionHelper.getRepoService(
+      entityMaster.entity_data_class,
+    );
+    if (!repoService) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityType}`,
+      );
+    }
+
+    const entityData = await repoService.findOne({ where: { id: entityId } });
+
+    if (!entityData) {
+      throw new Error(`Entity not found for entityType: ${entityType}`);
+    }
+
+    await repoService.delete(entityId);
+  }
 
   async findByCode(entityType: string, code: string): Promise<BaseEntity> {
     const entityData = await this.entityMasterService.getEntityData(entityType);