rez_core 5.0.28 → 5.0.30

package/package.json

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

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

@@ -29,19 +29,19 @@ export class EntityJSONController {
     );
   }
 
-  // @Post('/update-json/:entityId')
-  // @UseGuards(JwtAuthGuard)
-  // async updateEntityJson(
-  //   @Param('entityId') entityId: string,
-  //   @Query('entityType') entityType: string,
-  //   @Req() req: Request & { user: any },
-  // ) {
-  //   const loggedInUser = req.user?.userData;
+  @Post('/update-json/:entityId')
+  @UseGuards(JwtAuthGuard)
+  async updateEntityJson(
+    @Param('entityId') entityId: string,
+    @Query('entityType') entityType: string,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user?.userData;
 
-  //   return this.entityJSONService.updateEntityJSON(
-  //     entityType,
-  //     Number(entityId),
-  //     loggedInUser,
-  //   );
-  // }
+    return this.entityJSONService.updateEntityJSON(
+      entityType,
+      Number(entityId),
+      loggedInUser,
+    );
+  }
 }

package/src/module/entity_json/entity/entityJson.entity.ts

@@ -0,0 +1,39 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+  UpdateDateColumn,
+  Unique,
+  Index,
+} from 'typeorm';
+
+@Entity('frm_entity_json')
+@Unique(['entity_type', 'entity_id'])
+export class EntityJson {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Index()
+  @Column({ type: 'varchar', length: 100 })
+  entity_type: string;
+
+  @Index()
+  @Column({ type: 'int' })
+  entity_id: number;
+
+  @Column({ type: 'json', nullable: false })
+  json_data: Record<string, any>;
+
+  @Column({ type: 'int', nullable: true })
+  created_by: number;
+
+  @Column({ type: 'int', nullable: true })
+  updated_by: number;
+
+  @CreateDateColumn({ type: 'timestamp', nullable: true })
+  created_at: Date;
+
+  @UpdateDateColumn({ type: 'timestamp', nullable: true })
+  updated_at: Date;
+}

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

@@ -5,11 +5,14 @@ import { EntityJSONService } from './service/entity_json.service';
 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([]),FilterModule,UtilsModule],
+  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

@@ -1,17 +1,20 @@
 import { Injectable } from '@nestjs/common';
 import { FilterService } from 'src/module/filter/service/filter.service';
+import { LinkedAttributes } from 'src/module/linked_attributes/entity/linked_attribute.entity';
 import { AttributeMaster } from 'src/module/meta/entity/attribute-master.entity';
 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();
   }
@@ -19,30 +22,21 @@ export class EntityJSONService extends EntityServiceImpl {
   async getAttributeForFlatJSON(
     entityType: string,
     loggedInUser: any,
-    flag?: 'flat_json' | 'dropdown',
+    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.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)
@@ -54,31 +48,23 @@ export class EntityJSONService extends EntityServiceImpl {
       .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`,
-    );
+
+    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.attribute_key', 'attr.mapped_entity_type'])
+          .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('frm_linked_attribute')
+      .getRepository(LinkedAttributes)
       .createQueryBuilder('fla')
       .innerJoin(
         AttributeMaster,
@@ -86,68 +72,66 @@ 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`,
-    );
-
-    if (flag === 'flat_json') {
+
+    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.attribute_key) result[attr.attribute_key] = null; });
-      relatedAttributes.forEach(attr => { if (attr.attribute_key) result[attr.attribute_key] = null; });
-      linkedAttributes.forEach(link => { if (link.applicable_attribute_key) result[link.applicable_attribute_key] = 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.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.attribute_key })));
-    dropdown.push(...relatedAttributes.map(a => ({ label: a.name, value: a.attribute_key })));
-    dropdown.push({
-      linked_attributes: linkedAttributes.map(a => ({ label: a.attr_name, value: a.attr_attribute_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 })));
+    }
+
     return dropdown;
   }
 
