rez_core 4.0.98 → 4.0.99

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

@@ -1,809 +1,819 @@
-import { level } from 'winston';
-import { Injectable } from '@nestjs/common';
-import {
-  ENTITYTYPE_ENTITYMASTER,
-  STATUS_ACTIVE,
-} from 'src/constant/global.constant';
-import { DataSource } from 'typeorm';
-import { UserData } from 'src/module/user/entity/user.entity';
-import { MediaDataService } from './media-data.service';
-import { ResolverService } from './resolver.service';
-
-@Injectable()
-export class EntityDynamicService {
-  constructor(
-    private readonly dataSource: DataSource,
-    private readonly mediaDataService: MediaDataService,
-    private readonly resolverService: ResolverService,
-  ) {}
-
-  // -----------------------------
-  async createEntity(
-    entityType: string,
-    entityData: Record<string, any>,
-    loggedInUser: any,
-    mainID?: number,
-  ): Promise<any> {
-    const organizationId = loggedInUser.organization_id;
-
-    const tableName = await this.getTableName(entityType, organizationId);
-    const validAttributes = await this.getAttributeCodes(
-      entityType,
-      organizationId,
-    );
-
-    const statusList = await this.dataSource.query(
-      `SELECT id FROM frm_list_master_items WHERE code = ? AND organization_id = ?`,
-      [STATUS_ACTIVE, loggedInUser?.organization_id || 0],
-    );
-
-    entityData.created_date = new Date();
-    if (loggedInUser) {
-      entityData.created_by = loggedInUser.id;
-      if (!entityData.organization_id)
-        entityData.organization_id = loggedInUser.organization_id;
-      if (!entityData.enterprise_id)
-        entityData.enterprise_id = loggedInUser.enterprise_id;
-      if (!entityData.level_type)
-        entityData.level_type = loggedInUser.level_type;
-      if (!entityData.level_id) entityData.level_id = loggedInUser.level_id;
-      if (!entityData.status) entityData.status = statusList[0].id;
-      if (!entityData.entity_type) entityData.entity_type = entityType;
-    }
-
-    if (!entityData.code && loggedInUser) {
-      const result = await this.dataSource.query(
-        `SELECT MAX(CAST(SUBSTRING(code, LENGTH(entity_type) + 1) AS UNSIGNED)) AS max_seq_no
-     FROM ${tableName}
-     WHERE entity_type = ?`,
-        [entityData.entity_type],
-      );
-
-      // result will be like [ { max_seq_no: 12 } ]
-      let maxSeqNo = result?.[0]?.max_seq_no ? Number(result[0].max_seq_no) : 0;
-
-      maxSeqNo += 1;
-      entityData.code = `${entityData.entity_type}${maxSeqNo}`;
-    }
-
-    // Set parent_id if mainID is provided
-    if (mainID) {
-      entityData.parent_id = mainID;
-    }
-
-    const bypassColumn = [
-      {
-        attribute_key: 'created_date',
-        db_datatype: 'datetime',
-        element_type: 'date',
-      },
-      {
-        attribute_key: 'created_by',
-        db_datatype: 'int',
-        element_type: 'number',
-      },
-      {
-        attribute_key: 'organization_id',
-        db_datatype: 'datetime',
-        element_type: 'date',
-      },
-      {
-        attribute_key: 'enterprise_id',
-        db_datatype: 'int',
-        element_type: 'number',
-      },
-      { attribute_key: 'level_type', db_datatype: 'int', element_type: 'text' },
-      { attribute_key: 'level_id', db_datatype: 'int', element_type: 'number' },
-      { attribute_key: 'status', db_datatype: 'varchar', element_type: 'text' },
-      {
-        attribute_key: 'entity_type',
-        db_datatype: 'varchar',
-        element_type: 'text',
-      },
-      { attribute_key: 'code', db_datatype: 'varchar', element_type: 'text' },
-      {
-        attribute_key: 'parent_id',
-        db_datatype: 'int',
-        element_type: 'number',
-      },
-    ];
-
-    // Only push bypassColumn attributes that don't already exist in validAttributes
-    const existingAttributeKeys = validAttributes.map(
-      (attr) => attr.attribute_key,
-    );
-    const newBypassColumns = bypassColumn.filter(
-      (bypass) => !existingAttributeKeys.includes(bypass.attribute_key),
-    );
-    validAttributes.push(...newBypassColumns);
-
-    const columns: string[] = [];
-    const values: any[] = [];
-
-    validAttributes.forEach((attr) => {
-      columns.push(attr.attribute_key);
-      values.push(
-        attr.attribute_key in entityData
-          ? entityData[attr.attribute_key]
-          : null,
-      );
-    });
-
-    const placeholders = columns.map(() => '?').join(', ');
-    const escapedColumns = columns.map((col) => `\`${col}\``).join(', ');
-    const insertQuery = `INSERT INTO \`${tableName}\` (${escapedColumns}) VALUES (${placeholders})`;
-
-    const result = await this.dataSource.query(insertQuery, values);
-    return result;
-  }
-
-  // ----------------------------- get entity with relations
-
-  // ----------------------------- create entity with relations
-  async createEntityWithRelation(
-    entityType: string,
-    data: Record<string, any>,
-    loggedInUser: any,
-  ): Promise<any> {
-    const organizationId = loggedInUser.organization_id;
-
-    const getRelation = await this.dataSource.query(
-      `SELECT * FROM frm_entity_relation WHERE organization_id = ? AND source_entity_type = ?`,
-      [organizationId, entityType],
-    );
-
-    const { mappedEntities, ...mainData } = data;
-
-    // create main entity
-    const createdEntityData = await this.createEntity(
-      entityType,
-      mainData,
-      loggedInUser,
-    );
-    const mainID = createdEntityData.insertId || createdEntityData.id;
-
-    if (mappedEntities && getRelation.length > 0) {
-      for (const relation of getRelation) {
-        const targetEntityType = relation.target_entity_type;
-        const relationType = relation.relation_type;
-        const relationId = relation.relation_id;
-
-        if (!mappedEntities[targetEntityType]) continue;
-
-        // normalize: always array
-        const entityDataArray = Array.isArray(mappedEntities[targetEntityType])
-          ? mappedEntities[targetEntityType]
-          : [mappedEntities[targetEntityType]];
-
-        for (const item of entityDataArray) {
-          const itemWithRef = {
-            ...item,
-            entity_type: targetEntityType,
-          };
-
-          const createdRelatedEntity = await this.createEntity(
-            targetEntityType,
-            itemWithRef,
-            loggedInUser,
-            mainID, // this will pass for parent_id
-          );
-
-          await this.dataSource.query(
-            `INSERT INTO frm_entity_relation_data (organization_id, source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) VALUES (?, ?, ?, ?, ?,?)`,
-            [
-              organizationId,
-              mainID,
-              entityType,
-              createdRelatedEntity.insertId,
-              targetEntityType,
-              relationType,
-            ],
-          );
-        }
-      }
-    }
-
-    return {
-      mainEntity: {
-        id: mainID,
-        entityType,
-        data: createdEntityData,
-      },
-    };
-  }
-
-  // ----------------------------- get entity with relations
-  async getEntityWithRelation(
-    entityType: string,
-    id: number | string,
-    loggedInUser: any,
-  ): Promise<any> {
-    const mainEntity = await this.getEntityByDataSource(
-      entityType,
-      id,
-      loggedInUser,
-    );
-
-    const relatedEntities = await this.dataSource.query(
-      `SELECT * FROM frm_entity_relation_data WHERE  source_entity_id = ? AND target_entity_type IN (
-      SELECT target_entity_type FROM frm_entity_relation WHERE source_entity_type = ?)`,
-      [id, entityType],
-    );
-
-    // Format response to match create entity structure
-    const response: any = {
-      entity_type: entityType,
-      ...mainEntity,
-    };
-
-    if (relatedEntities.length > 0) {
-      response.mappedEntities = await this.formatMappedEntities(
-        relatedEntities,
-        loggedInUser,
-      );
-    }
-
-    return response;
-  }
-
-  // ----------------------------- formatMappedEntities
-  async formatMappedEntities(
-    relatedEntities: any[],
-    loggedInUser: any,
-  ): Promise<any> {
-    const mappedEntities: any = {};
-
-    for (const relation of relatedEntities) {
-      const targetEntityType = relation.target_entity_type;
-      const targetEntityId = relation.target_entity_id;
-
-      const entityData = await this.getEntity(
-        targetEntityType,
-        targetEntityId,
-        loggedInUser,
-      );
-
-      if (!mappedEntities[targetEntityType]) {
-        mappedEntities[targetEntityType] = [];
-      }
-
-      mappedEntities[targetEntityType].push(entityData);
-    }
-
-    return mappedEntities;
-  }
-
-  // ----------------------------- update with relations
-
-  // ----------------------------- update entity with relations
-  async updateEntityWithRelations(
-    entityType: string,
-    id: number | string,
-    data: Record<string, any>,
-    loggedInUser: any,
-  ): Promise<any> {
-    const organizationId = loggedInUser.organization_id;
-    const { mappedEntities, ...mainData } = data;
-
-    // Update main entity
-    const updatedMainEntity = await this.updateEntity(
-      entityType,
-      id,
-      mainData,
-      loggedInUser,
-    );
-
-    const updatedRelations: Record<string, any> = {};
-
-    if (mappedEntities) {
-      const getRelationDefs = await this.dataSource.query(
-        `SELECT * FROM frm_entity_relation WHERE organization_id = ? AND source_entity_type = ?`,
-        [organizationId, entityType],
-      );
-
-      for (const [targetEntityType, rawEntityData] of Object.entries(
-        mappedEntities,
-      )) {
-        const relationDef = getRelationDefs.find(
-          (r) => r.target_entity_type === targetEntityType,
-        );
-        if (!relationDef) continue;
-
-        const relationType = relationDef.relation_type;
-        const entityArray = Array.isArray(rawEntityData)
-          ? rawEntityData
-          : [rawEntityData];
-
-        // Delete previous relations and related entities
-        const existingRelationsForType = await this.dataSource.query(
-          `SELECT * FROM frm_entity_relation_data WHERE source_entity_type = ? AND source_entity_id = ? AND target_entity_type = ?`,
-          [entityType, id, targetEntityType],
-        );
-
-        // Create/update new entities & relations
-        const updatedEntities: any[] = [];
-
-        for (const item of entityArray) {
-          let targetEntityId;
-          let entityData;
-
-          if (item.id) {
-            // Update existing entity
-            await this.updateEntity(
-              targetEntityType,
-              item.id,
-              item,
-              loggedInUser,
-              Number(id), // pass main entity id as parent_id
-            );
-            targetEntityId = item.id;
-            entityData = await this.getEntity(
-              targetEntityType,
-              targetEntityId,
-              loggedInUser,
-            );
-          } else {
-            // Delete the related entity if we are creating a new one
-            // for (const existingRel of existingRelationsForType) {
-            //   await this.deleteEntity(
-            //     existingRel.target_entity_type,
-            //     existingRel.target_entity_id,
-            //     loggedInUser,
-            //   );
-
-            //   // Delete the relation row
-            //   await this.dataSource.query(
-            //     `DELETE FROM frm_entity_relation_data WHERE id = ?`,
-            //     [existingRel.id],
-            //   );
-            // }
-            // Create new entity
-            const createdEntity = await this.createEntity(
-              targetEntityType,
-              item,
-              loggedInUser,
-              Number(id), // pass main entity id as parent_id
-            );
-            targetEntityId = createdEntity.insertId || createdEntity.id;
-            entityData = await this.getEntity(
-              targetEntityType,
-              targetEntityId,
-              loggedInUser,
-            );
-
-            // Insert relation as per new entity created
-            await this.dataSource.query(
-              `INSERT INTO frm_entity_relation_data 
-            (organization_id, source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) 
-            VALUES (?, ?, ?, ?, ?,?)`,
-              [
-                organizationId,
-                id,
-                entityType,
-                targetEntityId,
-                targetEntityType,
-                relationType,
-              ],
-            );
-          }
-
-          if (relationType === 'ONE_TO_MANY') {
-            updatedEntities.push(entityData);
-          } else if (
-            relationType === 'ONE_TO_ONE' ||
-            relationType === 'MANY_TO_ONE'
-          ) {
-            updatedEntities[0] = entityData; // single object
-          }
-        }
-
-        // Assign to response mappedEntities
-        updatedRelations[targetEntityType] =
-          relationType === 'ONE_TO_MANY' ? updatedEntities : updatedEntities[0];
-      }
-    }
-
-    return {
-      mainEntity: {
-        id,
-        entityType,
-        data: updatedMainEntity,
-      },
-      relatedEntities: updatedRelations,
-    };
-  }
-
-  // -----------------------------
-  async updateEntity(
-    entityType: string,
-    id: number | string,
-    entityData: Record<string, any>,
-    loggedInUser: any,
-    mainID?: number,
-  ): Promise<any> {
-    const organizationId = loggedInUser.organization_id;
-
-    const tableName = await this.getTableName(entityType, organizationId);
-    const validAttributes = await this.getAttributeCodes(
-      entityType,
-      organizationId,
-    );
-
-    const updates: string[] = [];
-    const values: any[] = [];
-
-    entityData.modified_date = new Date();
-    if (loggedInUser) {
-      entityData.modified_by = loggedInUser.id;
-      if (!entityData.organization_id && entityData.entity_type !== 'ORG')
-        entityData.organization_id = loggedInUser.organization_id;
-      if (!entityData.enterprise_id)
-        entityData.enterprise_id = loggedInUser.enterprise_id;
-    }
-
-    // Set parent_id if mainID is provided
-    if (mainID) {
-      entityData.parent_id = mainID;
-    }
-
-    const bypassColumn = [
-      {
-        attribute_key: 'created_date',
-        db_datatype: 'datetime',
-        element_type: 'date',
-      },
-      {
-        attribute_key: 'created_by',
-        db_datatype: 'int',
-        element_type: 'number',
-      },
-      {
-        attribute_key: 'modified_date',
-        db_datatype: 'datetime',
-        element_type: 'date',
-      },
-      {
-        attribute_key: 'modified_by',
-        db_datatype: 'int',
-        element_type: 'number',
-      },
-      {
-        attribute_key: 'organization_id',
-        db_datatype: 'int',
-        element_type: 'number',
-      },
-      {
-        attribute_key: 'enterprise_id',
-        db_datatype: 'int',
-        element_type: 'number',
-      },
-      {
-        attribute_key: 'level_type',
-        db_datatype: 'varchar',
-        element_type: 'text',
-      },
-      { attribute_key: 'level_id', db_datatype: 'int', element_type: 'number' },
-      { attribute_key: 'status', db_datatype: 'varchar', element_type: 'text' },
-      {
-        attribute_key: 'entity_type',
-        db_datatype: 'varchar',
-        element_type: 'text',
-      },
-      { attribute_key: 'code', db_datatype: 'varchar', element_type: 'text' },
-      {
-        attribute_key: 'parent_id',
-        db_datatype: 'int',
-        element_type: 'number',
-      },
-    ];
-
-    // Only push bypassColumn attributes that don't already exist in validAttributes
-    const existingAttributeKeys = validAttributes.map(
-      (attr) => attr.attribute_key,
-    );
-    const newBypassColumns = bypassColumn.filter(
-      (bypass) => !existingAttributeKeys.includes(bypass.attribute_key),
-    );
-    validAttributes.push(...newBypassColumns);
-
-    for (const key of Object.keys(entityData)) {
-      if (validAttributes.some((attr) => attr.attribute_key === key)) {
-        updates.push(`\`${key}\` = ?`);
-        values.push(entityData[key]);
-      }
-    }
-
-    if (updates.length === 0) {
-      throw new Error('No valid attributes to update.');
-    }
-
-    const updateQuery = `UPDATE \`${tableName}\` SET ${updates.join(', ')} WHERE id = ?`;
-    values.push(id); // Add id for WHERE clause
-
-    const result = await this.dataSource.query(updateQuery, values);
-    return result;
-  }
-
-  async getEntityByDataSource(
-    entityType: string,
-    id: number | string,
-    loggedInUser: any,
-  ): Promise<any> {
-    const organizationId = loggedInUser.organization_id;
-
-    const dataSource = await this.getEntitySourceTableName(
-      entityType,
-      organizationId,
-    );
-    const validAttributes = await this.getAttributeCodes(
-      entityType,
-      organizationId,
-    );
-
-    const columns = validAttributes
-      .map((attr) => `\`${attr.attribute_key}\``)
-      .join(', ');
-    const selectQuery = `SELECT ${columns} FROM \`${dataSource}\` WHERE id = ?`;
-
-    const result = await this.dataSource.query(selectQuery, [id]);
-    if (!result.length) return null;
-
-    const row = result[0];
-
-    // Convert boolean columns (1/0) into true/false
-    for (const attr of validAttributes) {
-      if (
-        attr.db_datatype == 'boolean' &&
-        row[attr.attribute_key] !== undefined
-      ) {
-        row[attr.attribute_key] = row[attr.attribute_key] == 1 ? true : false;
-      } else if (
-        attr.element_type == 'upload' &&
-        row[attr.attribute_key] !== undefined
-      ) {
-        row[attr.attribute_key] =
-          row[attr.attribute_key] != null
-            ? await this.mediaDataService.getMediaDownloadUrl(
-                Number(row[attr.attribute_key]),
-                loggedInUser,
-              )
-            : null;
-      }
-    }
-
-    return row;
-  }
-  // -----------------------------
-  async getEntity(
-    entityType: string,
-    id: number | string,
-    loggedInUser: any,
-  ): Promise<any> {
-    const organizationId = loggedInUser.organization_id;
-
-    const tableName = await this.getTableName(entityType, organizationId);
-    const dataSource = await this.getEntitySourceTableName(
-      entityType,
-      organizationId,
-    );
-    const validAttributes = await this.getAttributeCodes(
-      entityType,
-      organizationId,
-    );
-
-    const columns = validAttributes
-      .map((attr) => `\`${attr.attribute_key}\``)
-      .join(', ');
-    const selectQuery = `SELECT ${columns} FROM \`${tableName}\` WHERE id = ?`;
-
-    const result = await this.dataSource.query(selectQuery, [id]);
-    if (!result.length) return null;
-
-    const row = result[0];
-
-    // Convert boolean columns (1/0) into true/false
-    for (const attr of validAttributes) {
-      if (
-        attr.db_datatype == 'boolean' &&
-        row[attr.attribute_key] !== undefined
-      ) {
-        row[attr.attribute_key] = row[attr.attribute_key] == 1 ? true : false;
-      } else if (
-        attr.element_type == 'upload' &&
-        row[attr.attribute_key] !== undefined
-      ) {
-        row[attr.attribute_key] =
-          row[attr.attribute_key] != null
-            ? await this.mediaDataService.getMediaDownloadUrl(
-                Number(row[attr.attribute_key]),
-                loggedInUser,
-              )
-            : null;
-      }
-    }
-
-    return row;
-  }
-
-  private async getEntitySourceTableName(
-    entityType: string,
-    organizationId: string,
-  ): Promise<string> {
-    const result = await this.dataSource.query(
-      `SELECT data_source, db_table_name FROM frm_entity_master WHERE organization_id = ? AND mapped_entity_type = ?`,
-      [organizationId, entityType],
-    );
-    if (!result.length) {
-      console.log(`Entity type '${entityType}' not found in frm_entity_master`);
-    }
-
-    return result[0].data_source;
-  }
-
-  // -----------------------------
-  private async getTableName(
-    entityType: string,
-    organizationId: string,
-  ): Promise<string> {
-    const result = await this.dataSource.query(
-      `SELECT db_table_name FROM frm_entity_master WHERE organization_id = ? AND mapped_entity_type = ?`,
-      [organizationId, entityType],
-    );
-
-    if (!result.length) {
-      console.log(`Entity type '${entityType}' not found in frm_entity_master`);
-    }
-
-    return result[0].db_table_name;
-  }
-
-  private async getAttributeCodes(
-    entityType: string,
-    organizationId: string,
-  ): Promise<
-    {
-      attribute_key: string;
-      db_datatype: string;
-      element_type: string;
-      is_hidden?: boolean;
-    }[]
-  > {
-    const result = await this.dataSource.query(
-      `SELECT attribute_key,  
-    MAX(db_datatype) AS db_datatype,
-    MAX(element_type) AS element_type,
-    MAX(is_hidden) AS is_hidden
-     FROM frm_entity_attribute
-     WHERE mapped_entity_type = ? AND organization_id = ? 
-     and (is_hidden IS NULL OR is_hidden = 0)  -- Exclude hidden attributes
-     GROUP BY attribute_key`,
-      [entityType, organizationId],
-    );
-
-    if (!result.length) {
-      console.log(
-        `No attributes found for entity '${entityType}' and org '${organizationId}'`,
-      );
-    }
-
-    return result.map((row: any) => ({
-      attribute_key: row.attribute_key,
-      db_datatype: row.db_datatype,
-      element_type: row.element_type,
-      is_hidden: row.is_hidden,
-    }));
-  }
-
-  private async deleteEntity(
-    entityType: string,
-    id: number | string,
-    loggedInUser: any,
-  ): Promise<any> {
-    const organizationId = loggedInUser.organization_id;
-
-    const tableName = await this.getTableName(entityType, organizationId);
-
-    const deleteQuery = `DELETE FROM \`${tableName}\` WHERE id = ?`;
-    const result = await this.dataSource.query(deleteQuery, [id]);
-    return result;
-  }
-
-  // -----------------------------
-
-  async getEntitiesDropdownList(
-    loggedInUser: any,
-    appcode?: string,
-  ): Promise<any> {
-    const organizationId = loggedInUser.organization_id;
-
-    let query = `SELECT name as label,mapped_entity_type as value FROM frm_entity_master WHERE organization_id = ?`;
-    const params = [organizationId];
-
-    if (appcode) {
-      query += ` AND appcode = ?`;
-      params.push(appcode);
-    }
-
-    const dropdown = await this.dataSource.query(query, params);
-    return dropdown;
-  }
-
-  async getCode(entityType: string, loggedInUser: any): Promise<string> {
-    const organizationId = loggedInUser.organization_id;
-
-    // 1. Get db_table_name from entity master
-    const result = await this.dataSource.query(
-      `SELECT db_table_name 
-     FROM frm_entity_master 
-     WHERE mapped_entity_type = ? AND organization_id = ?`,
-      [entityType, organizationId],
-    );
-
-    if (!result.length) {
-      throw new Error(
-        `Entity type '${entityType}' not found in frm_entity_master for org '${organizationId}'`,
-      );
-    }
-
-    const tableName = result[0].db_table_name;
-
-    // 2. Get current max sequence number from that table
-    const seqResult = await this.dataSource.query(
-      `SELECT MAX(CAST(SUBSTRING(code, LENGTH(entity_type) + 1) AS UNSIGNED)) AS max_seq_no
-     FROM \`${tableName}\`
-     WHERE entity_type = ?`,
-      [entityType],
-    );
-
-    let maxSeqNo = seqResult?.[0]?.max_seq_no
-      ? Number(seqResult[0].max_seq_no)
-      : 0;
-
-    maxSeqNo += 1;
-
-    // 3. Return generated code
-    return `${entityType}${maxSeqNo}`;
-  }
-
-  async getResolvedEntity(
-    id: number,
-    entity: string,
-    loggedInUser: UserData,
-  ): Promise<any> {
-    const leadData = await this.getEntityWithRelation(entity, id, loggedInUser);
-
-    const { mappedEntities, ...data } = leadData as any;
-
-    const resolvedData = await this.resolverService.getResolvedData(
-      loggedInUser,
-      data,
-      entity,
-    );
-
-    if (mappedEntities) {
-      resolvedData.mappedEntities = {};
-      for (const [entityType, entities] of Object.entries(mappedEntities)) {
-        if (Array.isArray(entities)) {
-          resolvedData.mappedEntities[entityType] = [];
-          for (const item of entities) {
-            const resolvedItem = await this.resolverService.getResolvedData(
-              loggedInUser,
-              item,
-              entityType,
-            );
-            resolvedData.mappedEntities[entityType].push(resolvedItem);
-          }
-        } else {
-          resolvedData.mappedEntities[entityType] =
-            await this.resolverService.getResolvedData(
-              loggedInUser,
-              entities,
-              entityType,
-            );
-        }
-      }
-    }
-
-    return resolvedData;
-  }
-}
+import { level } from 'winston';
+import { Injectable } from '@nestjs/common';
+import {
+  ENTITYTYPE_ENTITYMASTER,
+  STATUS_ACTIVE,
+} from 'src/constant/global.constant';
+import { DataSource } from 'typeorm';
+import { UserData } from 'src/module/user/entity/user.entity';
+import { MediaDataService } from './media-data.service';
+import { ResolverService } from './resolver.service';
+
+@Injectable()
+export class EntityDynamicService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly mediaDataService: MediaDataService,
+    private readonly resolverService: ResolverService,
+  ) {}
+
+  // -----------------------------
+  async createEntity(
+    entityType: string,
+    entityData: Record<string, any>,
+    loggedInUser: any,
+    mainID?: number,
+  ): Promise<any> {
+    const organizationId = loggedInUser.organization_id;
+
+    const tableName = await this.getTableName(entityType, organizationId);
+    const validAttributes = await this.getAttributeCodes(
+      entityType,
+      organizationId,
+    );
+
+    const statusList = await this.dataSource.query(
+      `SELECT id FROM frm_list_master_items WHERE code = ? AND organization_id = ?`,
+      [STATUS_ACTIVE, loggedInUser?.organization_id || 0],
+    );
+
+    entityData.created_date = new Date();
+    if (loggedInUser) {
+      entityData.created_by = loggedInUser.id;
+      if (!entityData.organization_id)
+        entityData.organization_id = loggedInUser.organization_id;
+      if (!entityData.enterprise_id)
+        entityData.enterprise_id = loggedInUser.enterprise_id;
+      if (!entityData.level_type)
+        entityData.level_type = loggedInUser.level_type;
+      if (!entityData.level_id) entityData.level_id = loggedInUser.level_id;
+      if (!entityData.status) entityData.status = statusList[0].id;
+      if (!entityData.entity_type) entityData.entity_type = entityType;
+    }
+
+    if (!entityData.code && loggedInUser) {
+      const result = await this.dataSource.query(
+        `SELECT MAX(CAST(SUBSTRING(code, LENGTH(entity_type) + 1) AS UNSIGNED)) AS max_seq_no
+     FROM ${tableName}
+     WHERE entity_type = ?`,
+        [entityData.entity_type],
+      );
+
+      // result will be like [ { max_seq_no: 12 } ]
+      let maxSeqNo = result?.[0]?.max_seq_no ? Number(result[0].max_seq_no) : 0;
+
+      maxSeqNo += 1;
+      entityData.code = `${entityData.entity_type}${maxSeqNo}`;
+    }
+
+    // Set parent_id if mainID is provided
+    if (mainID) {
+      entityData.parent_id = mainID;
+    }
+
+    const bypassColumn = [
+      {
+        attribute_key: 'created_date',
+        db_datatype: 'datetime',
+        element_type: 'date',
+      },
+      {
+        attribute_key: 'created_by',
+        db_datatype: 'int',
+        element_type: 'number',
+      },
+      {
+        attribute_key: 'organization_id',
+        db_datatype: 'datetime',
+        element_type: 'date',
+      },
+      {
+        attribute_key: 'enterprise_id',
+        db_datatype: 'int',
+        element_type: 'number',
+      },
+      { attribute_key: 'level_type', db_datatype: 'int', element_type: 'text' },
+      { attribute_key: 'level_id', db_datatype: 'int', element_type: 'number' },
+      { attribute_key: 'status', db_datatype: 'varchar', element_type: 'text' },
+      {
+        attribute_key: 'entity_type',
+        db_datatype: 'varchar',
+        element_type: 'text',
+      },
+      { attribute_key: 'code', db_datatype: 'varchar', element_type: 'text' },
+      {
+        attribute_key: 'parent_id',
+        db_datatype: 'int',
+        element_type: 'number',
+      },
+    ];
+
+    // Only push bypassColumn attributes that don't already exist in validAttributes
+    const existingAttributeKeys = validAttributes.map(
+      (attr) => attr.attribute_key,
+    );
+    const newBypassColumns = bypassColumn.filter(
+      (bypass) => !existingAttributeKeys.includes(bypass.attribute_key),
+    );
+    validAttributes.push(...newBypassColumns);
+
+    const columns: string[] = [];
+    const values: any[] = [];
+
+    validAttributes.forEach((attr) => {
+      columns.push(attr.attribute_key);
+      values.push(
+        attr.attribute_key in entityData
+          ? entityData[attr.attribute_key]
+          : null,
+      );
+    });
+
+    const placeholders = columns.map(() => '?').join(', ');
+    const escapedColumns = columns.map((col) => `\`${col}\``).join(', ');
+    const insertQuery = `INSERT INTO \`${tableName}\` (${escapedColumns}) VALUES (${placeholders})`;
+
+    const result = await this.dataSource.query(insertQuery, values);
+    return result;
+  }
+
+  // ----------------------------- get entity with relations
+
+  // ----------------------------- create entity with relations
+  async createEntityWithRelation(
+    entityType: string,
+    data: Record<string, any>,
+    loggedInUser: any,
+  ): Promise<any> {
+    const organizationId = loggedInUser.organization_id;
+
+    const getRelation = await this.dataSource.query(
+      `SELECT * FROM frm_entity_relation WHERE organization_id = ? AND source_entity_type = ?`,
+      [organizationId, entityType],
+    );
+
+    const { mappedEntities, ...mainData } = data;
+
+    // create main entity
+    const createdEntityData = await this.createEntity(
+      entityType,
+      mainData,
+      loggedInUser,
+    );
+    const mainID = createdEntityData.insertId || createdEntityData.id;
+
+    if (mappedEntities && getRelation.length > 0) {
+      for (const relation of getRelation) {
+        const targetEntityType = relation.target_entity_type;
+        const relationType = relation.relation_type;
+        const relationId = relation.relation_id;
+
+        if (!mappedEntities[targetEntityType]) continue;
+
+        // normalize: always array
+        const entityDataArray = Array.isArray(mappedEntities[targetEntityType])
+          ? mappedEntities[targetEntityType]
+          : [mappedEntities[targetEntityType]];
+
+        for (const item of entityDataArray) {
+          const itemWithRef = {
+            ...item,
+            entity_type: targetEntityType,
+          };
+
+          const createdRelatedEntity = await this.createEntity(
+            targetEntityType,
+            itemWithRef,
+            loggedInUser,
+            mainID, // this will pass for parent_id
+          );
+
+          await this.dataSource.query(
+            `INSERT INTO frm_entity_relation_data (organization_id, source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) VALUES (?, ?, ?, ?, ?,?)`,
+            [
+              organizationId,
+              mainID,
+              entityType,
+              createdRelatedEntity.insertId,
+              targetEntityType,
+              relationType,
+            ],
+          );
+        }
+      }
+    }
+
+    return {
+      mainEntity: {
+        id: mainID,
+        entityType,
+        data: createdEntityData,
+      },
+    };
+  }
+
+  // ----------------------------- get entity with relations
+  async getEntityWithRelation(
+    entityType: string,
+    id: number | string,
+    loggedInUser: any,
+  ): Promise<any> {
+    const mainEntity = await this.getEntityByDataSource(
+      entityType,
+      id,
+      loggedInUser,
+    );
+
+    const relatedEntities = await this.dataSource.query(
+      `SELECT * FROM frm_entity_relation_data WHERE  source_entity_id = ? AND target_entity_type IN (
+      SELECT target_entity_type FROM frm_entity_relation WHERE source_entity_type = ?)`,
+      [id, entityType],
+    );
+
+    // Format response to match create entity structure
+    const response: any = {
+      entity_type: entityType,
+      ...mainEntity,
+    };
+
+    if (relatedEntities.length > 0) {
+      response.mappedEntities = await this.formatMappedEntities(
+        relatedEntities,
+        loggedInUser,
+      );
+    }
+
+    return response;
+  }
+
+  // ----------------------------- formatMappedEntities
+  async formatMappedEntities(
+    relatedEntities: any[],
+    loggedInUser: any,
+  ): Promise<any> {
+    const mappedEntities: any = {};
+
+    for (const relation of relatedEntities) {
+      const targetEntityType = relation.target_entity_type;
+      const targetEntityId = relation.target_entity_id;
+
+      const entityData = await this.getEntity(
+        targetEntityType,
+        targetEntityId,
+        loggedInUser,
+      );
+
+      if (!mappedEntities[targetEntityType]) {
+        mappedEntities[targetEntityType] = [];
+      }
+
+      mappedEntities[targetEntityType].push(entityData);
+    }
+
+    return mappedEntities;
+  }
+
+  // ----------------------------- update with relations
+
+  // ----------------------------- update entity with relations
+  async updateEntityWithRelations(
+    entityType: string,
+    id: number | string,
+    data: Record<string, any>,
+    loggedInUser: any,
+  ): Promise<any> {
+    const organizationId = loggedInUser.organization_id;
+    const { mappedEntities, ...mainData } = data;
+
+    // Update main entity
+    const updatedMainEntity = await this.updateEntity(
+      entityType,
+      id,
+      mainData,
+      loggedInUser,
+    );
+
+    const updatedRelations: Record<string, any> = {};
+
+    if (mappedEntities) {
+      const getRelationDefs = await this.dataSource.query(
+        `SELECT * FROM frm_entity_relation WHERE organization_id = ? AND source_entity_type = ?`,
+        [organizationId, entityType],
+      );
+
+      for (const [targetEntityType, rawEntityData] of Object.entries(
+        mappedEntities,
+      )) {
+        const relationDef = getRelationDefs.find(
+          (r) => r.target_entity_type === targetEntityType,
+        );
+        if (!relationDef) continue;
+
+        const relationType = relationDef.relation_type;
+        const entityArray = Array.isArray(rawEntityData)
+          ? rawEntityData
+          : [rawEntityData];
+
+        // Delete previous relations and related entities
+        const existingRelationsForType = await this.dataSource.query(
+          `SELECT * FROM frm_entity_relation_data WHERE source_entity_type = ? AND source_entity_id = ? AND target_entity_type = ?`,
+          [entityType, id, targetEntityType],
+        );
+
+        // Create/update new entities & relations
+        const updatedEntities: any[] = [];
+
+        for (const item of entityArray) {
+          let targetEntityId;
+          let entityData;
+
+          if (item.id) {
+            // Update existing entity
+            await this.updateEntity(
+              targetEntityType,
+              item.id,
+              item,
+              loggedInUser,
+              Number(id), // pass main entity id as parent_id
+            );
+            targetEntityId = item.id;
+            entityData = await this.getEntity(
+              targetEntityType,
+              targetEntityId,
+              loggedInUser,
+            );
+          } else {
+            // Delete the related entity if we are creating a new one
+            // for (const existingRel of existingRelationsForType) {
+            //   await this.deleteEntity(
+            //     existingRel.target_entity_type,
+            //     existingRel.target_entity_id,
+            //     loggedInUser,
+            //   );
+
+            //   // Delete the relation row
+            //   await this.dataSource.query(
+            //     `DELETE FROM frm_entity_relation_data WHERE id = ?`,
+            //     [existingRel.id],
+            //   );
+            // }
+            // Create new entity
+            const createdEntity = await this.createEntity(
+              targetEntityType,
+              item,
+              loggedInUser,
+              Number(id), // pass main entity id as parent_id
+            );
+            targetEntityId = createdEntity.insertId || createdEntity.id;
+            entityData = await this.getEntity(
+              targetEntityType,
+              targetEntityId,
+              loggedInUser,
+            );
+
+            // Insert relation as per new entity created
+            await this.dataSource.query(
+              `INSERT INTO frm_entity_relation_data 
+            (organization_id, source_entity_id, source_entity_type, target_entity_id, target_entity_type, relation_type) 
+            VALUES (?, ?, ?, ?, ?,?)`,
+              [
+                organizationId,
+                id,
+                entityType,
+                targetEntityId,
+                targetEntityType,
+                relationType,
+              ],
+            );
+          }
+
+          if (relationType === 'ONE_TO_MANY') {
+            updatedEntities.push(entityData);
+          } else if (
+            relationType === 'ONE_TO_ONE' ||
+            relationType === 'MANY_TO_ONE'
+          ) {
+            updatedEntities[0] = entityData; // single object
+          }
+        }
+
+        // Assign to response mappedEntities
+        updatedRelations[targetEntityType] =
+          relationType === 'ONE_TO_MANY' ? updatedEntities : updatedEntities[0];
+      }
+    }
+
+    return {
+      mainEntity: {
+        id,
+        entityType,
+        data: updatedMainEntity,
+      },
+      relatedEntities: updatedRelations,
+    };
+  }
+
+  // -----------------------------
+  async updateEntity(
+    entityType: string,
+    id: number | string,
+    entityData: Record<string, any>,
+    loggedInUser: any,
+    mainID?: number,
+  ): Promise<any> {
+    const organizationId = loggedInUser.organization_id;
+
+    const tableName = await this.getTableName(entityType, organizationId);
+    const validAttributes = await this.getAttributeCodes(
+      entityType,
+      organizationId,
+    );
+
+    const updates: string[] = [];
+    const values: any[] = [];
+
+    entityData.modified_date = new Date();
+    if (loggedInUser) {
+      entityData.modified_by = loggedInUser.id;
+      if (!entityData.organization_id && entityData.entity_type !== 'ORG')
+        entityData.organization_id = loggedInUser.organization_id;
+      if (!entityData.enterprise_id)
+        entityData.enterprise_id = loggedInUser.enterprise_id;
+    }
+
+    // Set parent_id if mainID is provided
+    if (mainID) {
+      entityData.parent_id = mainID;
+    }
+
+    const bypassColumn = [
+      {
+        attribute_key: 'created_date',
+        db_datatype: 'datetime',
+        element_type: 'date',
+      },
+      {
+        attribute_key: 'created_by',
+        db_datatype: 'int',
+        element_type: 'number',
+      },
+      {
+        attribute_key: 'modified_date',
+        db_datatype: 'datetime',
+        element_type: 'date',
+      },
+      {
+        attribute_key: 'modified_by',
+        db_datatype: 'int',
+        element_type: 'number',
+      },
+      {
+        attribute_key: 'organization_id',
+        db_datatype: 'int',
+        element_type: 'number',
+      },
+      {
+        attribute_key: 'enterprise_id',
+        db_datatype: 'int',
+        element_type: 'number',
+      },
+      {
+        attribute_key: 'level_type',
+        db_datatype: 'varchar',
+        element_type: 'text',
+      },
+      { attribute_key: 'level_id', db_datatype: 'int', element_type: 'number' },
+      { attribute_key: 'status', db_datatype: 'varchar', element_type: 'text' },
+      {
+        attribute_key: 'entity_type',
+        db_datatype: 'varchar',
+        element_type: 'text',
+      },
+      { attribute_key: 'code', db_datatype: 'varchar', element_type: 'text' },
+      {
+        attribute_key: 'parent_id',
+        db_datatype: 'int',
+        element_type: 'number',
+      },
+    ];
+
+    // Only push bypassColumn attributes that don't already exist in validAttributes
+    const existingAttributeKeys = validAttributes.map(
+      (attr) => attr.attribute_key,
+    );
+    const newBypassColumns = bypassColumn.filter(
+      (bypass) => !existingAttributeKeys.includes(bypass.attribute_key),
+    );
+    validAttributes.push(...newBypassColumns);
+
+    for (const key of Object.keys(entityData)) {
+      if (validAttributes.some((attr) => attr.attribute_key === key)) {
+        updates.push(`\`${key}\` = ?`);
+        values.push(entityData[key]);
+      }
+    }
+
+    if (updates.length === 0) {
+      throw new Error('No valid attributes to update.');
+    }
+
+    const updateQuery = `UPDATE \`${tableName}\` SET ${updates.join(', ')} WHERE id = ?`;
+    values.push(id); // Add id for WHERE clause
+
+    const result = await this.dataSource.query(updateQuery, values);
+    return result;
+  }
+
+  async getEntityByDataSource(
+    entityType: string,
+    id: number | string,
+    loggedInUser: any,
+  ): Promise<any> {
+    const organizationId = loggedInUser.organization_id;
+
+    const dataSource = await this.getEntitySourceTableName(
+      entityType,
+      organizationId,
+    );
+    const validAttributes = await this.getAttributeCodes(
+      entityType,
+      organizationId,
+    );
+
+    const columns = validAttributes
+      .map((attr) => `\`${attr.attribute_key}\``)
+      .join(', ');
+    const selectQuery = `SELECT ${columns} FROM \`${dataSource}\` WHERE id = ?`;
+
+    const result = await this.dataSource.query(selectQuery, [id]);
+    if (!result.length) return null;
+
+    const row = result[0];
+
+    // Convert boolean columns (1/0) into true/false
+    for (const attr of validAttributes) {
+      if (
+        attr.db_datatype == 'boolean' &&
+        row[attr.attribute_key] !== undefined
+      ) {
+        row[attr.attribute_key] = row[attr.attribute_key] == 1 ? true : false;
+      } else if (
+        attr.element_type == 'upload' &&
+        row[attr.attribute_key] !== undefined
+      ) {
+        row[attr.attribute_key] =
+          row[attr.attribute_key] != null
+            ? await this.mediaDataService.getMediaDownloadUrl(
+                Number(row[attr.attribute_key]),
+                loggedInUser,
+              )
+            : null;
+      }
+    }
+
+    return row;
+  }
+  // -----------------------------
+  //TODO : make it normal getEntity function make another function if for resolve data
+  async getEntity(
+    entityType: string,
+    id: number | string,
+    loggedInUser: any,
+  ): Promise<any> {
+    const organizationId = loggedInUser.organization_id;
+
+    const tableName = await this.getTableName(entityType, organizationId);
+    const dataSource = await this.getEntitySourceTableName(
+      entityType,
+      organizationId,
+    );
+    const validAttributes = await this.getAttributeCodes(
+      entityType,
+      organizationId,
+      false,
+    );
+
+    const columns = validAttributes
+      .map((attr) => `\`${attr.attribute_key}\``)
+      .join(', ');
+    const selectQuery = `SELECT ${columns} FROM \`${tableName}\` WHERE id = ?`;
+
+    const result = await this.dataSource.query(selectQuery, [id]);
+    if (!result.length) return null;
+
+    const row = result[0];
+
+    // Convert boolean columns (1/0) into true/false
+    for (const attr of validAttributes) {
+      if (
+        attr.db_datatype == 'boolean' &&
+        row[attr.attribute_key] !== undefined
+      ) {
+        row[attr.attribute_key] = row[attr.attribute_key] == 1 ? true : false;
+      } else if (
+        attr.element_type == 'upload' &&
+        row[attr.attribute_key] !== undefined
+      ) {
+        row[attr.attribute_key] =
+          row[attr.attribute_key] != null
+            ? await this.mediaDataService.getMediaDownloadUrl(
+                Number(row[attr.attribute_key]),
+                loggedInUser,
+              )
+            : null;
+      }
+    }
+
+    return row;
+  }
+
+  private async getEntitySourceTableName(
+    entityType: string,
+    organizationId: string,
+  ): Promise<string> {
+    const result = await this.dataSource.query(
+      `SELECT data_source, db_table_name FROM frm_entity_master WHERE organization_id = ? AND mapped_entity_type = ?`,
+      [organizationId, entityType],
+    );
+    if (!result.length) {
+      console.log(`Entity type '${entityType}' not found in frm_entity_master`);
+    }
+
+    return result[0].data_source;
+  }
+
+  // -----------------------------
+  private async getTableName(
+    entityType: string,
+    organizationId: string,
+  ): Promise<string> {
+    const result = await this.dataSource.query(
+      `SELECT db_table_name FROM frm_entity_master WHERE organization_id = ? AND mapped_entity_type = ?`,
+      [organizationId, entityType],
+    );
+
+    if (!result.length) {
+      console.log(`Entity type '${entityType}' not found in frm_entity_master`);
+    }
+
+    return result[0].db_table_name;
+  }
+
+  private async getAttributeCodes(
+    entityType: string,
+    organizationId: string,
+    isHidden = true,
+  ): Promise<
+    {
+      attribute_key: string;
+      db_datatype: string;
+      element_type: string;
+      is_hidden?: boolean;
+    }[]
+  > {
+    const qb = this.dataSource
+      .createQueryBuilder()
+      .select('fea.attribute_key', 'attribute_key')
+      .addSelect('MAX(fea.db_datatype)', 'db_datatype')
+      .addSelect('MAX(fea.element_type)', 'element_type')
+      .addSelect('MAX(fea.is_hidden)', 'is_hidden')
+      .from('frm_entity_attribute', 'fea')
+      .where('fea.mapped_entity_type = :entityType', { entityType })
+      .andWhere('fea.organization_id = :organizationId', { organizationId });
+
+    // add hidden filter only when requested
+    if (isHidden) {
+      qb.andWhere('(fea.is_hidden IS NULL OR fea.is_hidden = 0)');
+    }
+
+    qb.groupBy('fea.attribute_key');
+
+    const result = await qb.getRawMany();
+
+    if (!result.length) {
+      console.log(
+        `No attributes found for entity '${entityType}' and org '${organizationId}'`,
+      );
+    }
+
+    return result.map((row: any) => ({
+      attribute_key: row.attribute_key,
+      db_datatype: row.db_datatype,
+      element_type: row.element_type,
+      is_hidden: row.is_hidden != null ? !!Number(row.is_hidden) : undefined,
+    }));
+  }
+
+  private async deleteEntity(
+    entityType: string,
+    id: number | string,
+    loggedInUser: any,
+  ): Promise<any> {
+    const organizationId = loggedInUser.organization_id;
+
+    const tableName = await this.getTableName(entityType, organizationId);
+
+    const deleteQuery = `DELETE FROM \`${tableName}\` WHERE id = ?`;
+    const result = await this.dataSource.query(deleteQuery, [id]);
+    return result;
+  }
+
+  // -----------------------------
+
+  async getEntitiesDropdownList(
+    loggedInUser: any,
+    appcode?: string,
+  ): Promise<any> {
+    const organizationId = loggedInUser.organization_id;
+
+    let query = `SELECT name as label,mapped_entity_type as value FROM frm_entity_master WHERE organization_id = ?`;
+    const params = [organizationId];
+
+    if (appcode) {
+      query += ` AND appcode = ?`;
+      params.push(appcode);
+    }
+
+    const dropdown = await this.dataSource.query(query, params);
+    return dropdown;
+  }
+
+  async getCode(entityType: string, loggedInUser: any): Promise<string> {
+    const organizationId = loggedInUser.organization_id;
+
+    // 1. Get db_table_name from entity master
+    const result = await this.dataSource.query(
+      `SELECT db_table_name 
+     FROM frm_entity_master 
+     WHERE mapped_entity_type = ? AND organization_id = ?`,
+      [entityType, organizationId],
+    );
+
+    if (!result.length) {
+      throw new Error(
+        `Entity type '${entityType}' not found in frm_entity_master for org '${organizationId}'`,
+      );
+    }
+
+    const tableName = result[0].db_table_name;
+
+    // 2. Get current max sequence number from that table
+    const seqResult = await this.dataSource.query(
+      `SELECT MAX(CAST(SUBSTRING(code, LENGTH(entity_type) + 1) AS UNSIGNED)) AS max_seq_no
+     FROM \`${tableName}\`
+     WHERE entity_type = ?`,
+      [entityType],
+    );
+
+    let maxSeqNo = seqResult?.[0]?.max_seq_no
+      ? Number(seqResult[0].max_seq_no)
+      : 0;
+
+    maxSeqNo += 1;
+
+    // 3. Return generated code
+    return `${entityType}${maxSeqNo}`;
+  }
+
+  async getResolvedEntity(
+    id: number,
+    entity: string,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    const leadData = await this.getEntityWithRelation(entity, id, loggedInUser);
+
+    const { mappedEntities, ...data } = leadData as any;
+
+    const resolvedData = await this.resolverService.getResolvedData(
+      loggedInUser,
+      data,
+      entity,
+    );
+
+    if (mappedEntities) {
+      resolvedData.mappedEntities = {};
+      for (const [entityType, entities] of Object.entries(mappedEntities)) {
+        if (Array.isArray(entities)) {
+          resolvedData.mappedEntities[entityType] = [];
+          for (const item of entities) {
+            const resolvedItem = await this.resolverService.getResolvedData(
+              loggedInUser,
+              item,
+              entityType,
+            );
+            resolvedData.mappedEntities[entityType].push(resolvedItem);
+          }
+        } else {
+          resolvedData.mappedEntities[entityType] =
+            await this.resolverService.getResolvedData(
+              loggedInUser,
+              entities,
+              entityType,
+            );
+        }
+      }
+    }
+
+    return resolvedData;
+  }
+}