rez_core 4.0.290 → 4.0.292

package/package.json

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

package/src/module/entity_json/entity_json.module.ts

@@ -6,11 +6,12 @@ import { EntityJSONController } from './controller/entity_json.controller';
 import { FilterModule } from '../filter/filter.module';
 import { UtilsModule } from 'src/utils/utils.module';
 import { EntityJson } from './entity/entityJson.entity';
+import { EntityJSONRepository } from './service/entityJson.repository';
 
 @Module({
   imports: [EntityModule, TypeOrmModule.forFeature([EntityJson]),FilterModule,UtilsModule],
   controllers: [EntityJSONController],
-  providers: [EntityJSONService],
+  providers: [EntityJSONService,EntityJSONRepository],
   exports: [],
 })
 export class EntityJSONModule {}

package/src/module/entity_json/service/entityJson.repository.ts

@@ -0,0 +1,37 @@
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { Repository } from "typeorm";
+import { EntityJson } from "../entity/entityJson.entity";
+import { create } from "domain";
+
+
+@Injectable()
+export class EntityJSONRepository {
+  constructor(
+    @InjectRepository(EntityJson)
+    private readonly entityJSONRepository: Repository<EntityJson>,
+  ) {}
+
+  async create(flatJson: Partial<EntityJson>) {
+    const { entity_type, entity_id } = flatJson;
+
+    // Step 1 — check if exists by unique keys
+    const existing = await this.entityJSONRepository.findOne({
+      where: { entity_type, entity_id },
+    });
+
+    if (existing) {
+      // Step 2 — normal update (no merge)
+      await this.entityJSONRepository.update(existing.id, flatJson);
+
+      // Optionally return updated row (common practice)
+      return this.entityJSONRepository.findOne({
+        where: { id: existing.id },
+      });
+    }
+
+    // Step 3 — insert new
+    const created = this.entityJSONRepository.create(flatJson);
+    return this.entityJSONRepository.save(created);
+  }
+}

package/src/module/entity_json/service/entity_json.service.ts

@@ -6,13 +6,15 @@ import { EntityRelation } from 'src/module/meta/entity/entity-relation.entity';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { LoggingService } from 'src/utils/service/loggingUtil.service';
 import { DataSource } from 'typeorm';
