rez_core 6.1.0 → 6.1.2

package/src/module/linked_attributes/service/linked_attributes.service.ts

@@ -1,648 +1,648 @@
-import { Injectable, Inject, BadRequestException, NotFoundException } from '@nestjs/common';
-import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
-import { BaseEntity, DataSource } from 'typeorm';
-import { LinkedAttributes } from '../entity/linked_attribute.entity';
-import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
-import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
-import { SavedFilterService } from 'src/module/filter/service/saved-filter.service';
-import { SavedFilterDetailRepository } from 'src/module/filter/repository/saved.filter-detail.repository';
-import { EntityJSONService } from 'src/module/entity_json/service/entity_json.service';
-import { CreateLinkedAttributeSmartDto } from '../dto/create-linked-attribute-smart.dto';
-import { EntityJson } from 'src/module/entity_json/entity/entityJson.entity';
-import { FilterService } from 'src/module/filter/service/filter.service';
-
-@Injectable()
-export class LinkedAttributesService extends EntityServiceImpl {
-  constructor(
-    private readonly dataSource: DataSource,
-      entityMasterService: EntityMasterService,
-    private readonly attributeMasterService: AttributeMasterService,
-    @Inject('SavedFilterService')
-    private readonly savedFilterService: SavedFilterService,
-    private readonly entityJsonService: EntityJSONService,
-    private readonly filterService: FilterService,
-  ) {
-    super();
-  }
-
-  async createEntity(payload: any, loggedInUser: any): Promise<any> {
-    console.warn(
-      '[DEPRECATED] Use createLinkedAttributeSmart() instead of createEntity()',
-    );
-
-    // Auto-generate attribute_key if missing OR empty
-    if (!payload.attribute_key || payload.attribute_key.trim() === '') {
-      payload.attribute_key = payload.field_name
-        .trim()
-        .toLowerCase()
-        .replace(/\s+/g, '_');
-    }
-
-    // Pass to base class create method
-    return super.createEntity(payload, loggedInUser);
-  }
-
-  async getAllLinkedAttributes(loggedInUser: any) {
-    const entId = loggedInUser.enterprise_id;
-
-    return this.dataSource
-      .getRepository(LinkedAttributes)
-      .createQueryBuilder('fla')
-      .where('fla.enterprise_id = :entId', { entId })
-      .getMany();
-  }
-
-  async upsertLinkedAttributes(payloadList: any[], loggedInUser: any) {
-    const entId = loggedInUser.enterprise_id;
-
-    // Step 1: Delete all existing rows for this organization
-    await this.dataSource
-      .createQueryBuilder()
-      .delete()
-      .from(LinkedAttributes)
-      .where('enterprise_id = :entId', { entId })
-      .execute();
-
-    // Step 2: Normalize & prepare payloads
-    const newPayloads = payloadList.map((item) => ({
-      ...item,
-      enterprise_id: entId,
-      attribute_key: item.attribute_key
-        ? item.attribute_key.trim().toLowerCase().replace(/\s+/g, '_')
-        : item.field_name.trim().toLowerCase().replace(/\s+/g, '_'),
-    }));
-
-    // Step 3: Bulk Insert
-    const insertResult = await this.dataSource
-      .createQueryBuilder()
-      .insert()
-      .into(LinkedAttributes)
-      .values(newPayloads)
-      .execute();
-
-    // Step 4: Return inserted list
-    const ids = insertResult.identifiers.map((i) => i.id);
-
-    return await this.dataSource
-      .getRepository(LinkedAttributes)
-      .createQueryBuilder('la')
-      .where('la.id IN (:...ids)', { ids })
-      .andWhere('la.enterprise_id = :entId', { entId })
-      .getMany();
-  }
-
-  async getEntityListing(entity_type: string, loggedInUser: any) {
-    const entId = loggedInUser.enterprise_id;
-
-    // check if is_flag_json is true for the entity_type
-
-    const entityMasterRepo =
-      this.reflectionHelper.getRepoService('EntityMaster');
-
-    const isFlagJson = await entityMasterRepo.findOne({
-      where: {
-        mapped_entity_type: entity_type,
-        enterprise_id: entId,
-        is_flag_json: true,
-      },
-    });
-
-    if (isFlagJson?.is_flag_json) {
-      // If is_flag_json is true, return getAllLinkedAttributes
-      return await this.getAllLinkedAttributes(loggedInUser);
-    }
-
-    // Otherwise, return filter result
-    return await this.filterService.applyFilterWrapper({
-      entity_type,
-      loggedInUser,
-    });
-  }
-
-  /**
-   * Generate the next sequence number for a linked attribute
-   * @param mapped_entity_type - Main entity type (e.g., "LEAD")
-   * @param applicable_entity_type - Source 1:M entity (e.g., "LFMG")
-   * @param applicable_attribute_key - Source attribute (e.g., "name")
-   * @param organization_id - Organization ID
-   * @returns Next available sequence number
-   */
-  private async generateNextSequence(
-    mapped_entity_type: string,
-    applicable_entity_type: string,
-    applicable_attribute_key: string,
-    organization_id: number,
-  ): Promise<number> {
-    const result = await this.dataSource
-      .getRepository(LinkedAttributes)
-      .createQueryBuilder('fla')
-      .select('MAX(fla.sequence)', 'max_sequence')
-      .where('fla.mapped_entity_type = :mapped_entity_type', {
-        mapped_entity_type,
-      })
-      .andWhere('fla.applicable_entity_type = :applicable_entity_type', {
-        applicable_entity_type,
-      })
-      .andWhere('fla.applicable_attribute_key = :applicable_attribute_key', {
-        applicable_attribute_key,
-      })
-      .andWhere('fla.organization_id = :organization_id', { organization_id })
-      .getRawOne();
-
-    const maxSequence = result?.max_sequence;
-
-    // If no records exist or max is null, return 1; otherwise return max + 1
-    return maxSequence ? maxSequence + 1 : 1;
-  }
-
-  /**
-   * Generate a flatjson attribute key in format: ENTITY__attribute__N
-   * @param applicable_entity_type - Entity code (e.g., "LFMG")
-   * @param applicable_attribute_key - Attribute key (e.g., "name")
-   * @param sequence - Sequence number (e.g., 1)
-   * @returns Generated key (e.g., "LFMG__name__1")
-   * @example generateAttributeKey('LFMG', 'name', 1) => 'LFMG__name__1'
-   */
-  public generateAttributeKey(
-    applicable_entity_type: string,
-    applicable_attribute_key: string,
-    sequence: number,
-  ): string {
-    // Validate inputs
-    if (!applicable_entity_type || applicable_entity_type.trim() === '') {
-      throw new Error('applicable_entity_type is required and cannot be empty');
-    }
-
-    if (!applicable_attribute_key || applicable_attribute_key.trim() === '') {
-      throw new Error(
-        'applicable_attribute_key is required and cannot be empty',
-      );
-    }
-
-    if (!sequence || sequence < 1 || !Number.isInteger(sequence)) {
-      throw new Error('sequence must be a positive integer greater than 0');
-    }
-
-    // Generate and return formatted key
-    return `${applicable_entity_type}__${applicable_attribute_key}__${sequence}`;
-  }
-
-  /**
-   * Create a SavedFilter for a linked attribute
-   * @param entity_type - Entity type to filter (e.g., "LFMG")
-   * @param conditions - Array of filter conditions
-   * @param attribute_key - Linked attribute key (for naming)
-   * @param loggedInUser - Current user context
-   * @returns Generated filter code
-   */
-  private async createFilterForLinkedAttribute(
-    entity_type: string,
-    conditions: Array<{
-      filter_attribute: string;
-      filter_operator: string;
-      filter_value: any;
-    }>,
-    attribute_key: string,
-    loggedInUser: any,
-  ): Promise<string> {
-    return await this.dataSource.transaction(async (transactionManager) => {
-      // Step 1: Generate unique filter code
-      const timestamp = Date.now();
-      const filterCode = `LA_${entity_type}_${attribute_key}_${timestamp}`;
-
-      // Step 2: Create SavedFilterMaster
-      const filterMasterData = {
-        name: `Auto Filter - ${attribute_key}`,
-        code: filterCode,
-        mapped_entity_type: entity_type,
-        filter_scope: 'FILTER' as const,
-        organization_id: loggedInUser.organization_id,
-        level_type: loggedInUser.level_type,
-        level_id: loggedInUser.level_id,
-        user_id: loggedInUser.id,
-      };
-
-      const filterMaster = await this.savedFilterService.createEntity(
-        filterMasterData,
-        loggedInUser,
-      );
-
-      // Step 3: Create SavedFilterDetail records
-      const detailPromises = conditions.map((condition) => {
-        const detailData = {
-          mapped_filter_code: filterMaster.code,
-          filter_entity_type: entity_type,
-          filter_attribute: condition.filter_attribute,
-          filter_operator: condition.filter_operator,
-          filter_value: String(condition.filter_value),
-          organization_id: loggedInUser.organization_id,
-          level_type: loggedInUser.level_type,
-          level_id: loggedInUser.level_id,
-        };
-
-        return transactionManager.save('SavedFilterDetail', detailData);
-      });
-
-      await Promise.all(detailPromises);
-
-      // Step 4: Return the generated filter code
-      return filterMaster.code;
-    });
-  }
-
-  /**
-   * Smart creation of linked attribute with auto-generation
-   * @param payload - Linked attribute data
-   * @param loggedInUser - Current user context
-   * @returns Created LinkedAttribute entity
-   */
-  async createLinkedAttributeSmart(
-    payload: CreateLinkedAttributeSmartDto,
-    loggedInUser: any,
-  ): Promise<LinkedAttributes> {
-    // Step 1: Validate input
-    const validation = await this.validateLinkedAttribute(
-      {
-        field_name: payload.field_name,
-        mapped_entity_type: payload.mapped_entity_type,
-        applicable_entity_type: payload.applicable_entity_type,
-        applicable_attribute_key: payload.applicable_attribute_key,
-        organization_id: loggedInUser.organization_id,
-      },
-      loggedInUser,
-    );
-
-    if (!validation.valid) {
-      throw new BadRequestException(validation.errors.join(', '));
-    }
-
-    // Step 2: Generate sequence number
-    const sequence = await this.generateNextSequence(
-      payload.mapped_entity_type,
-      payload.applicable_entity_type,
-      payload.applicable_attribute_key,
-      loggedInUser.organization_id,
-    );
-
-    // Step 3: Generate attribute_key
-    const attribute_key = this.generateAttributeKey(
-      payload.applicable_entity_type,
-      payload.applicable_attribute_key,
-      sequence,
-    );
-
-    // Step 4: Create saved filter if conditions provided
-    let saved_filter_code: string | null = payload.saved_filter_code || null;
-    // if (payload.filter_conditions && payload.filter_conditions.length > 0) {
-    //   saved_filter_code = await this.createFilterForLinkedAttribute(
-    //     payload.applicable_entity_type,
-    //     payload.filter_conditions,
-    //     attribute_key,
-    //     loggedInUser,
-    //   );
-    // }
-
-    // Step 5: Create LinkedAttribute entity
-    let linkedAttrData:any  = {
-      field_name: payload.field_name,
-      attribute_key,
-      applicable_entity_type: payload.applicable_entity_type,
-      applicable_attribute_key: payload.applicable_attribute_key,
-      mapped_entity_type: payload.mapped_entity_type,
-      saved_filter_code,
-      sequence,
-      organization_id: loggedInUser.organization_id,
-      level_type: loggedInUser.level_type,
-      level_id: loggedInUser.level_id,
-      entity_type:'LNATR'
-    };
-
-    const linkedAttribute = (await super.createEntity(
-      linkedAttrData,
-      loggedInUser,
-    )) as LinkedAttributes;
-
-    // Step 6: Trigger backfill if requested (async, don't await)
-    if (payload.backfill) {
-      this.backfillLinkedAttribute(linkedAttribute.id, loggedInUser).catch(
-        (err) =>
-          console.error(
-            `Backfill failed for linked attribute ${linkedAttribute.id}:`,
-            err,
-          ),
-      );
-    }
-
-    return linkedAttribute;
-  }
-
-  /**
-   * Validate linked attribute payload before creation
-   * @param payload - Linked attribute data to validate
-   * @param loggedInUser - Current user context
-   * @returns Validation result with errors array
-   */
-  async validateLinkedAttribute(
-    payload: {
-      field_name: string;
-      mapped_entity_type: string;
-      applicable_entity_type: string;
-      applicable_attribute_key: string;
-      attribute_key?: string;
-      organization_id: number;
-    },
-    loggedInUser: any,
-  ): Promise<{ valid: boolean; errors: string[] }> {
-    const errors: string[] = [];
-
-    // Run all validations in parallel
-    const [
-      duplicateError,
-      mappedEntityError,
-      applicableEntityError,
-      attributeError,
-    ] = await Promise.all([
-      this.checkDuplicateAttributeKey(
-        payload.attribute_key,
-        payload.organization_id,
-      ),
-      this.validateEntityTypeExists(
-        payload.mapped_entity_type,
-        loggedInUser,
-      ),
-      this.validateEntityTypeExists(
-        payload.applicable_entity_type,
-        loggedInUser,
-      ),
-      this.validateAttributeKeyExists(
-        payload.applicable_entity_type,
-        payload.applicable_attribute_key,
-        loggedInUser,
-      ),
-    ]);
-
-    // Collect errors
-    if (duplicateError) errors.push(duplicateError);
-    if (mappedEntityError) errors.push(mappedEntityError);
-    if (applicableEntityError) errors.push(applicableEntityError);
-    if (attributeError) errors.push(attributeError);
-
-    // Validate required fields
-    this.validateRequiredFields(payload, errors);
-
-    return { valid: errors.length === 0, errors };
-  }
-
-  /**
-   * Validate that all required fields are present and not empty
-   * @param payload - Payload to validate
-   * @param errors - Array to collect error messages
-   */
-  private validateRequiredFields(
-    payload: {
-      field_name: string;
-      mapped_entity_type: string;
-      applicable_entity_type: string;
-      applicable_attribute_key: string;
-    },
-    errors: string[],
-  ): void {
-    const requiredFields = [
-      { field: 'field_name', value: payload.field_name },
-      { field: 'mapped_entity_type', value: payload.mapped_entity_type },
-      { field: 'applicable_entity_type', value: payload.applicable_entity_type },
-      { field: 'applicable_attribute_key', value: payload.applicable_attribute_key },
-    ];
-
-    for (const { field, value } of requiredFields) {
-      if (!value || (typeof value === 'string' && value.trim() === '')) {
-        errors.push(`Required field '${field}' is missing or empty`);
-      }
-    }
-  }
-
-  /**
-   * Check if attribute_key already exists for the organization
-   * @param attribute_key - Attribute key to check
-   * @param organization_id - Organization ID
-   * @returns Error message if duplicate exists, null otherwise
-   */
-  private async checkDuplicateAttributeKey(
-    attribute_key: string | undefined,
-    organization_id: number,
-  ): Promise<string | null> {
-    // Skip check if attribute_key is not provided (will be auto-generated)
-    if (!attribute_key || attribute_key.trim() === '') {
-      return null;
-    }
-
-    const existing = await this.dataSource
-      .getRepository(LinkedAttributes)
-      .createQueryBuilder('fla')
-      .where('fla.attribute_key = :attribute_key', { attribute_key })
-      .andWhere('fla.organization_id = :organization_id', { organization_id })
-      .getOne();
-
-    if (existing) {
-      return `Attribute key '${attribute_key}' already exists for this organization`;
-    }
-
-    return null;
-  }
-
-  /**
-   * Validate that entity type exists in frm_entity_master
-   * @param entity_type - Entity type to validate
-   * @param loggedInUser - Current user context
-   * @returns Error message if entity doesn't exist, null otherwise
-   */
-  private async validateEntityTypeExists(
-    entity_type: string,
-    loggedInUser: any,
-  ): Promise<string | null> {
-    if (!entity_type || entity_type.trim() === '') {
-      return null; // Will be caught by required field validation
-    }
-
-    try {
-      await this.entityMasterService.getEntityData(entity_type, loggedInUser);
-      return null; // Entity exists
-    } catch (error) {
-      return `Entity type '${entity_type}' does not exist`;
-    }
-  }
-
-  /**
-   * Validate that attribute exists in frm_attribute_master for the given entity
-   * @param entity_type - Entity type
-   * @param attribute_key - Attribute key to validate
-   * @param loggedInUser - Current user context
-   * @returns Error message if attribute doesn't exist, null otherwise
-   */
-  private async validateAttributeKeyExists(
-    entity_type: string,
-    attribute_key: string,
-    loggedInUser: any,
-  ): Promise<string | null> {
-    if (!entity_type || !attribute_key) {
-      return null; // Will be caught by required field validation
-    }
-
-    try {
-      const attributes =
-        await this.attributeMasterService.findAttributesByMappedEntityType(
-          entity_type,
-          loggedInUser,
-        );
-
-      const attributeExists = attributes.some(
-        (attr) => attr.attribute_key === attribute_key,
-      );
-
-      if (!attributeExists) {
-        return `Attribute '${attribute_key}' does not exist in entity '${entity_type}'`;
-      }
-
-      return null;
-    } catch (error) {
-      return `Error validating attribute '${attribute_key}' in entity '${entity_type}': ${error.message}`;
-    }
-  }
-
-  /**
-   * Backfill existing entities with a new linked attribute
-   * @param linked_attribute_id - ID of the linked attribute to backfill
-   * @param loggedInUser - Current user context
-   * @returns Summary of backfill operation
-   */
-  async backfillLinkedAttribute(
-    linked_attribute_id: number,
-    loggedInUser: any,
-  ): Promise<{
-    total: number;
-    updated: number;
-    failed: number;
-    errors: Array<{ entity_id: number; error: string }>;
-  }> {
-    // Step 1: Load linked attribute
-    const linkedAttr = await this.dataSource
-      .getRepository(LinkedAttributes)
-      .findOne({ where: { id: linked_attribute_id } });
-
-    if (!linkedAttr) {
-      throw new NotFoundException(
-        `LinkedAttribute with ID ${linked_attribute_id} not found`,
-      );
-    }
-
-    // Step 2: Get all entities of this type
-    const entityJsonRecords = await this.dataSource
-      .getRepository(EntityJson)
-      .createQueryBuilder('ej')
-      .select(['ej.entity_id'])
-      .where('ej.entity_type = :entityType', {
-        entityType: linkedAttr.mapped_entity_type,
-      })
-      .andWhere('ej.organization_id = :orgId', {
-        orgId: loggedInUser.organization_id,
-      })
-      .getMany();
-
-    // Step 3: Process in batches
-    const batchSize = 100;
-    const results = {
-      total: entityJsonRecords.length,
-      updated: 0,
-      failed: 0,
-      errors: [] as Array<{ entity_id: number; error: string }>,
-    };
-
-    for (let i = 0; i < entityJsonRecords.length; i += batchSize) {
-      const batch = entityJsonRecords.slice(i, i + batchSize);
-
-      for (const record of batch) {
-        try {
-          await this.entityJsonService.updateEntityJSON(
-            linkedAttr.mapped_entity_type,
-            record.entity_id,
-            loggedInUser,
-          );
-          results.updated++;
-        } catch (error) {
-          results.failed++;
-          results.errors.push({
-            entity_id: record.entity_id,
-            error: error.message,
-          });
-          console.error(
-            `Failed to update entity ${record.entity_id}:`,
-            error,
-          );
-        }
-      }
-
-      // Log progress
-      console.log(
-        `Backfill progress: ${Math.min(i + batchSize, results.total)}/${results.total}`,
-      );
-    }
-
-    return results;
-  }
-
-  /**
-   * Backfill all linked attributes for an entity type
-   * @param mapped_entity_type - Entity type to backfill
-   * @param loggedInUser - Current user context
-   * @returns Summary of backfill operation
-   */
-  async backfillAllForEntity(
-    mapped_entity_type: string,
-    loggedInUser: any,
-  ): Promise<{ updated: number; failed: number }> {
-    // Get all entities of this type
-    const entityJsonRecords = await this.dataSource
-      .getRepository(EntityJson)
-      .createQueryBuilder('ej')
-      .select(['ej.entity_id'])
-      .where('ej.entity_type = :entityType', { entityType: mapped_entity_type })
-      .andWhere('ej.organization_id = :orgId', {
-        orgId: loggedInUser.organization_id,
-      })
-      .getMany();
-
-    const batchSize = 100;
-    const results = {
-      updated: 0,
-      failed: 0,
-    };
-
-    for (let i = 0; i < entityJsonRecords.length; i += batchSize) {
-      const batch = entityJsonRecords.slice(i, i + batchSize);
-
-      for (const record of batch) {
-        try {
-          await this.entityJsonService.updateEntityJSON(
-            mapped_entity_type,
-            record.entity_id,
-            loggedInUser,
-          );
-          results.updated++;
-        } catch (error) {
-          results.failed++;
-          console.error(
-            `Failed to update entity ${record.entity_id}:`,
-            error,
-          );
-        }
-      }
-
-      // Log progress
-      console.log(
-        `Backfill all progress: ${Math.min(i + batchSize, entityJsonRecords.length)}/${entityJsonRecords.length}`,
-      );
-    }
-
-    return results;
-  }
-}
+import { Injectable, Inject, BadRequestException, NotFoundException } from '@nestjs/common';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { BaseEntity, DataSource } from 'typeorm';
+import { LinkedAttributes } from '../entity/linked_attribute.entity';
+import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
+import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
+import { SavedFilterService } from 'src/module/filter/service/saved-filter.service';
+import { SavedFilterDetailRepository } from 'src/module/filter/repository/saved.filter-detail.repository';
+import { EntityJSONService } from 'src/module/entity_json/service/entity_json.service';
+import { CreateLinkedAttributeSmartDto } from '../dto/create-linked-attribute-smart.dto';
+import { EntityJson } from 'src/module/entity_json/entity/entityJson.entity';
+import { FilterService } from 'src/module/filter/service/filter.service';
+
+@Injectable()
+export class LinkedAttributesService extends EntityServiceImpl {
+  constructor(
+    private readonly dataSource: DataSource,
+      entityMasterService: EntityMasterService,
+    private readonly attributeMasterService: AttributeMasterService,
+    @Inject('SavedFilterService')
+    private readonly savedFilterService: SavedFilterService,
+    private readonly entityJsonService: EntityJSONService,
+    private readonly filterService: FilterService,
+  ) {
+    super();
+  }
+
+  async createEntity(payload: any, loggedInUser: any): Promise<any> {
+    console.warn(
+      '[DEPRECATED] Use createLinkedAttributeSmart() instead of createEntity()',
+    );
+
+    // Auto-generate attribute_key if missing OR empty
+    if (!payload.attribute_key || payload.attribute_key.trim() === '') {
+      payload.attribute_key = payload.field_name
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, '_');
+    }
+
+    // Pass to base class create method
+    return super.createEntity(payload, loggedInUser);
+  }
+
+  async getAllLinkedAttributes(loggedInUser: any) {
+    const entId = loggedInUser.enterprise_id;
+
+    return this.dataSource
+      .getRepository(LinkedAttributes)
+      .createQueryBuilder('fla')
+      .where('fla.enterprise_id = :entId', { entId })
+      .getMany();
+  }
+
+  async upsertLinkedAttributes(payloadList: any[], loggedInUser: any) {
+    const entId = loggedInUser.enterprise_id;
+
+    // Step 1: Delete all existing rows for this organization
+    await this.dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(LinkedAttributes)
+      .where('enterprise_id = :entId', { entId })
+      .execute();
+
+    // Step 2: Normalize & prepare payloads
+    const newPayloads = payloadList.map((item) => ({
+      ...item,
+      enterprise_id: entId,
+      attribute_key: item.attribute_key
+        ? item.attribute_key.trim().toLowerCase().replace(/\s+/g, '_')
+        : item.field_name.trim().toLowerCase().replace(/\s+/g, '_'),
+    }));
+
+    // Step 3: Bulk Insert
+    const insertResult = await this.dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(LinkedAttributes)
+      .values(newPayloads)
+      .execute();
+
+    // Step 4: Return inserted list
+    const ids = insertResult.identifiers.map((i) => i.id);
+
+    return await this.dataSource
+      .getRepository(LinkedAttributes)
+      .createQueryBuilder('la')
+      .where('la.id IN (:...ids)', { ids })
+      .andWhere('la.enterprise_id = :entId', { entId })
+      .getMany();
+  }
+
+  async getEntityListing(entity_type: string, loggedInUser: any) {
+    const entId = loggedInUser.enterprise_id;
+
+    // check if is_flag_json is true for the entity_type
+
+    const entityMasterRepo =
+      this.reflectionHelper.getRepoService('EntityMaster');
+
+    const isFlagJson = await entityMasterRepo.findOne({
+      where: {
+        mapped_entity_type: entity_type,
+        enterprise_id: entId,
+        is_flag_json: true,
+      },
+    });
+
+    if (isFlagJson?.is_flag_json) {
+      // If is_flag_json is true, return getAllLinkedAttributes
+      return await this.getAllLinkedAttributes(loggedInUser);
+    }
+
+    // Otherwise, return filter result
+    return await this.filterService.applyFilterWrapper({
+      entity_type,
+      loggedInUser,
+    });
+  }
+
+  /**
+   * Generate the next sequence number for a linked attribute
+   * @param mapped_entity_type - Main entity type (e.g., "LEAD")
+   * @param applicable_entity_type - Source 1:M entity (e.g., "LFMG")
+   * @param applicable_attribute_key - Source attribute (e.g., "name")
+   * @param organization_id - Organization ID
+   * @returns Next available sequence number
+   */
+  private async generateNextSequence(
+    mapped_entity_type: string,
+    applicable_entity_type: string,
+    applicable_attribute_key: string,
+    organization_id: number,
+  ): Promise<number> {
+    const result = await this.dataSource
+      .getRepository(LinkedAttributes)
+      .createQueryBuilder('fla')
+      .select('MAX(fla.sequence)', 'max_sequence')
+      .where('fla.mapped_entity_type = :mapped_entity_type', {
+        mapped_entity_type,
+      })
+      .andWhere('fla.applicable_entity_type = :applicable_entity_type', {
+        applicable_entity_type,
+      })
+      .andWhere('fla.applicable_attribute_key = :applicable_attribute_key', {
+        applicable_attribute_key,
+      })
+      .andWhere('fla.organization_id = :organization_id', { organization_id })
+      .getRawOne();
+
+    const maxSequence = result?.max_sequence;
+
+    // If no records exist or max is null, return 1; otherwise return max + 1
+    return maxSequence ? maxSequence + 1 : 1;
+  }
+
+  /**
+   * Generate a flatjson attribute key in format: ENTITY__attribute__N
+   * @param applicable_entity_type - Entity code (e.g., "LFMG")
+   * @param applicable_attribute_key - Attribute key (e.g., "name")
+   * @param sequence - Sequence number (e.g., 1)
+   * @returns Generated key (e.g., "LFMG__name__1")
+   * @example generateAttributeKey('LFMG', 'name', 1) => 'LFMG__name__1'
+   */
+  public generateAttributeKey(
+    applicable_entity_type: string,
+    applicable_attribute_key: string,
+    sequence: number,
+  ): string {
+    // Validate inputs
+    if (!applicable_entity_type || applicable_entity_type.trim() === '') {
+      throw new Error('applicable_entity_type is required and cannot be empty');
+    }
+
+    if (!applicable_attribute_key || applicable_attribute_key.trim() === '') {
+      throw new Error(
+        'applicable_attribute_key is required and cannot be empty',
+      );
+    }
+
+    if (!sequence || sequence < 1 || !Number.isInteger(sequence)) {
+      throw new Error('sequence must be a positive integer greater than 0');
+    }
+
+    // Generate and return formatted key
+    return `${applicable_entity_type}__${applicable_attribute_key}__${sequence}`;
+  }
+
+  /**
+   * Create a SavedFilter for a linked attribute
+   * @param entity_type - Entity type to filter (e.g., "LFMG")
+   * @param conditions - Array of filter conditions
+   * @param attribute_key - Linked attribute key (for naming)
+   * @param loggedInUser - Current user context
+   * @returns Generated filter code
+   */
+  private async createFilterForLinkedAttribute(
+    entity_type: string,
+    conditions: Array<{
+      filter_attribute: string;
+      filter_operator: string;
+      filter_value: any;
+    }>,
+    attribute_key: string,
+    loggedInUser: any,
+  ): Promise<string> {
+    return await this.dataSource.transaction(async (transactionManager) => {
+      // Step 1: Generate unique filter code
+      const timestamp = Date.now();
+      const filterCode = `LA_${entity_type}_${attribute_key}_${timestamp}`;
+
+      // Step 2: Create SavedFilterMaster
+      const filterMasterData = {
+        name: `Auto Filter - ${attribute_key}`,
+        code: filterCode,
+        mapped_entity_type: entity_type,
+        filter_scope: 'FILTER' as const,
+        organization_id: loggedInUser.organization_id,
+        level_type: loggedInUser.level_type,
+        level_id: loggedInUser.level_id,
+        user_id: loggedInUser.id,
+      };
+
+      const filterMaster = await this.savedFilterService.createEntity(
+        filterMasterData,
+        loggedInUser,
+      );
+
+      // Step 3: Create SavedFilterDetail records
+      const detailPromises = conditions.map((condition) => {
+        const detailData = {
+          mapped_filter_code: filterMaster.code,
+          filter_entity_type: entity_type,
+          filter_attribute: condition.filter_attribute,
+          filter_operator: condition.filter_operator,
+          filter_value: String(condition.filter_value),
+          organization_id: loggedInUser.organization_id,
+          level_type: loggedInUser.level_type,
+          level_id: loggedInUser.level_id,
+        };
+
+        return transactionManager.save('SavedFilterDetail', detailData);
+      });
+
+      await Promise.all(detailPromises);
+
+      // Step 4: Return the generated filter code
+      return filterMaster.code;
+    });
+  }
+
+  /**
+   * Smart creation of linked attribute with auto-generation
+   * @param payload - Linked attribute data
+   * @param loggedInUser - Current user context
+   * @returns Created LinkedAttribute entity
+   */
+  async createLinkedAttributeSmart(
+    payload: CreateLinkedAttributeSmartDto,
+    loggedInUser: any,
+  ): Promise<LinkedAttributes> {
+    // Step 1: Validate input
+    const validation = await this.validateLinkedAttribute(
+      {
+        field_name: payload.field_name,
+        mapped_entity_type: payload.mapped_entity_type,
+        applicable_entity_type: payload.applicable_entity_type,
+        applicable_attribute_key: payload.applicable_attribute_key,
+        organization_id: loggedInUser.organization_id,
+      },
+      loggedInUser,
+    );
+
+    if (!validation.valid) {
+      throw new BadRequestException(validation.errors.join(', '));
+    }
+
+    // Step 2: Generate sequence number
+    const sequence = await this.generateNextSequence(
+      payload.mapped_entity_type,
+      payload.applicable_entity_type,
+      payload.applicable_attribute_key,
+      loggedInUser.organization_id,
+    );
+
+    // Step 3: Generate attribute_key
+    const attribute_key = this.generateAttributeKey(
+      payload.applicable_entity_type,
+      payload.applicable_attribute_key,
+      sequence,
+    );
+
+    // Step 4: Create saved filter if conditions provided
+    let saved_filter_code: string | null = payload.saved_filter_code || null;
+    // if (payload.filter_conditions && payload.filter_conditions.length > 0) {
+    //   saved_filter_code = await this.createFilterForLinkedAttribute(
+    //     payload.applicable_entity_type,
+    //     payload.filter_conditions,
+    //     attribute_key,
+    //     loggedInUser,
+    //   );
+    // }
+
+    // Step 5: Create LinkedAttribute entity
+    let linkedAttrData:any  = {
+      field_name: payload.field_name,
+      attribute_key,
+      applicable_entity_type: payload.applicable_entity_type,
+      applicable_attribute_key: payload.applicable_attribute_key,
+      mapped_entity_type: payload.mapped_entity_type,
+      saved_filter_code,
+      sequence,
+      organization_id: loggedInUser.organization_id,
+      level_type: loggedInUser.level_type,
+      level_id: loggedInUser.level_id,
+      entity_type:'LNATR'
+    };
+
+    const linkedAttribute = (await super.createEntity(
+      linkedAttrData,
+      loggedInUser,
+    )) as LinkedAttributes;
+
+    // Step 6: Trigger backfill if requested (async, don't await)
+    if (payload.backfill) {
+      this.backfillLinkedAttribute(linkedAttribute.id, loggedInUser).catch(
+        (err) =>
+          console.error(
+            `Backfill failed for linked attribute ${linkedAttribute.id}:`,
+            err,
+          ),
+      );
+    }
+
+    return linkedAttribute;
+  }
+
+  /**
+   * Validate linked attribute payload before creation
+   * @param payload - Linked attribute data to validate
+   * @param loggedInUser - Current user context
+   * @returns Validation result with errors array
+   */
+  async validateLinkedAttribute(
+    payload: {
+      field_name: string;
+      mapped_entity_type: string;
+      applicable_entity_type: string;
+      applicable_attribute_key: string;
+      attribute_key?: string;
+      organization_id: number;
+    },
+    loggedInUser: any,
+  ): Promise<{ valid: boolean; errors: string[] }> {
+    const errors: string[] = [];
+
+    // Run all validations in parallel
+    const [
+      duplicateError,
+      mappedEntityError,
+      applicableEntityError,
+      attributeError,
+    ] = await Promise.all([
+      this.checkDuplicateAttributeKey(
+        payload.attribute_key,
+        payload.organization_id,
+      ),
+      this.validateEntityTypeExists(
+        payload.mapped_entity_type,
+        loggedInUser,
+      ),
+      this.validateEntityTypeExists(
+        payload.applicable_entity_type,
+        loggedInUser,
+      ),
+      this.validateAttributeKeyExists(
+        payload.applicable_entity_type,
+        payload.applicable_attribute_key,
+        loggedInUser,
+      ),
+    ]);
+
+    // Collect errors
+    if (duplicateError) errors.push(duplicateError);
+    if (mappedEntityError) errors.push(mappedEntityError);
+    if (applicableEntityError) errors.push(applicableEntityError);
+    if (attributeError) errors.push(attributeError);
+
+    // Validate required fields
+    this.validateRequiredFields(payload, errors);
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  /**
+   * Validate that all required fields are present and not empty
+   * @param payload - Payload to validate
+   * @param errors - Array to collect error messages
+   */
+  private validateRequiredFields(
+    payload: {
+      field_name: string;
+      mapped_entity_type: string;
+      applicable_entity_type: string;
+      applicable_attribute_key: string;
+    },
+    errors: string[],
+  ): void {
+    const requiredFields = [
+      { field: 'field_name', value: payload.field_name },
+      { field: 'mapped_entity_type', value: payload.mapped_entity_type },
+      { field: 'applicable_entity_type', value: payload.applicable_entity_type },
+      { field: 'applicable_attribute_key', value: payload.applicable_attribute_key },
+    ];
+
+    for (const { field, value } of requiredFields) {
+      if (!value || (typeof value === 'string' && value.trim() === '')) {
+        errors.push(`Required field '${field}' is missing or empty`);
+      }
+    }
+  }
+
+  /**
+   * Check if attribute_key already exists for the organization
+   * @param attribute_key - Attribute key to check
+   * @param organization_id - Organization ID
+   * @returns Error message if duplicate exists, null otherwise
+   */
+  private async checkDuplicateAttributeKey(
+    attribute_key: string | undefined,
+    organization_id: number,
+  ): Promise<string | null> {
+    // Skip check if attribute_key is not provided (will be auto-generated)
+    if (!attribute_key || attribute_key.trim() === '') {
+      return null;
+    }
+
+    const existing = await this.dataSource
+      .getRepository(LinkedAttributes)
+      .createQueryBuilder('fla')
+      .where('fla.attribute_key = :attribute_key', { attribute_key })
+      .andWhere('fla.organization_id = :organization_id', { organization_id })
+      .getOne();
+
+    if (existing) {
+      return `Attribute key '${attribute_key}' already exists for this organization`;
+    }
+
+    return null;
+  }
+
+  /**
+   * Validate that entity type exists in frm_entity_master
+   * @param entity_type - Entity type to validate
+   * @param loggedInUser - Current user context
+   * @returns Error message if entity doesn't exist, null otherwise
+   */
+  private async validateEntityTypeExists(
+    entity_type: string,
+    loggedInUser: any,
+  ): Promise<string | null> {
+    if (!entity_type || entity_type.trim() === '') {
+      return null; // Will be caught by required field validation
+    }
+
+    try {
+      await this.entityMasterService.getEntityData(entity_type, loggedInUser);
+      return null; // Entity exists
+    } catch (error) {
+      return `Entity type '${entity_type}' does not exist`;
+    }
+  }
+
+  /**
+   * Validate that attribute exists in frm_attribute_master for the given entity
+   * @param entity_type - Entity type
+   * @param attribute_key - Attribute key to validate
+   * @param loggedInUser - Current user context
+   * @returns Error message if attribute doesn't exist, null otherwise
+   */
+  private async validateAttributeKeyExists(
+    entity_type: string,
+    attribute_key: string,
+    loggedInUser: any,
+  ): Promise<string | null> {
+    if (!entity_type || !attribute_key) {
+      return null; // Will be caught by required field validation
+    }
+
+    try {
+      const attributes =
+        await this.attributeMasterService.findAttributesByMappedEntityType(
+          entity_type,
+          loggedInUser,
+        );
+
+      const attributeExists = attributes.some(
+        (attr) => attr.attribute_key === attribute_key,
+      );
+
+      if (!attributeExists) {
+        return `Attribute '${attribute_key}' does not exist in entity '${entity_type}'`;
+      }
+
+      return null;
+    } catch (error) {
+      return `Error validating attribute '${attribute_key}' in entity '${entity_type}': ${error.message}`;
+    }
+  }
+
+  /**
+   * Backfill existing entities with a new linked attribute
+   * @param linked_attribute_id - ID of the linked attribute to backfill
+   * @param loggedInUser - Current user context
+   * @returns Summary of backfill operation
+   */
+  async backfillLinkedAttribute(
+    linked_attribute_id: number,
+    loggedInUser: any,
+  ): Promise<{
+    total: number;
+    updated: number;
+    failed: number;
+    errors: Array<{ entity_id: number; error: string }>;
+  }> {
+    // Step 1: Load linked attribute
+    const linkedAttr = await this.dataSource
+      .getRepository(LinkedAttributes)
+      .findOne({ where: { id: linked_attribute_id } });
+
+    if (!linkedAttr) {
+      throw new NotFoundException(
+        `LinkedAttribute with ID ${linked_attribute_id} not found`,
+      );
+    }
+
+    // Step 2: Get all entities of this type
+    const entityJsonRecords = await this.dataSource
+      .getRepository(EntityJson)
+      .createQueryBuilder('ej')
+      .select(['ej.entity_id'])
+      .where('ej.entity_type = :entityType', {
+        entityType: linkedAttr.mapped_entity_type,
+      })
+      .andWhere('ej.organization_id = :orgId', {
+        orgId: loggedInUser.organization_id,
+      })
+      .getMany();
+
+    // Step 3: Process in batches
+    const batchSize = 100;
+    const results = {
+      total: entityJsonRecords.length,
+      updated: 0,
+      failed: 0,
+      errors: [] as Array<{ entity_id: number; error: string }>,
+    };
+
+    for (let i = 0; i < entityJsonRecords.length; i += batchSize) {
+      const batch = entityJsonRecords.slice(i, i + batchSize);
+
+      for (const record of batch) {
+        try {
+          await this.entityJsonService.updateEntityJSON(
+            linkedAttr.mapped_entity_type,
+            record.entity_id,
+            loggedInUser,
+          );
+          results.updated++;
+        } catch (error) {
+          results.failed++;
+          results.errors.push({
+            entity_id: record.entity_id,
+            error: error.message,
+          });
+          console.error(
+            `Failed to update entity ${record.entity_id}:`,
+            error,
+          );
+        }
+      }
+
+      // Log progress
+      console.log(
+        `Backfill progress: ${Math.min(i + batchSize, results.total)}/${results.total}`,
+      );
+    }
+
+    return results;
+  }
+
+  /**
+   * Backfill all linked attributes for an entity type
+   * @param mapped_entity_type - Entity type to backfill
+   * @param loggedInUser - Current user context
+   * @returns Summary of backfill operation
+   */
+  async backfillAllForEntity(
+    mapped_entity_type: string,
+    loggedInUser: any,
+  ): Promise<{ updated: number; failed: number }> {
+    // Get all entities of this type
+    const entityJsonRecords = await this.dataSource
+      .getRepository(EntityJson)
+      .createQueryBuilder('ej')
+      .select(['ej.entity_id'])
+      .where('ej.entity_type = :entityType', { entityType: mapped_entity_type })
+      .andWhere('ej.organization_id = :orgId', {
+        orgId: loggedInUser.organization_id,
+      })
+      .getMany();
+
+    const batchSize = 100;
+    const results = {
+      updated: 0,
+      failed: 0,
+    };
+
+    for (let i = 0; i < entityJsonRecords.length; i += batchSize) {
+      const batch = entityJsonRecords.slice(i, i + batchSize);
+
+      for (const record of batch) {
+        try {
+          await this.entityJsonService.updateEntityJSON(
+            mapped_entity_type,
+            record.entity_id,
+            loggedInUser,
+          );
+          results.updated++;
+        } catch (error) {
+          results.failed++;
+          console.error(
+            `Failed to update entity ${record.entity_id}:`,
+            error,
+          );
+        }
+      }
+
+      // Log progress
+      console.log(
+        `Backfill all progress: ${Math.min(i + batchSize, entityJsonRecords.length)}/${entityJsonRecords.length}`,
+      );
+    }
+
+    return results;
+  }
+}