rez_core 7.1.1 → 7.1.3

package/src/module/listmaster/service/list-master.service.ts

@@ -1,774 +1,760 @@
-import { BadRequestException, forwardRef, Inject, Injectable, NotFoundException } from '@nestjs/common';
-import { ListMasterItemsRepository } from '../repository/list-master-items.repository';
-import { ListMasterRepository } from '../repository/list-master.repository';
-import { EntityManager } from 'typeorm';
-import { UserData } from 'src/module/auth/dto/user.dto';
-import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
-import { STATUS_ACTIVE } from 'src/constant/global.constant';
-import { Action } from '../../workflow-automation/interface/action.interface';
-import axios from 'axios';
-import { ConfigService } from '@nestjs/config';
-import { AttributeMasterService } from '../../meta/service/attribute-master.service';
-import { IMicroserviceClients } from '../../microservice-client/service/microservice-clients';
-
-@Injectable()
-export class ListMasterService extends EntityServiceImpl {
-  constructor(
-    private readonly entityManager: EntityManager,
-    @Inject(forwardRef(() => EntityServiceImpl))
-    private readonly entityServiceImpl: EntityServiceImpl,
-    private readonly listMasterRepo: ListMasterRepository,
-    private readonly listItemsRepo: ListMasterItemsRepository,
-    private readonly configService: ConfigService,
-    @Inject('AttributeMasterService')
-    private readonly attributeMasterService: AttributeMasterService,
-    @Inject('MICROSERVICE_CLIENT_FACTORY')
-    private readonly factory: IMicroserviceClients,
-  ) {
-    super();
-  }
-
-  schema = this.configService.get('DB_SCHEMA');
-  private readonly skipLevelFilterEntities = ['BRN', 'USR', 'UPR', 'BRNP'];
-  private readonly actions = new Map<string, Action>();
-
-  registerAction(actionName: string, actionInstance: Action) {
-    this.actions.set(actionName, actionInstance);
-    console.log(
-      `⚙️ [WorkflowAutomationEngine] Registered action: ${actionName}`,
-    );
-  }
-
-  async getResolvedListCode(
-    code: string,
-    enterprise_id: number,
-  ): Promise<any> {
-    if (!code) return code;
-
-    // Check if it's a valid list type
-    const listMaster = await this.listItemsRepo.findItemByCode(
-      code,
-      enterprise_id,
-    );
-    if (listMaster) {
-      return listMaster;
-    }
-  }
-
-  async getDropdownOptions(
-    type: string,
-    params: Record<string, string>,
-    inactiveIdsArray?: number[],
-    loggedInUser?,
-    publicCall = false,
-  ) {
-    const config: any = await this.listMasterRepo.findByType(
-      type,
-      loggedInUser?.enterprise_id,
-    );
-
-    if (!config) throw new NotFoundException(`Type ${type} not found`);
-
-    if (
-      config.appcode != null &&
-      config.appcode != loggedInUser?.appcode &&
-      !publicCall
-    ) {
-      // Call internal API for appcode mismatch
-      try {
-        const baseUrl = this.configService.get<string>('REDIRECT_BE_URL');
-
-        // Prepare the query string
-        const queryParams = new URLSearchParams({
-          inactiveIds: inactiveIdsArray?.join(',') || '',
-          loggedInUser: JSON.stringify(loggedInUser),
-          ...params, // Spread other params into the query string
-        }).toString();
-
-        // Make the GET request with query parameters
-        const response = await axios.get(
-          `${baseUrl}/list-master/getDropdownDataPublic/${type}?${queryParams}`,
-          {
-            headers: {
-              'Content-Type': 'application/json',
-            },
-          },
-        );
-
-        return response.data;
-      } catch (error) {
-        console.error('⚠️ Internal API call failed:', error.message);
-        throw new BadRequestException(
-          `Failed to fetch dropdown for type ${type} from internal API`,
-        );
-      }
-    }
-
-    // Fallback to old logic if no extension exists
-    switch (config.source) {
-      case 'entity':
-        return this.fetchFromEntity(
-          type,
-          params,
-          loggedInUser,
-        );
-
-      case 'master':
-        return this.listItemsRepo.findItemsByType(
-          type,
-          config.sort_by,
-          config.storage_type,
-          loggedInUser?.enterprise_id,
-          params,
-        );
-
-      case 'operator':
-        return this.listItemsRepo.findOperatorsByType(
-          type,
-          loggedInUser?.enterprise_id,
-        );
-
-      case 'custom':
-        // If you want Axios call here too:
-        try {
-          const response = await axios.get(
-            `https://external-source.com/${config.custom_source_id}`,
-            { params },
-          );
-          return response.data;
-        } catch (error) {
-          console.error('⚠️ Custom source fetch failed:', error.message);
-          throw new BadRequestException('Failed to fetch custom source');
-        }
-
-      default:
-        throw new BadRequestException(`Unknown source: ${config.source}`);
-    }
-  }
-
-  private async fetchFromEntity(
-    sourceList: string,
-    params: Record<string, any>,
-    loggedInUser?: UserData,
-    values?: any[],
-  ) {
-   
-    let result: { label: string; value: number }[] = [];
-    if (!sourceList) return result;
-
-    const entityMaster = await this.entityMasterService.getEntityData(
-      sourceList,
-      loggedInUser,
-    );
-    const tableName = entityMaster.data_source;
-
-    const applyCommonFilters = (qb: any, status?: number) => {
-      if (status) {
-        const isView = tableName.endsWith('_vw'); // auto-detect view
-        const statusColumn = isView ? 'status_id' : 'status';
-        qb.andWhere(`${tableName}.${statusColumn} = :status`, { status });
-      }
-
-      if (loggedInUser?.level_type && loggedInUser?.level_id) {
-        // Skip level filter for certain entities
-        if (!this.skipLevelFilterEntities.includes(sourceList)) {
-          qb.andWhere(
-            `${tableName}.level_type = :levelType AND ${tableName}.level_id = :levelId AND ${tableName}.enterprise_id = :enterprise_id`,
-            {
-              levelType: loggedInUser.level_type,
-              levelId: loggedInUser.level_id,
-              enterprise_id: loggedInUser.enterprise_id,
-            },
-          );
-        }
-      }
-
-      if (sourceList == 'USR' || sourceList == 'UPR') {
-        // IN the case of USR/UPR, we don't filter by level
-        qb.andWhere(`${tableName}.enterprise_id = :enterprise_id`, {
-          enterprise_id: loggedInUser?.enterprise_id,
-        });
-      }
-
-      if (values && values.length > 0) {
-        qb.andWhere(`${tableName}.id IN (:...values)`, { values });
-      }
-
-      // ✅ Apply dynamic params
-      for (const key in params) {
-        qb.andWhere(`${tableName}.${key} = :${key}`, {
-          [key]: params[key],
-        });
-      }
-
-      // ✅ New: Exclude customers for USR/UPR
-      if (sourceList === 'USR' || sourceList === 'UPR') {
-        qb.andWhere(`${tableName}.is_customer is NULL`);
-      }
-
-      return qb;
-    };
-
-    const resolveStatus = await this.getResolvedListCode(
-      STATUS_ACTIVE,
-      loggedInUser?.enterprise_id || 0,
-    );
-
-    // Fetch active records
-    const activeQuery = applyCommonFilters(
-      this.entityManager
-        .createQueryBuilder()
-        .select('*')
-        .from(`${this.schema}.${tableName}`, tableName),
-      resolveStatus.id,
-    );
-
-    const activeResults = await activeQuery.getRawMany();
-
-    // Add active entries first
-    activeResults.forEach((r) => {
-      result.push({ label: r.name, value: r.id });
-    });
-
-    return result;
-  }
-
-  // createEntity method
-  async createEntity(entityData: any, loggedInUser: UserData): Promise<any> {
-    // Trim and validate name and code
-    const name = entityData.name?.trim();
-    if (!name) {
-      throw new BadRequestException('Name is required and cannot be empty');
-    }
-    entityData.name = name;
-    entityData.is_factory = entityData.is_factory || 0;
-    entityData.source = entityData.source || 'master';
-    entityData.status = entityData.status || 'ACTIVE';
-    entityData.type = entityData.code;
-    entityData.sort_by = entityData.sort_by || 'asc';
-
-    // Check for duplicate name
-    const nameExists = await this.listMasterRepo.findOneByCondition({
-      name,
-      enterprise_id: loggedInUser.enterprise_id,
-    });
-
-    if (nameExists) {
-      throw new BadRequestException(
-        'A List Master with the same name already exists',
-      );
-    }
-
-    const createdListMaster = await this.entityServiceImpl.createEntity(
-      entityData,
-      loggedInUser,
-    );
-
-    if (!createdListMaster) {
-      throw new BadRequestException('Failed to create entity');
-    }
-    return createdListMaster;
-  }
-
-  async updateEntity(entityData: any, loggedInUser: UserData): Promise<any> {
-    return await this.entityServiceImpl.updateEntity(entityData, loggedInUser);
-  }
-
-  async getEntityData(
-    entity_type: string,
-    id: number,
-    loggedInUser,
-  ): Promise<any> {
-    return await this.entityServiceImpl.getEntityData(
-      entity_type,
-      id,
-      loggedInUser,
-    );
-  }
-
-  async getAllListMasterByOrganization(
-    enterprise_id: number,
-    app_code: string,
-    search?: string,
-  ): Promise<any[]> {
-    return await this.listMasterRepo.findAllItems(enterprise_id, app_code, search);
-  }
-
-  async getDropDownData(
-    entity_type: string,
-    attribute_key: string,
-    loggedInUser: UserData,
-    body: Record<string, any>,
-    values?: any[],
-    inactiveIdsArray?: any[],
-  ) {
-    try {
-      // Extract inactiveIds from body
-      const { ...params } = body;
-
-      // Fetch Attribute Master to get data source configuration
-      const attributeMaster =
-        await this.attributeMasterService.findByMappedEntityTypeAndAttributeKey(
-          entity_type,
-          attribute_key,
-          loggedInUser,
-        );
-
-      if (!attributeMaster) {
-        throw new BadRequestException(
-          `Attribute '${attribute_key}' not found for entity '${entity_type}'`,
-        );
-      }
-
-      // Extract data source configuration from AttributeMaster
-      const {
-        ds_category,    // ENT_LIST | LM | CAPI | CK | EXTAPI
-        ds_entitytype,  // Entity type or list code
-        ds_filtercode,  // Additional filter code
-        ds_appcode,     // Target app code
-      } = attributeMaster;
-
-      if (!ds_category) {
-        throw new BadRequestException(
-          `Data source category not configured for attribute '${attribute_key}'`,
-        );
-      }
-
-      const currentAppCode = this.configService.get<string>('appcode');
-
-      // Check if request is for same app (SELF) or cross-app (CROSS)
-      const isSelfApp =
-        !ds_appcode ||
-        ds_appcode.toUpperCase() === 'SELF' ||
-        currentAppCode === ds_appcode;
-
-      if (isSelfApp) {
-        // SELF APP - Process locally
-        return this.processLocalDropdown(
-          ds_category,
-          ds_entitytype,
-          ds_filtercode,
-          params,
-          loggedInUser,
-          values,
-          inactiveIdsArray
-        );
-      } else {
-        // CROSS APP - Forward to target microservice
-        return this.processCrossAppDropdown(
-          ds_appcode,
-          ds_entitytype,
-          attribute_key,
-          loggedInUser,
-          body,
-          values,
-        );
-      }
-    } catch (error) {
-      console.error('❌ Error in getDropDownData:', error.message);
-      throw error;
-    }
-  }
-
-  /**
-   * Process dropdown data locally (SELF APP)
-   */
-  private async processLocalDropdown(
-    ds_category: string,
-    ds_entitytype: string,
-    ds_filtercode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-    values?: any[],
-    inactives?: any[],
-  ) {
-    // Route to appropriate handler based on data source category
-    switch (ds_category.toUpperCase()) {
-      case 'ENT_LIST':
-      case 'ENTITY':
-        // Merge ds_filtercode params with request params
-        const mergedParams = { ...params };
-        if (ds_filtercode) {
-          const filterParams = this.parseFilterCode(ds_filtercode);
-          Object.assign(mergedParams, filterParams);
-        }
-        return this.fetchFromEntity(
-          ds_entitytype,
-          mergedParams,
-          loggedInUser,
-          values,
-        );
-
-      case 'LM':
-      case 'LIST_MASTER':
-        return this.fetchFromListMaster(
-          ds_entitytype,
-          ds_filtercode,
-          params,
-          loggedInUser,
-          values,
-          inactives
-        );
-
-      case 'CAPI':
-      case 'CUSTOM_API':
-        return this.fetchFromCustomInternalService(
-          ds_entitytype,
-          ds_filtercode,
-          params,
-          loggedInUser,
-        );
-
-      case 'CK':
-      case 'CUSTOM_KEY':
-        return this.fetchFromCustomKey(
-          ds_entitytype,
-          ds_filtercode,
-          params,
-          loggedInUser,
-        );
-
-      case 'EXTAPI':
-      case 'EXTERNAL_API':
-        return this.fetchFromExternalAPI(
-          ds_entitytype,
-          ds_filtercode,
-          params,
-          loggedInUser,
-        );
-
-      default:
-        throw new BadRequestException(
-          `Unsupported data source category: ${ds_category}`,
-        );
-    }
-  }
-
-  /**
-   * Fetch dropdown from List Master
-   */
-  private async fetchFromListMaster(
-    lmCode: string,
-    filterCode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-    values?: any[],
-    inactives?: any[],
-  ) {
-    try {
-      // Get List Master configuration
-      const listMaster = await this.listMasterRepo.findByType(
-        lmCode,
-        loggedInUser.enterprise_id,
-      );
-
-      if (!listMaster) {
-        throw new BadRequestException(`List Master '${lmCode}' not found`);
-      }
-
-      // Use repository to fetch items directly with filter
-      return this.listItemsRepo.findItemsByType(
-        lmCode,
-        listMaster.sort_by,
-        listMaster.storage_type,
-        loggedInUser.enterprise_id,
-        params,
-        values,
-        inactives
-      );
-    } catch (error) {
-      console.error(`❌ Error fetching from List Master '${lmCode}':`, error.message);
-      throw new BadRequestException(
-        `Failed to fetch from List Master: ${error.message}`,
-      );
-    }
-  }
-
-  /**
-   * Fetch dropdown from Custom Internal Service (Message Pattern)
-   */
-  private async fetchFromCustomInternalService(
-    serviceName: string,
-    filterCode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-  ) {
-    try {
-      // Get internal service client
-      const currentAppCode = this.configService.get<string>('appcode');
-
-      const client = this.factory.getClient(currentAppCode || '');
-
-      if (!client) {
-        throw new BadRequestException('Internal service client not available');
-      }
-
-      // Call internal microservice using message pattern
-      const response = await client
-        .send(serviceName, {
-          filterCode,
-          params,
-          loggedInUser,
-        })
-        .toPromise();
-
-      return response;
-    } catch (error) {
-      console.error(
-        `❌ Error calling custom internal service '${serviceName}':`,
-        error.message,
-      );
-      throw new BadRequestException(
-        `Failed to call custom internal service: ${error.message}`,
-      );
-    }
-  }
-
-  /**
-   * Fetch dropdown from Custom Key (Predefined logic)
-   */
-  private async fetchFromCustomKey(
-    customKey: string,
-    filterCode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-  ) {
-    try {
-      // Handle predefined custom logic based on custom key
-      switch (customKey.toUpperCase()) {
-        case 'USER_ROLES':
-          return this.getUserRolesDropdown(filterCode, params, loggedInUser);
-
-        case 'DEPARTMENTS':
-          return this.getDepartmentsDropdown(filterCode, params, loggedInUser);
-
-        case 'FINANCIAL_YEARS':
-          return this.getFinancialYearsDropdown(filterCode, params, loggedInUser);
-
-        case 'OPERATORS':
-          return this.getOperatorsDropdown(filterCode, params, loggedInUser);
-
-        // Add more custom key handlers as needed
-        default:
-          throw new BadRequestException(`Unknown custom key: ${customKey}`);
-      }
-    } catch (error) {
-      console.error(`❌ Error fetching custom key '${customKey}':`, error.message);
-      throw new BadRequestException(
-        `Failed to fetch custom key: ${error.message}`,
-      );
-    }
-  }
-
-  /**
-   * Fetch dropdown from External API
-   */
-  private async fetchFromExternalAPI(
-    apiUrl: string,
-    filterCode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-  ) {
-    try {
-      // Build full API URL with filter code if provided
-      const fullUrl = filterCode ? `${apiUrl}/${filterCode}` : apiUrl;
-
-      // Make external API call using Axios
-      const response = await axios.get(fullUrl, {
-        params: {
-          ...params,
-          enterprise_id: loggedInUser.enterprise_id,
-        },
-        timeout: 10000, // 10 seconds timeout
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': `Bearer ${this.configService.get('EXTERNAL_API_TOKEN')}`,
-        },
-      });
-
-      return response.data;
-    } catch (error) {
-      console.error(`❌ Error calling external API '${apiUrl}':`, error.message);
-
-      if (error.response) {
-        throw new BadRequestException(
-          `External API error: ${error.response.status} - ${error.response.statusText}`,
-        );
-      } else if (error.request) {
-        throw new BadRequestException('External API is not responding');
-      } else {
-        throw new BadRequestException(
-          `Failed to call external API: ${error.message}`,
-        );
-      }
-    }
-  }
-
-  /**
-   * Apply filter code to query (custom WHERE conditions)
-   */
-  private applyFilterCode(
-    query: any,
-    tableName: string,
-    filterCode: string,
-    loggedInUser: UserData,
-  ): any {
-    // Parse filter code and apply conditions
-    // Example: "status=active|type=premium"
-    const filters = filterCode.split('|');
-
-    filters.forEach((filter) => {
-      const [key, value] = filter.split('=');
-      if (key && value) {
-        // Handle special variables
-        let filterValue: any = value;
-        if (value === '{USER_ID}') {
-          filterValue = loggedInUser.id;
-        } else if (value === '{ENTERPRISE_ID}') {
-          filterValue = loggedInUser.enterprise_id;
-        }
-
-        query = query.andWhere(`${tableName}.${key} = :${key}`, {
-          [key]: filterValue,
-        });
-      }
-    });
-
-    return query;
-  }
-
-  /**
-   * Format dropdown response with consistent structure
-   */
-  private formatDropdownResponse(data: any[], config: any): any[] {
-    return data.map((item) => ({
-      id: item.id,
-      value: item.value || item.name || item.title,
-      label: item.label || item.display_name || item.name || item.title,
-      code: item.code,
-      ...item, // Include all other fields
-    }));
-  }
-
-  /**
-   * Forward request to cross-app microservice (CROSS APP)
-   */
-  private async processCrossAppDropdown(
-    targetAppCode: string,
-    entity_type: string,
-    attribute_key: string,
-    loggedInUser: UserData,
-    body: Record<string, any>,
-    values?: any[],
-  ) {
-    try {
-      // Get microservice client for target app
-      const client = this.factory.getClient(targetAppCode);
-
-      if (!client) {
-        throw new BadRequestException(
-          `Microservice client for app '${targetAppCode}' not available`,
-        );
-      }
-
-      // Forward the request to target microservice
-      // The target microservice will execute the same process recursively
-      const response = await client
-        .send('getDropdownData', {
-          entity_type,
-          attribute_key,
-          loggedInUser,
-          body,
-        })
-        .toPromise();
-
-      return response;
-    } catch (error) {
-      console.error(
-        `❌ Error calling cross-app microservice '${targetAppCode}':`,
-        error.message,
-      );
-      throw new BadRequestException(
-        `Failed to fetch dropdown from app '${targetAppCode}': ${error.message}`,
-      );
-    }
-  }
-
-  // Example custom key handlers
-  private async getUserRolesDropdown(
-    filterCode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-  ) {
-    // TODO: Implement roles service integration
-    // return this.rolesService.getActiveRoles(loggedInUser.enterprise_id, params);
-    throw new BadRequestException('USER_ROLES handler not implemented yet');
-  }
-
-  private async getDepartmentsDropdown(
-    filterCode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-  ) {
-    // TODO: Implement departments service integration
-    // return this.departmentService.getActiveDepartments(loggedInUser.enterprise_id, params);
-    throw new BadRequestException('DEPARTMENTS handler not implemented yet');
-  }
-
-  private async getFinancialYearsDropdown(
-    filterCode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-  ) {
-    // Generate financial years dynamically
-    const currentYear = new Date().getFullYear();
-    const years: Array<{ id: number; value: string; label: string }> = [];
-    for (let i = -5; i <= 5; i++) {
-      const year = currentYear + i;
-      years.push({
-        id: year,
-        value: `FY${year}-${year + 1}`,
-        label: `FY ${year}-${year + 1}`,
-      });
-    }
-    return years;
-  }
-
-  private async getOperatorsDropdown(
-    filterCode: string,
-    params: Record<string, any>,
-    loggedInUser: UserData,
-  ) {
-    // Return predefined operators
-    return [
-      { id: 1, value: '=', label: 'Equals' },
-      { id: 2, value: '!=', label: 'Not Equals' },
-      { id: 3, value: '>', label: 'Greater Than' },
-      { id: 4, value: '<', label: 'Less Than' },
-      { id: 5, value: '>=', label: 'Greater Than or Equal' },
-      { id: 6, value: '<=', label: 'Less Than or Equal' },
-      { id: 7, value: 'LIKE', label: 'Contains' },
-      { id: 8, value: 'IN', label: 'In List' },
-    ];
-  }
-
-  /**
-   * Parse filter code string into key-value params
-   * Example: "status=active|type=premium" => { status: 'active', type: 'premium' }
-   */
-  private parseFilterCode(filterCode: string): Record<string, any> {
-    if (!filterCode) return {};
-
-    const params: Record<string, any> = {};
-    const filters = filterCode.split('|');
-
-    filters.forEach((filter) => {
-      const [key, value] = filter.split('=');
-      if (key && value) {
-        params[key.trim()] = value.trim();
-      }
-    });
-
-    return params;
-  }
-}
+import { BadRequestException, forwardRef, Inject, Injectable, NotFoundException } from '@nestjs/common';
+import { ListMasterItemsRepository } from '../repository/list-master-items.repository';
+import { ListMasterRepository } from '../repository/list-master.repository';
+import { EntityManager } from 'typeorm';
+import { UserData } from 'src/module/auth/dto/user.dto';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { STATUS_ACTIVE } from 'src/constant/global.constant';
+import { Action } from '../../workflow-automation/interface/action.interface';
+import axios from 'axios';
+import { ConfigService } from '@nestjs/config';
+import { AttributeMasterService } from '../../meta/service/attribute-master.service';
+import { IMicroserviceClients } from '../../microservice-client/service/microservice-clients';
+import { firstValueFrom } from 'rxjs';
+
+@Injectable()
+export class ListMasterService extends EntityServiceImpl {
+  constructor(
+    private readonly entityManager: EntityManager,
+    @Inject(forwardRef(() => EntityServiceImpl))
+    private readonly entityServiceImpl: EntityServiceImpl,
+    private readonly listMasterRepo: ListMasterRepository,
+    private readonly listItemsRepo: ListMasterItemsRepository,
+    private readonly configService: ConfigService,
+    @Inject('AttributeMasterService')
+    private readonly attributeMasterService: AttributeMasterService,
+    @Inject('MICROSERVICE_CLIENT_FACTORY')
+    private readonly factory: IMicroserviceClients,
+  ) {
+    super();
+  }
+
+  schema = this.configService.get('DB_SCHEMA');
+  private readonly skipLevelFilterEntities = ['BRN', 'USR', 'UPR', 'BRNP'];
+  private readonly actions = new Map<string, Action>();
+
+  registerAction(actionName: string, actionInstance: Action) {
+    this.actions.set(actionName, actionInstance);
+    console.log(
+      `⚙️ [WorkflowAutomationEngine] Registered action: ${actionName}`,
+    );
+  }
+
+  async getResolvedListCode(
+    code: string,
+    enterprise_id: number,
+  ): Promise<any> {
+    if (!code) return code;
+
+    // Check if it's a valid list type
+    const listMaster = await this.listItemsRepo.findItemByCode(
+      code,
+      enterprise_id,
+    );
+    if (listMaster) {
+      return listMaster;
+    }
+  }
+
+  async getDropdownOptions(
+    type: string,
+    params: Record<string, string>,
+    inactiveIdsArray?: number[],
+    loggedInUser?,
+    publicCall = false,
+  ) {
+    const config: any = await this.listMasterRepo.findByType(
+      type,
+      loggedInUser?.enterprise_id,
+    );
+
+    if (!config) throw new NotFoundException(`Type ${type} not found`);
+
+    if (
+      config.appcode != null &&
+      config.appcode != loggedInUser?.appcode &&
+      !publicCall
+    ) {
+      // Call internal API for appcode mismatch
+      try {
+        const baseUrl = this.configService.get<string>('REDIRECT_BE_URL');
+
+        // Prepare the query string
+        const queryParams = new URLSearchParams({
+          inactiveIds: inactiveIdsArray?.join(',') || '',
+          loggedInUser: JSON.stringify(loggedInUser),
+          ...params, // Spread other params into the query string
+        }).toString();
+
+        // Make the GET request with query parameters
+        const response = await axios.get(
+          `${baseUrl}/list-master/getDropdownDataPublic/${type}?${queryParams}`,
+          {
+            headers: {
+              'Content-Type': 'application/json',
+            },
+          },
+        );
+
+        return response.data;
+      } catch (error) {
+        console.error('⚠️ Internal API call failed:', error.message);
+        throw new BadRequestException(
+          `Failed to fetch dropdown for type ${type} from internal API`,
+        );
+      }
+    }
+
+    // Fallback to old logic if no extension exists
+    switch (config.source) {
+      case 'entity':
+        return this.fetchFromEntity(
+          type,
+          params,
+          loggedInUser,
+        );
+
+      case 'master':
+        return this.listItemsRepo.findItemsByType(
+          type,
+          config.sort_by,
+          config.storage_type,
+          loggedInUser?.enterprise_id,
+          params,
+        );
+
+      case 'operator':
+        return this.listItemsRepo.findOperatorsByType(
+          type,
+          loggedInUser?.enterprise_id,
+        );
+
+      case 'custom':
+        // If you want Axios call here too:
+        try {
+          const response = await axios.get(
+            `https://external-source.com/${config.custom_source_id}`,
+            { params },
+          );
+          return response.data;
+        } catch (error) {
+          console.error('⚠️ Custom source fetch failed:', error.message);
+          throw new BadRequestException('Failed to fetch custom source');
+        }
+
+      default:
+        throw new BadRequestException(`Unknown source: ${config.source}`);
+    }
+  }
+
+  public async fetchFromEntity(
+    sourceList: string,
+    params: Record<string, any>,
+    loggedInUser?: UserData,
+    values?: any[],
+    inactiveIds?: any[],
+  ) {
+   
+    let result: { label: string; value: number }[] = [];
+    if (!sourceList) return result;
+
+    const entityMaster = await this.entityMasterService.getEntityData(
+      sourceList,
+      loggedInUser,
+    );
+    const tableName = entityMaster.data_source;
+
+    const applyCommonFilters = (qb: any, status?: number) => {
+      if (status) {
+        const isView = tableName.endsWith('_vw'); // auto-detect view
+        const statusColumn = isView ? 'status_id' : 'status';
+        qb.andWhere(`${tableName}.${statusColumn} = :status`, { status });
+      }
+
+      if (loggedInUser?.level_type && loggedInUser?.level_id) {
+        // Skip level filter for certain entities
+        if (!this.skipLevelFilterEntities.includes(sourceList)) {
+          qb.andWhere(
+            `${tableName}.level_type = :levelType AND ${tableName}.level_id = :levelId AND ${tableName}.enterprise_id = :enterprise_id`,
+            {
+              levelType: loggedInUser.level_type,
+              levelId: loggedInUser.level_id,
+              enterprise_id: loggedInUser.enterprise_id,
+            },
+          );
+        }
+      }
+
+      if (sourceList == 'USR' || sourceList == 'UPR') {
+        // IN the case of USR/UPR, we don't filter by level
+        qb.andWhere(`${tableName}.enterprise_id = :enterprise_id`, {
+          enterprise_id: loggedInUser?.enterprise_id,
+        });
+      }
+
+      if (values && values.length > 0) {
+        qb.andWhere(`${tableName}.id IN (:...values)`, { values });
+      }
+
+      // ✅ Apply dynamic params
+      for (const key in params) {
+        qb.andWhere(`${tableName}.${key} = :${key}`, {
+          [key]: params[key],
+        });
+      }
+
+      // ✅ New: Exclude customers for USR
+      if (sourceList === 'USR') {
+        qb.andWhere(`${tableName}.is_customer is NULL`);
+      }
+
+      return qb;
+    };
+
+    const resolveStatus = await this.getResolvedListCode(
+      STATUS_ACTIVE,
+      loggedInUser?.enterprise_id || 0,
+    );
+
+    // Fetch active records
+    const activeQuery = applyCommonFilters(
+      this.entityManager
+        .createQueryBuilder()
+        .select('*')
+        .from(`${this.schema}.${tableName}`, tableName),
+      resolveStatus.id,
+    );
+
+    const activeResults = await activeQuery.getRawMany();
+
+    // Add active entries first
+    activeResults.forEach((r) => {
+      result.push({ label: r.name, value: r.id });
+    });
+
+    if (inactiveIds && inactiveIds.length > 0) {
+      const qb = this.entityManager
+        .createQueryBuilder()
+        .select('*')
+        .from(`${this.schema}.${tableName}`, tableName)
+        .where('id IN (:...inactiveIds)', { inactiveIds });
+
+      const inactiveQuery = await qb.getRawMany();
+
+      inactiveQuery.map((r) => {
+        result.push({ label: `${r.name} [INACTIVE]`, value: r.id });
+      });
+    }
+    return result;
+  }
+
+  // createEntity method
+  async createEntity(entityData: any, loggedInUser: UserData): Promise<any> {
+    // Trim and validate name and code
+    const name = entityData.name?.trim();
+    if (!name) {
+      throw new BadRequestException('Name is required and cannot be empty');
+    }
+    entityData.name = name;
+    entityData.is_factory = entityData.is_factory || 0;
+    entityData.source = entityData.source || 'master';
+    entityData.status = entityData.status || 'ACTIVE';
+    entityData.type = entityData.code;
+    entityData.sort_by = entityData.sort_by || 'asc';
+
+    // Check for duplicate name
+    const nameExists = await this.listMasterRepo.findOneByCondition({
+      name,
+      enterprise_id: loggedInUser.enterprise_id,
+    });
+
+    if (nameExists) {
+      throw new BadRequestException(
+        'A List Master with the same name already exists',
+      );
+    }
+
+    const createdListMaster = await this.entityServiceImpl.createEntity(
+      entityData,
+      loggedInUser,
+    );
+
+    if (!createdListMaster) {
+      throw new BadRequestException('Failed to create entity');
+    }
+    return createdListMaster;
+  }
+
+  async updateEntity(entityData: any, loggedInUser: UserData): Promise<any> {
+    return await this.entityServiceImpl.updateEntity(entityData, loggedInUser);
+  }
+
+  async getEntityData(
+    entity_type: string,
+    id: number,
+    loggedInUser,
+  ): Promise<any> {
+    return await this.entityServiceImpl.getEntityData(
+      entity_type,
+      id,
+      loggedInUser,
+    );
+  }
+
+  async getAllListMasterByOrganization(
+    enterprise_id: number,
+    app_code: string,
+    search?: string,
+  ): Promise<any[]> {
+    return await this.listMasterRepo.findAllItems(enterprise_id, app_code, search);
+  }
+
+  async getDropDownData(
+    entity_type: string,
+    attribute_key: string,
+    loggedInUser: UserData,
+    body: Record<string, any>,
+    values?: any[],
+    inactiveIdsArray?: any[],
+  ) {
+    try {
+      // Extract inactiveIds from body
+      const { ...params } = body;
+
+      // Fetch Attribute Master to get data source configuration
+      const attributeMaster =
+        await this.attributeMasterService.findByMappedEntityTypeAndAttributeKey(
+          entity_type,
+          attribute_key,
+          loggedInUser,
+        );
+
+      if (!attributeMaster) {
+        throw new BadRequestException(
+          `Attribute '${attribute_key}' not found for entity '${entity_type}'`,
+        );
+      }
+
+      // Extract data source configuration from AttributeMaster
+      const {
+        ds_category,    // ENT_LIST | LM | CAPI | CK | EXTAPI
+        ds_entitytype,  // Entity type or list code
+        ds_filtercode,  // Additional filter code
+        ds_appcode,     // Target app code
+      } = attributeMaster;
+
+      if (!ds_category) {
+        throw new BadRequestException(
+          `Data source category not configured for attribute '${attribute_key}'`,
+        );
+      }
+
+      return this.processDropdown(
+        ds_category,
+        ds_entitytype,
+        ds_appcode,
+        ds_filtercode,
+        params,
+        loggedInUser,
+        values,
+        inactiveIdsArray,
+      );
+
+    } catch (error) {
+      console.error('❌ Error in getDropDownData:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Process dropdown data locally (SELF APP)
+   */
+  private async processDropdown(
+    ds_category: string,
+    ds_entitytype: string,
+    ds_filtercode: string,
+    ds_appcode: string,
+    params: Record<string, any>,
+    loggedInUser: UserData,
+    values?: any[],
+    inactives?: any[],
+  ) {
+    const currentAppCode = this.configService.get<string>('appcode');
+
+    // Determine if request is SELF or CROSS
+    const isSelfApp =
+      !ds_appcode ||
+      ds_appcode.toUpperCase() === 'SELF' ||
+      currentAppCode === ds_appcode;
+
+    const client = this.factory.getClient(ds_appcode);
+
+    // Helper: safely call microservice
+    const callClient = async (pattern: string, payload: any) => {
+      if (!client) return null;
+      return firstValueFrom(client.send(pattern, payload));
+    };
+
+    switch (ds_category.toUpperCase()) {
+      case 'ENTITY': {
+        // Merge params + filter params
+        const mergedParams = {
+          ...params,
+          ...(ds_filtercode ? this.parseFilterCode(ds_filtercode) : {}),
+        };
+
+        if (isSelfApp) {
+          return this.fetchFromEntity(
+            ds_entitytype,
+            mergedParams,
+            loggedInUser,
+            values,
+          );
+        }
+
+        return callClient('getEntityDropdown', {
+          ds_entitytype,
+          mergedParams,
+          loggedInUser,
+          values,
+        });
+      }
+
+      case 'LIST_MASTER': {
+        if (isSelfApp) {
+          return this.fetchFromListMaster(
+            ds_entitytype,
+            params,
+            loggedInUser,
+            values,
+            inactives,
+          );
+        }
+
+        return callClient('getListMasterDropdown', {
+          ds_entitytype,
+          ds_filtercode,
+          params,
+          loggedInUser,
+          values,
+          inactives,
+        });
+      }
+
+      case 'CAPI':
+      case 'CUSTOM_API':
+        return this.fetchFromCustomInternalService(
+          ds_entitytype,
+          ds_filtercode,
+          params,
+          loggedInUser,
+        );
+
+      case 'CK':
+      case 'CUSTOM_KEY':
+        return this.fetchFromCustomKey(
+          ds_entitytype,
+          ds_filtercode,
+          params,
+          loggedInUser,
+        );
+
+      case 'EXTAPI':
+      case 'EXTERNAL_API':
+        return this.fetchFromExternalAPI(
+          ds_entitytype,
+          ds_filtercode,
+          params,
+          loggedInUser,
+        );
+
+      default:
+        throw new BadRequestException(
+          `Unsupported data source category: ${ds_category}`,
+        );
+    }
+  }
+
+  /**
+   * Fetch dropdown from List Master
+   */
+  public async fetchFromListMaster(
+    lmCode: string,
+    params: Record<string, any>,
+    loggedInUser: UserData,
+    values?: any[],
+    inactives?: any[],
+  ) {
+    try {
+      // Get List Master configuration
+      const listMaster = await this.listMasterRepo.findByType(
+        lmCode,
+        loggedInUser.enterprise_id,
+      );
+
+      if (!listMaster) {
+        throw new BadRequestException(`List Master '${lmCode}' not found`);
+      }
+
+      // Use repository to fetch items directly with filter
+      return this.listItemsRepo.findItemsByType(
+        lmCode,
+        listMaster.sort_by,
+        listMaster.storage_type,
+        loggedInUser.enterprise_id,
+        params,
+        values,
+        inactives,
+      );
+    } catch (error) {
+      console.error(`❌ Error fetching from List Master '${lmCode}':`, error.message);
+      throw new BadRequestException(
+        `Failed to fetch from List Master: ${error.message}`,
+      );
+    }
+  }
+
+  /**
+   * Fetch dropdown from Custom Internal Service (Message Pattern)
+   */
+  private async fetchFromCustomInternalService(
+    serviceName: string,
+    filterCode: string,
+    params: Record<string, any>,
+    loggedInUser: UserData,
+  ) {
+    try {
+      // Get internal service client
+      const currentAppCode = this.configService.get<string>('appcode');
+
+      const client = this.factory.getClient(currentAppCode || '');
+
+      if (!client) {
+        throw new BadRequestException('Internal service client not available');
+      }
+
+      // Call internal microservice using message pattern
+      const response = await client
+        .send(serviceName, {
+          filterCode,
+          params,
+          loggedInUser,
+        })
+        .toPromise();
+
+      return response;
+    } catch (error) {
+      console.error(
+        `❌ Error calling custom internal service '${serviceName}':`,
+        error.message,
+      );
+      throw new BadRequestException(
+        `Failed to call custom internal service: ${error.message}`,
+      );
+    }
+  }
+
+  /**
+   * Fetch dropdown from Custom Key (Predefined logic)
+   */
+  private async fetchFromCustomKey(
+    customKey: string,
+    filterCode: string,
+    params: Record<string, any>,
+    loggedInUser: UserData,
+  ) {
+    try {
+      // Handle predefined custom logic based on custom key
+      switch (customKey.toUpperCase()) {
+        case 'USER_ROLES':
+          return this.getUserRolesDropdown(filterCode, params, loggedInUser);
+
+        case 'DEPARTMENTS':
+          return this.getDepartmentsDropdown(filterCode, params, loggedInUser);
+
+        case 'FINANCIAL_YEARS':
+          return this.getFinancialYearsDropdown(filterCode, params, loggedInUser);
+
+        case 'OPERATORS':
+          return this.getOperatorsDropdown(filterCode, params, loggedInUser);
+
+        // Add more custom key handlers as needed
+        default:
+          throw new BadRequestException(`Unknown custom key: ${customKey}`);
+      }
+    } catch (error) {
+      console.error(`❌ Error fetching custom key '${customKey}':`, error.message);
+      throw new BadRequestException(
+        `Failed to fetch custom key: ${error.message}`,
+      );
+    }
+  }
+
+  /**
+   * Fetch dropdown from External API
+   */
+  private async fetchFromExternalAPI(
+    apiUrl: string,
+    filterCode: string,
+    params: Record<string, any>,
+    loggedInUser: UserData,
+  ) {
+    try {
+      // Build full API URL with filter code if provided
+      const fullUrl = filterCode ? `${apiUrl}/${filterCode}` : apiUrl;
+
+      // Make external API call using Axios
+      const response = await axios.get(fullUrl, {
+        params: {
+          ...params,
+          enterprise_id: loggedInUser.enterprise_id,
+        },
+        timeout: 10000, // 10 seconds timeout
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.configService.get('EXTERNAL_API_TOKEN')}`,
+        },
+      });
+
+      return response.data;
+    } catch (error) {
+      console.error(`❌ Error calling external API '${apiUrl}':`, error.message);
+
+      if (error.response) {
+        throw new BadRequestException(
+          `External API error: ${error.response.status} - ${error.response.statusText}`,
+        );
+      } else if (error.request) {
+        throw new BadRequestException('External API is not responding');
+      } else {
+        throw new BadRequestException(
+          `Failed to call external API: ${error.message}`,
+        );
+      }
+    }
+  }
+
+  /**
+   * Apply filter code to query (custom WHERE conditions)
+   */
+  private applyFilterCode(
+    query: any,
+    tableName: string,
+    filterCode: string,
+    loggedInUser: UserData,
+  ): any {
+    // Parse filter code and apply conditions
+    // Example: "status=active|type=premium"
+    const filters = filterCode.split('|');
+
+    filters.forEach((filter) => {
+      const [key, value] = filter.split('=');
+      if (key && value) {
+        // Handle special variables
+        let filterValue: any = value;
+        if (value === '{USER_ID}') {
+          filterValue = loggedInUser.id;
+        } else if (value === '{ENTERPRISE_ID}') {
+          filterValue = loggedInUser.enterprise_id;
+        }
+
+        query = query.andWhere(`${tableName}.${key} = :${key}`, {
+          [key]: filterValue,
+        });
+      }
+    });
+
+    return query;
+  }
+
+  /**
+   * Format dropdown response with consistent structure
+   */
+  private formatDropdownResponse(data: any[], config: any): any[] {
+    return data.map((item) => ({
+      id: item.id,
+      value: item.value || item.name || item.title,
+      label: item.label || item.display_name || item.name || item.title,
+      code: item.code,
+      ...item, // Include all other fields
+    }));
+  }
+
+  // Example custom key handlers
+  private async getUserRolesDropdown(
+    filterCode: string,
+    params: Record<string, any>,
+    loggedInUser: UserData,
+  ) {
+    // TODO: Implement roles service integration
+    // return this.rolesService.getActiveRoles(loggedInUser.enterprise_id, params);
+    throw new BadRequestException('USER_ROLES handler not implemented yet');
+  }
+
+  private async getDepartmentsDropdown(
+    filterCode: string,
+    params: Record<string, any>,
+    loggedInUser: UserData,
+  ) {
+    // TODO: Implement departments service integration
+    // return this.departmentService.getActiveDepartments(loggedInUser.enterprise_id, params);
+    throw new BadRequestException('DEPARTMENTS handler not implemented yet');
+  }
+
+  private async getFinancialYearsDropdown(
+    filterCode: string,
+    params: Record<string, any>,
+    loggedInUser: UserData,
+  ) {
+    // Generate financial years dynamically
+    const currentYear = new Date().getFullYear();
+    const years: Array<{ id: number; value: string; label: string }> = [];
+    for (let i = -5; i <= 5; i++) {
+      const year = currentYear + i;
+      years.push({
+        id: year,
+        value: `FY${year}-${year + 1}`,
+        label: `FY ${year}-${year + 1}`,
+      });
+    }
+    return years;
+  }
+
+  private async getOperatorsDropdown(
+    filterCode: string,
+    params: Record<string, any>,
+    loggedInUser: UserData,
+  ) {
+    // Return predefined operators
+    return [
+      { id: 1, value: '=', label: 'Equals' },
+      { id: 2, value: '!=', label: 'Not Equals' },
+      { id: 3, value: '>', label: 'Greater Than' },
+      { id: 4, value: '<', label: 'Less Than' },
+      { id: 5, value: '>=', label: 'Greater Than or Equal' },
+      { id: 6, value: '<=', label: 'Less Than or Equal' },
+      { id: 7, value: 'LIKE', label: 'Contains' },
+      { id: 8, value: 'IN', label: 'In List' },
+    ];
+  }
+
+  /**
+   * Parse filter code string into key-value params
+   * Example: "status=active|type=premium" => { status: 'active', type: 'premium' }
+   */
+  private parseFilterCode(filterCode: string): Record<string, any> {
+    if (!filterCode) return {};
+
+    const params: Record<string, any> = {};
+    const filters = filterCode.split('|');
+
+    filters.forEach((filter) => {
+      const [key, value] = filter.split('=');
+      if (key && value) {
+        params[key.trim()] = value.trim();
+      }
+    });
+
+    return params;
+  }
+}