-  async updateEntityJSON(
-    entityType: string,
-    entityId: number,
-    loggedInUser,
-  ) {
-    await this.loggerService.log(
-      'info',
-      'EntityJSONService',
-      'updateEntityJSON',
-      `Building flat JSON for entity: ${entityType}#${entityId}`,
-    );
-
-    const flatJson = await this.getAttributeForFlatJSON(entityType, loggedInUser, 'flat_json');
-    if (!flatJson) {
-      await this.loggerService.log(
-        'error',
-        'EntityJSONService',
-        'updateEntityJSON',
-        `Flat JSON template not found for entity: ${entityType}`,
-      );
-      throw new Error(`Flat JSON template not found for ${entityType}`);
+  async updateEntityJSON(entityType: string, entityId: number, loggedInUser) {
+    await this.loggerService.log('info', 'EntityJSONService', 'updateEntityJSON', `Building flat JSON for entity: ${entityType}#${entityId}`);
+
+    const response = await this.getAttributeForFlatJSON(entityType, loggedInUser, 'all');
+
+    if (!response || !('flat_json' in response) || !('attributes' in response) || !response.attributes) {
+      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;
+
+    const safeAttributes = {
+      mainAttributes: attributes.mainAttributes || [],
+      relatedAttributes: attributes.relatedAttributes || [],
+      linkedAttributes: attributes.linkedAttributes || [],
+    };
+
+    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; });
+
     const mainData = await this.getResolvedEntityData(entityType, entityId, loggedInUser);
-    this.mergeIntoFlatJson(flatJson, mainData);
-    await this.loggerService.log(
-      'debug',
-      'EntityJSONService',
-      'updateEntityJSON',
-      'Merged main entity data into flat JSON',
-    );
+    this.mergeEntityDataIntoFlatJson(flatJson, mainData, attrMap);
 
     const relations = await this.dataSource
       .getRepository('frm_entity_relation_data')
@@ -157,75 +141,59 @@ export class EntityJSONService extends EntityServiceImpl {
       .andWhere('erd.source_entity_id = :entityId', { entityId })
       .andWhere('erd.relation_type = :rt', { rt: 'ONE_TO_ONE' })
       .getRawMany();
-    await this.loggerService.log(
-      'debug',
-      'EntityJSONService',
-      'updateEntityJSON',
-      `Found ${relations.length} ONE-TO-ONE relations`,
-    );
 
     for (const rel of relations) {
-      const related = await this.getResolvedEntityData(rel.target_entity_type, rel.target_entity_id, loggedInUser);
-      this.mergeIntoFlatJson(flatJson, related);
-      await this.loggerService.log(
-        'debug',
-        'EntityJSONService',
-        'updateEntityJSON',
-        `Merged related entity ${rel.target_entity_type}#${rel.target_entity_id}`,
-      );
+      const relatedData = await this.getResolvedEntityData(rel.target_entity_type, rel.target_entity_id, loggedInUser);
+      this.mergeEntityDataIntoFlatJson(flatJson, relatedData, attrMap);
     }
 
-    const linkedAttrs = await this.dataSource
-      .getRepository('frm_linked_attributes_table')
-      .createQueryBuilder('la')
-      .where('la.entity_type = :entityType', { entityType })
-      .getMany();
-    await this.loggerService.log(
-      'debug',
-      'EntityJSONService',
-      'updateEntityJSON',
-      `Found ${linkedAttrs.length} linked attributes`,
-    );
-
-    for (const la of linkedAttrs) {
-      const mappingValue = flatJson[la.mapping_attribute];
-      const result = await this.applyLinkedFilterUsingSavedFilter(
-        la.child_entity_type,
-        la.saved_filter_code,
-        la.filter_attribute,
+    for (const linkAttr of safeAttributes.linkedAttributes) {
+      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(
+        childEntityType,
+        linkAttr.saved_filter_code,
+        sourceKey,
         mappingValue,
-        la.target_attribute,
-        loggedInUser
-      );
-      flatJson[la.target_attribute] = result;
-      await this.loggerService.log(
-        'debug',
-        'EntityJSONService',
-        'updateEntityJSON',
-        `Linked attribute ${la.target_attribute} set from child entity ${la.child_entity_type}`,
+        targetKey,
+        loggedInUser,
+        entityId,
       );
+
+      if (value !== null && value !== undefined) {
+        flatJson[targetKey] = value;
+      }
     }
 
-    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',
-      `Flat JSON saved for entity: ${entityType}#${entityId}`,
-    );
+    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;
   }
 
-  private mergeIntoFlatJson(flatJson, entityData) {
-    for (const key of Object.keys(entityData)) {
-      if (flatJson.hasOwnProperty(key)) {
-        flatJson[key] = entityData[key];
+  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;
+        if (flatJson.hasOwnProperty(flatKey)) {
+          flatJson[flatKey] = record[key];
+        }
       }
     }
   }
@@ -237,6 +205,7 @@ export class EntityJSONService extends EntityServiceImpl {
     mappingValue: any,
     targetAttribute: string,
     loggedInUser,
+    entity_id
   ) {
     if (!savedFilterCode && (mappingValue === null || mappingValue === undefined)) return null;
 
@@ -250,16 +219,16 @@ export class EntityJSONService extends EntityServiceImpl {
 
     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] },
+    ];
+
     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

@@ -885,13 +885,107 @@ export class FilterService {
   }
 
   private buildDateCondition(attr: string, op: string, val: any, key: string) {
+    const dateColumn = `DATE(e.${attr})`;
+    const monthColumn = `DATE_FORMAT(e.${attr}, '%Y-%m-01')`; // MySQL equivalent
+
+    const numVal = Number(val);
+
     switch (op) {
+      // ===== BASIC COMPARISONS =====
       case 'equal':
-        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
+      case 'is':
+        return {
+          query: `${dateColumn} = :${key}`,
+          params: { [key]: val },
+        };
+
       case 'before':
-        return { query: `e.${attr} < :${key}`, params: { [key]: val } };
+      case 'is_before':
+        return {
+          query: `${dateColumn} < :${key}`,
+          params: { [key]: val },
+        };
+
       case 'after':
-        return { query: `e.${attr} > :${key}`, params: { [key]: val } };
+      case 'is_after':
+        return {
+          query: `${dateColumn} > :${key}`,
+          params: { [key]: val },
+        };
+
+      case 'is_on_or_before':
+        return {
+          query: `${dateColumn} <= :${key}`,
+          params: { [key]: val },
+        };
+
+      case 'is_on_or_after':
+        return {
+          query: `${dateColumn} >= :${key}`,
+          params: { [key]: val },
+        };
+
+      // ===== 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_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_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') {
           val = val.split(',').map((v) => v.trim());
@@ -903,12 +997,12 @@ export class FilterService {
           val[0] === '' ||
           val[1] === ''
         ) {
-          // throw new BadRequestException(`Invalid value for in_between: ${val}`);
-          console.log(`Invalid value for in_between: ${val}`);
+          console.log(`Invalid value for between: ${val}`);
           return null;
         }
+
         return {
-          query: `e.${attr} BETWEEN :${key}_start AND :${key}_end`,
+          query: `${dateColumn} BETWEEN :${key}_start AND :${key}_end`,
           params: {
             [`${key}_start`]: val[0],
             [`${key}_end`]: val[1],
@@ -916,30 +1010,29 @@ export class FilterService {
         };
       }
 
+      // ===== TODAY =====
       case 'today': {
-        const today = new Date().toISOString().split('T')[0]; // 'YYYY-MM-DD'
-
+        const today = moment().format('YYYY-MM-DD');
         return {
-          query: `DATE(e.${attr}) = :today`,
-          params: {
-            today,
-          },
+          query: `${dateColumn} = :today`,
+          params: { today },
         };
       }
 
-      case 'empty': {
+      // ===== EMPTY =====
+      case 'empty':
+      case 'is_empty':
         return {
           query: `e.${attr} IS NULL`,
           params: {},
         };
-      }
 
-      case 'not_empty': {
+      case 'not_empty':
         return {
           query: `e.${attr} IS NOT NULL`,
           params: {},
         };
-      }
+
       default:
         throw new BadRequestException(`Unsupported operator for date: ${op}`);
     }