rez_core 2.1.48 → 2.1.49

package/package.json

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

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 | string[];
+      filter_value: any;
     }[]
   > {
     const saveFilterMasterData = await this.savedFilterMasterRepo.findOne({
@@ -112,9 +112,7 @@ export class SavedFilterRepositoryService {
           ? detail.filter_value?.trim() === ''
             ? []
             : detail.filter_value.split(',')
-          : detail.filter_value?.trim() === ''
-            ? []
-            : detail.filter_value,
+          : detail.filter_value,
     }));
   }
 }

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

@@ -194,10 +194,10 @@ 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
@@ -273,7 +273,8 @@ export class FilterService {
               {
                 filter_attribute: tabs.columnName,
                 filter_operator: 'not_equal',
-                filter_value: value,
+                filter_value: [value],
+                skip_id: true,
               },
               tabAttrMeta,
             );
@@ -288,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,
         );
@@ -359,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
@@ -409,7 +402,7 @@ export class FilterService {
       success: true,
       data: {
         entity_tabs: filteredTabs,
-        entity_list,
+        entity_list: formattedEntityList,
         pagination: {
           total,
           page,
@@ -469,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':
@@ -482,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:
@@ -536,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}`);
     }
@@ -564,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}`);
     }
@@ -616,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

@@ -6,7 +6,6 @@ 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';
-import { isArray } from 'class-validator';
 
 @Injectable()
 export class SavedFilterService extends EntityServiceImpl {
@@ -112,6 +111,30 @@ 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);
   }

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);