+import { EntityJSONRepository } from './entityJson.repository';
 
 @Injectable()
 export class EntityJSONService extends EntityServiceImpl {
   constructor(
     private readonly dataSource: DataSource,
     private readonly filterService: FilterService,
-    private readonly loggerService: LoggingService, // <-- inject logging service
+    private readonly loggerService: LoggingService,
+    private readonly EntityJSONRepository:EntityJSONRepository
   ) {
     super();
   }
@@ -23,27 +25,18 @@ export class EntityJSONService extends EntityServiceImpl {
     flag?: 'flat_json' | 'dropdown' | 'all',
   ) {
     const orgId = loggedInUser.organization_id;
-    await this.loggerService.log(
-      'info',
-      'EntityJSONService',
-      'getAttributeForFlatJSON',
-      `Loading attributes for entity: ${entityType}, org: ${orgId}`,
-    );
+
+    await this.loggerService.log('info', 'EntityJSONService', 'getAttributeForFlatJSON', `Loading attributes for entity: ${entityType}, org: ${orgId}`);
 
     const mainAttributes = await this.dataSource
       .getRepository(AttributeMaster)
       .createQueryBuilder('attr')
-      .select(['attr.id', 'attr.name', 'attr.flat_json_key','attr.attribute_key'])
+      .select(['attr.id', 'attr.name', 'attr.flat_json_key', 'attr.attribute_key'])
       .where('attr.mapped_entity_type = :entityType', { entityType })
       .andWhere('attr.organization_id = :orgId', { orgId })
       .getMany();
 
-    await this.loggerService.log(
-      'debug',
-      'EntityJSONService',
-      'getAttributeForFlatJSON',
-      `Loaded ${mainAttributes.length} main attributes`,
-    );
+    await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Loaded ${mainAttributes.length} main attributes`);
 
     const relatedEntityTypes = await this.dataSource
       .getRepository(EntityRelation)
@@ -51,44 +44,24 @@ export class EntityJSONService extends EntityServiceImpl {
       .select(['rel.target_entity_type'])
       .where('rel.source_entity_type = :entityType', { entityType })
       .andWhere('rel.organization_id = :orgId', { orgId })
-      .andWhere('rel.relation_type = :relationType', {
-        relationType: 'ONE_TO_ONE',
-      })
+      .andWhere('rel.relation_type = :relationType', { relationType: 'ONE_TO_ONE' })
       .getRawMany();
 
-    const relatedTypesList = relatedEntityTypes.map(
-      (x) => x.rel_target_entity_type,
-    );
-    await this.loggerService.log(
-      'debug',
-      'EntityJSONService',
-      'getAttributeForFlatJSON',
-      `Found ${relatedTypesList.length} ONE-TO-ONE related entity types`,
-    );
+    const relatedTypesList = relatedEntityTypes.map(x => x.rel_target_entity_type);
+
+    await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Found ${relatedTypesList.length} ONE-TO-ONE related entity types`);
 
     const relatedAttributes = relatedTypesList.length
       ? await this.dataSource
           .getRepository(AttributeMaster)
           .createQueryBuilder('attr')
-          .select([
-            'attr.id',
-            'attr.name',
-            'attr.flat_json_key',
-            'attr.mapped_entity_type',
-            'attr.attribute_key',
-          ])
-          .where('attr.mapped_entity_type IN (:...types)', {
-            types: relatedTypesList,
-          })
+          .select(['attr.id', 'attr.name', 'attr.flat_json_key', 'attr.mapped_entity_type', 'attr.attribute_key'])
+          .where('attr.mapped_entity_type IN (:...types)', { types: relatedTypesList })
           .andWhere('attr.organization_id = :orgId', { orgId })
           .getMany()
       : [];
-    await this.loggerService.log(
-      'debug',
-      'EntityJSONService',
-      'getAttributeForFlatJSON',
-      `Loaded ${relatedAttributes.length} related attributes`,
-    );
+
+    await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Loaded ${relatedAttributes.length} related attributes`);
 
     const linkedAttributes = await this.dataSource
       .getRepository(LinkedAttributes)
@@ -99,103 +72,67 @@ export class EntityJSONService extends EntityServiceImpl {
         'fla.applicable_entity_type = attr.mapped_entity_type AND fla.applicable_attribute_key = attr.attribute_key',
       )
       .select([
-        'fla.applicable_entity_type',
-        'attr.id',
-        'attr.name',
-        'attr.attribute_key',
+        'fla.applicable_entity_type AS applicable_entity_type',
+        'fla.applicable_attribute_key AS applicable_attribute_key',
+        'fla.attribute_key AS target_attribute_key',
+        'fla.saved_filter_code AS saved_filter_code',
+        'attr.name AS name',
+        'attr.id AS id',
       ])
       .where('attr.organization_id = :orgId', { orgId })
       .getRawMany();
-    await this.loggerService.log(
-      'debug',
-      'EntityJSONService',
-      'getAttributeForFlatJSON',
-      `Loaded ${linkedAttributes.length} linked attributes`,
-    );
+
+    await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Loaded ${linkedAttributes.length} linked attributes`);
 
     if (flag === 'flat_json' || flag === 'all') {
       const result: Record<string, null> = {};
-      mainAttributes.forEach((attr) => {
-        if (attr.flat_json_key) result[attr.flat_json_key] = null;
-      });
-      relatedAttributes.forEach((attr) => {
-        if (attr.flat_json_key) result[attr.flat_json_key] = null;
-      });
-      linkedAttributes.forEach((link) => {
-        if (link.applicable_attribute_key)
-          result[link.applicable_attribute_key] = null;
-      });
-      if(flag === 'all')
-        return {flat_json: result,attributes: {mainAttributes,relatedAttributes,linkedAttributes}};
-
-        return result;
+      mainAttributes.forEach(attr => { if (attr.flat_json_key) result[attr.flat_json_key] = null; });
+      relatedAttributes.forEach(attr => { if (attr.flat_json_key) result[attr.flat_json_key] = null; });
+      linkedAttributes.forEach(link => { if (link.target_attribute_key) result[link.target_attribute_key] = null; });
+
+      if (flag === 'all') {
+        return { flat_json: result, attributes: { mainAttributes, relatedAttributes, linkedAttributes } };
+      }
+
+      return result;
     }
 
     const dropdown: any[] = [];
-    dropdown.push(
-      ...mainAttributes.map((a) => ({ label: a.name, value: a.flat_json_key })),
-    );
-    dropdown.push(
-      ...relatedAttributes.map((a) => ({
-        label: a.name,
-        value: a.flat_json_key,
-      })),
-    );
+    dropdown.push(...mainAttributes.map(a => ({ label: a.name, value: a.flat_json_key })));
+    dropdown.push(...relatedAttributes.map(a => ({ label: a.name, value: a.flat_json_key })));
     if (linkedAttributes.length > 0) {
-      dropdown.push({
-        ...linkedAttributes.map((a) => ({
-          label: a.name,
-          value: a.attribute_key,
-        })),
-      });
+      dropdown.push(...linkedAttributes.map(a => ({ label: a.name, value: a.attribute_key })));
     }
+
     return dropdown;
   }
 
   async updateEntityJSON(entityType: string, entityId: number, loggedInUser) {
-    await this.loggerService.log(
-      'info',
-      'EntityJSONService',
-      'updateEntityJSON',
-      `Building flat JSON for entity: ${entityType}#${entityId}`,
-    );
-  
-    // 1. Load flat JSON template + attributes
+    await this.loggerService.log('info', 'EntityJSONService', 'updateEntityJSON', `Building flat JSON for entity: ${entityType}#${entityId}`);
+
     const response = await this.getAttributeForFlatJSON(entityType, loggedInUser, 'all');
-  
-    // ---- Structural validation ----
+
     if (!response || !('flat_json' in response) || !('attributes' in response) || !response.attributes) {
-      await this.loggerService.log(
-        'error',
-        'EntityJSONService',
-        'updateEntityJSON',
-        `getAttributeForFlatJSON() did not return expected structure`,
-      );
+      await this.loggerService.log('error', 'EntityJSONService', 'updateEntityJSON', `getAttributeForFlatJSON() did not return expected structure`);
       return null;
     }
-  
+
     const { flat_json: flatJson, attributes } = response;
     if (!flatJson) return null;
-  
-    // ---- Strong safety fix ----
+
     const safeAttributes = {
       mainAttributes: attributes.mainAttributes || [],
       relatedAttributes: attributes.relatedAttributes || [],
       linkedAttributes: attributes.linkedAttributes || [],
     };
-  
-    // 2. Build attribute_key → flat_json_key map
+
     const attrMap: Record<string, string> = {};
     const allAttrs = [...safeAttributes.mainAttributes, ...safeAttributes.relatedAttributes];
-    allAttrs.forEach(attr => {
-      if (attr.attribute_key) attrMap[attr.attribute_key] = attr.flat_json_key || attr.attribute_key;
-    });
-  
-    // 3. Merge main entity data
+    allAttrs.forEach(attr => { if (attr.attribute_key) attrMap[attr.attribute_key] = attr.flat_json_key || attr.attribute_key; });
+
     const mainData = await this.getResolvedEntityData(entityType, entityId, loggedInUser);
     this.mergeEntityDataIntoFlatJson(flatJson, mainData, attrMap);
-  
-    // 4. Merge ONE-TO-ONE related entities
+
     const relations = await this.dataSource
       .getRepository('frm_entity_relation_data')
       .createQueryBuilder('erd')
@@ -204,67 +141,62 @@ export class EntityJSONService extends EntityServiceImpl {
       .andWhere('erd.source_entity_id = :entityId', { entityId })
       .andWhere('erd.relation_type = :rt', { rt: 'ONE_TO_ONE' })
       .getRawMany();
-  
+
     for (const rel of relations) {
       const relatedData = await this.getResolvedEntityData(rel.target_entity_type, rel.target_entity_id, loggedInUser);
       this.mergeEntityDataIntoFlatJson(flatJson, relatedData, attrMap);
     }
-  
-    // 5. Merge linked attributes using saved filters
+
     for (const linkAttr of safeAttributes.linkedAttributes) {
-      if (!linkAttr.applicable_entity_type || !linkAttr.applicable_attribute_key) continue;
-  
-      const mappingValue = mainData?.[linkAttr.parent_attribute_key || ''] ?? null;
+      const childEntityType = linkAttr.applicable_entity_type;
+      const sourceKey = linkAttr.applicable_attribute_key;
+      const targetKey = linkAttr.target_attribute_key;
+
+      if (!childEntityType || !sourceKey || !targetKey) continue;
+
+      const mappingValue = mainData?.[sourceKey] ?? null;
+
       const value = await this.applyLinkedFilterUsingSavedFilter(
-        linkAttr.applicable_entity_type,
+        childEntityType,
         linkAttr.saved_filter_code,
-        linkAttr.applicable_attribute_key,
+        sourceKey,
         mappingValue,
-        linkAttr.target_attribute_key || linkAttr.applicable_attribute_key,
+        targetKey,
         loggedInUser,
         entityId,
       );
-  
+
       if (value !== null && value !== undefined) {
-        const flatKey = attrMap[linkAttr.target_attribute_key || linkAttr.applicable_attribute_key]
-          || (linkAttr.target_attribute_key || linkAttr.applicable_attribute_key);
-        flatJson[flatKey] = value;
+        flatJson[targetKey] = value;
       }
     }
-  
-    // 6. Save JSON
-    await this.dataSource.query(
-      `INSERT INTO frm_entity_json (entity_type, entity_id, json_data, created_by)
-         VALUES (?, ?, ?, ?)
-         ON DUPLICATE KEY UPDATE json_data = VALUES(json_data), updated_by = VALUES(created_by)`,
-      [entityType, entityId, JSON.stringify(flatJson), loggedInUser.id],
-    );
-  
+
+    await this.loggerService.log('info', 'EntityJSONService', 'updateEntityJSON', `Saving flat JSON for entity: ${entityType}#${entityId}`);
+    let JsonData = {
+      entity_type: entityType,
+      entity_id: entityId,
+      json_data: flatJson,
+      created_by: loggedInUser.id,
+    }
+    
+    await this.EntityJSONRepository.create(JsonData);
+
     return flatJson;
   }
-  
-  
-  // Helper: Merge entity data using attribute_key → flat_json_key mapping
-  private mergeEntityDataIntoFlatJson(
-    flatJson: Record<string, any>,
-    entityData: any | any[], // accept both object or array
-    attrMap: Record<string, string>,
-  ) {
+
+  private mergeEntityDataIntoFlatJson(flatJson: Record<string, any>, entityData: any | any[], attrMap: Record<string, string>) {
     const records = Array.isArray(entityData) ? entityData : [entityData];
-  
+
     for (const record of records) {
       if (!record || typeof record !== 'object') continue;
-  
       for (const key of Object.keys(record)) {
-        const flatKey = attrMap[key] || key; // map to flat_json_key if exists
+        const flatKey = attrMap[key] || key;
         if (flatJson.hasOwnProperty(flatKey)) {
           flatJson[flatKey] = record[key];
         }
       }
     }
   }
-  
-  
 
   private async applyLinkedFilterUsingSavedFilter(
     childEntityType: string,
@@ -275,11 +207,7 @@ export class EntityJSONService extends EntityServiceImpl {
     loggedInUser,
     entity_id
   ) {
-    if (
-      !savedFilterCode &&
-      (mappingValue === null || mappingValue === undefined)
-    )
-      return null;
+    if (!savedFilterCode && (mappingValue === null || mappingValue === undefined)) return null;
 
     const dto: any = {
       entity_type: childEntityType,
@@ -289,30 +217,18 @@ export class EntityJSONService extends EntityServiceImpl {
       size: 1,
     };
 
-    if (
-      mappingValue !== null &&
-      mappingValue !== undefined &&
-      mappingValue !== ''
-    ) {
+    if (mappingValue !== null && mappingValue !== undefined && mappingValue !== '') {
       dto.quickFilter = [
-        {
-          filter_attribute: childFilterAttribute,
-          filter_operator: 'equal',
-          filter_value: mappingValue,
-        },
+        { filter_attribute: childFilterAttribute, filter_operator: 'equal', filter_value: mappingValue },
       ];
     }
 
     dto.quickFilter = [
-      {
-        filter_attribute: 'parent_id',
-        filter_operator: 'equal',
-        filter_value: entity_id,
-      },
+      { filter_attribute: 'parent_id', filter_operator: 'equal', filter_value: [entity_id] },
     ];
 
     const result = await this.filterService.applyFilter(dto);
     const rows = result?.data?.entity_list || [];
-    return rows.length ? (rows[0][targetAttribute] ?? null) : null;
+    return rows.length ? (rows[0][childFilterAttribute] ?? null) : null;
   }
 }

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

@@ -849,7 +849,9 @@ export class FilterService {
 
   private buildDateCondition(attr: string, op: string, val: any, key: string) {
     const dateColumn = `DATE(e.${attr})`;
-    const monthColumn = `DATE_TRUNC('month', e.${attr})`;
+    const monthColumn = `DATE_FORMAT(e.${attr}, '%Y-%m-01')`; // MySQL equivalent
+
+    const numVal = Number(val);
 
     switch (op) {
       // ===== BASIC COMPARISONS =====
@@ -888,17 +890,64 @@ export class FilterService {
 
       // ===== MONTH COMPARISONS =====
       case 'is_month_before':
+        if (!isNaN(numVal)) {
+          const target = moment()
+            .subtract(numVal, 'months')
+            .startOf('month')
+            .format('YYYY-MM-DD');
+          return {
+            query: `${monthColumn} < DATE_FORMAT(:${key}, '%Y-%m-01')`,
+            params: { [key]: target },
+          };
+        }
         return {
-          query: `${monthColumn} < DATE_TRUNC('month', :${key})`,
+          query: `${monthColumn} < DATE_FORMAT(:${key}, '%Y-%m-01')`,
           params: { [key]: val },
         };
 
       case 'is_month_after':
+        if (!isNaN(numVal)) {
+          const target = moment()
+            .add(numVal, 'months')
+            .startOf('month')
+            .format('YYYY-MM-DD');
+          return {
+            query: `${monthColumn} > DATE_FORMAT(:${key}, '%Y-%m-01')`,
+            params: { [key]: target },
+          };
+        }
         return {
-          query: `${monthColumn} > DATE_TRUNC('month', :${key})`,
+          query: `${monthColumn} > DATE_FORMAT(:${key}, '%Y-%m-01')`,
           params: { [key]: val },
         };
 
+      // ===== DAY BEFORE / AFTER =====
+      case 'is_day_before':
+        if (isNaN(numVal))
+          throw new BadRequestException(
+            'Value must be a number for is_day_before',
+          );
+
+        const beforeDate = moment()
+          .subtract(numVal, 'days')
+          .format('YYYY-MM-DD');
+        return {
+          query: `${dateColumn} < :${key}`,
+          params: { [key]: beforeDate },
+        };
+
+      case 'is_day_after':
+        if (isNaN(numVal))
+          throw new BadRequestException(
+            'Value must be a number for is_day_after',
+          );
+
+        const afterDate = moment().add(numVal, 'days').format('YYYY-MM-DD');
+        return {
+          query: `${dateColumn} > :${key}`,
+          params: { [key]: afterDate },
+        };
+
       // ===== BETWEEN =====
       case 'between': {
         if (typeof val === 'string') {
@@ -924,17 +973,18 @@ export class FilterService {
         };
       }
 
-      // ===== TODAY KEYWORD =====
+      // ===== TODAY =====
       case 'today': {
-        const today = new Date().toISOString().split('T')[0];
+        const today = moment().format('YYYY-MM-DD');
         return {
           query: `${dateColumn} = :today`,
           params: { today },
         };
       }
 
-      // ===== EMPTY / NOT EMPTY =====
+      // ===== EMPTY =====
       case 'empty':
+      case 'is_empty':
         return {
           query: `e.${attr} IS NULL`,
           params: {},
@@ -946,7 +996,6 @@ export class FilterService {
           params: {},
         };
 
-      // ===== UNSUPPORTED =====
       default:
         throw new BadRequestException(`Unsupported operator for date: ${op}`);
     }