rez_core 3.1.163 → 3.1.165

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

@@ -1,415 +1,420 @@
-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 { ApiRegistryService } from '../../third-party-module/service/api-registry.service';
-import { firstValueFrom } from 'rxjs';
-import { HttpService } from '@nestjs/axios';
-import { EntityManager } from 'typeorm';
-import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
-import { UserData } from 'src/module/user/entity/user.entity';
-import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
-import { STATUS_ACTIVE, STATUS_INACTIVE } from 'src/constant/global.constant';
-import { ListMasterExtension } from './list-master-extension.interface';
-import { ListMasterEngine } from './list-master-engine';
-import { Action } from '../../workflow-automation/interface/action.interface';
-import axios from 'axios';
-import { ConfigService } from '@nestjs/config';
-
-@Injectable()
-export class ListMasterService {
-  constructor(
-    private readonly entityManager: EntityManager,
-    @Inject(forwardRef(() => EntityServiceImpl))
-    private readonly entityServiceImpl: EntityServiceImpl,
-    @Inject(forwardRef(() => EntityMasterService))
-    private readonly entityMasterService: EntityMasterService,
-    private readonly listMasterRepo: ListMasterRepository,
-    private readonly listItemsRepo: ListMasterItemsRepository,
-    private readonly apiRegistryService: ApiRegistryService,
-    private readonly httpService: HttpService,
-    private readonly listMasterEngine: ListMasterEngine,
-    private readonly configService: ConfigService,
-  ) {}
-
-  private readonly skipLevelFilterEntities = ['BRN'];
-  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,
-    organization_id: number,
-  ): Promise<any> {
-    if (!code) return code;
-
-    // Check if it's a valid list type
-    const listMaster = await this.listItemsRepo.findItemByCode(
-      code,
-      organization_id,
-    );
-    if (listMaster) {
-      return listMaster;
-    }
-  }
-
-  async getDropdownOptions(
-    type: string,
-    params: Record<string, string>,
-    inactiveIdsArray?: number[],
-    loggedInUser?,
-  ) {
-    const config = await this.listMasterRepo.findByType(
-      type,
-      loggedInUser?.organization_id,
-    );
-
-    if (!config) throw new NotFoundException(`Type ${type} not found`);
-
-    if (config.appcode != loggedInUser?.appcode) {
-      // Call internal API for appcode mismatch
-      try {
-        const baseUrl = this.configService.get<string>('REDIRECT_BE_URL');
-        const response = await axios.post(
-          `${baseUrl}/api/getDropdownDataPublic/${type}`,
-          {
-            inactiveIds: inactiveIdsArray?.join(',') || '',
-            loggedInUser: JSON.stringify(loggedInUser),
-            ...params,
-          },
-          {
-            headers: {
-              'Content-Type': 'application/json',
-            },
-          },
-        );
-
-        console.log('✅ Internal API response:', response.data);
-        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,
-          inactiveIdsArray,
-          loggedInUser,
-        );
-
-      case 'master':
-        return this.listItemsRepo.findItemsByType(
-          type,
-          config.sort_by,
-          inactiveIdsArray,
-          loggedInUser?.organization_id,
-          params,
-        );
-
-      case 'operator':
-        return this.listItemsRepo.findOperatorsByType(
-          type,
-          loggedInUser?.organization_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>,
-    inactiveIdsArray?: number[],
-    loggedInUser?: UserData,
-  ) {
-    console.log(
-      sourceList,
-      'sourceList',
-      params,
-      'params',
-      inactiveIdsArray,
-      'inactiveIdsArray',
-      loggedInUser,
-      'loggedInUser',
-    );
-    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}.organization_id = :organization_id`,
-            {
-              levelType: loggedInUser.level_type,
-              levelId: loggedInUser.level_id,
-              organization_id: loggedInUser.organization_id,
-            },
-          );
-        } else {
-          // IN the case of BRN, we don't filter by level
-          qb.andWhere(
-            `${tableName}.parent_id = :organization_id
-            AND ${tableName}.type = 'BRN'
-            `,
-            {
-              organization_id: loggedInUser.organization_id,
-            },
-          );
-        }
-      }
-
-      if (loggedInUser?.appcode && sourceList === 'ROL') {
-        if (!this.skipLevelFilterEntities.includes(sourceList)) {
-          qb.andWhere(`${tableName}.appcode = :appcode`, {
-            appcode: loggedInUser.appcode,
-          });
-        }
-      }
-
-      for (const key in params) {
-        qb.andWhere(`${tableName}.${key} = :${key}`, {
-          [key]: params[key],
-        });
-      }
-
-      return qb;
-    };
-
-    const resolveStatus = await this.getResolvedListCode(
-      STATUS_ACTIVE,
-      loggedInUser?.organization_id || 0,
-    );
-
-    // Fetpords
-    const activeQuery = applyCommonFilters(
-      this.entityManager
-        .createQueryBuilder()
-        .select('*')
-        .from(tableName, tableName),
-      resolveStatus.id,
-    );
-
-    const activeResults = await activeQuery.getRawMany();
-    const activeIds = new Set(activeResults.map((r) => r.id));
-
-    // Add active entries first
-    activeResults.forEach((r) => {
-      result.push({ label: r.name, value: r.id });
-    });
-
-    const resolveInactiveStatus = await this.getResolvedListCode(
-      STATUS_INACTIVE,
-      loggedInUser?.organization_id || 0,
-    );
-
-    // Fetch inactive records (with same filters but without status condition)
-    if (inactiveIdsArray?.length) {
-      const inactiveQuery = applyCommonFilters(
-        this.entityManager
-          .createQueryBuilder()
-          .select('*')
-          .from(tableName, tableName),
-        resolveInactiveStatus.id,
-      );
-
-      inactiveQuery.andWhere(`${tableName}.id IN (:...ids)`, {
-        ids: inactiveIdsArray,
-      });
-
-      const inactiveResults = await inactiveQuery.getRawMany();
-
-      // Add only those inactive records not already present in active
-      inactiveResults.forEach((item) => {
-        if (!activeIds.has(item.id)) {
-          result.push({
-            label: `${item.name} [INACTIVE]`,
-            value: item.id,
-          });
-        }
-      });
-    }
-
-    return result;
-  }
-
-  private async fetchFromExternalSource(
-    customSourceId: number,
-    params?: Record<string, string>,
-  ) {
-    const apiRegistry = await this.apiRegistryService.findById(customSourceId);
-    if (!apiRegistry) return [];
-
-    const url = `${apiRegistry.base_url}${apiRegistry.endpoint.replace(/{{(.*?)}}/g, (_, key) => params?.[key.trim()] || '')}`;
-    const payload = this.injectDynamicParams(
-      apiRegistry.request_payload_schema,
-      params,
-    );
-
-    const response = await firstValueFrom(
-      this.httpService.request({
-        url,
-        method: apiRegistry.http_method || 'POST',
-        data: payload,
-        headers: apiRegistry.headers ? apiRegistry.headers : undefined,
-      }),
-    );
-
-    const data = this.extractByPath(
-      response.data,
-      apiRegistry.response_data_path,
-    );
-
-    if (!Array.isArray(data)) {
-      return [{ label: data, value: data }];
-    }
-
-    if (typeof data[0] === 'string') {
-      return data.map((item: string) => ({ label: item, value: item }));
-    }
-
-    return data.map((item: any) => ({
-      label: item[apiRegistry?.label],
-      value: item[apiRegistry?.value],
-    }));
-  }
-
-  private injectDynamicParams(
-    payload: any,
-    params?: Record<string, string>,
-  ): any {
-    if (params) {
-      const stringified = JSON.stringify(payload);
-      const replaced = stringified.replace(
-        /{{(.*?)}}/g,
-        (_, key) => params[key.trim()] || '',
-      );
-      return JSON.parse(replaced);
-    }
-  }
-
-  private extractByPath(obj: any, path: string): any {
-    if (!path || !obj) return obj;
-
-    return path.split('.').reduce((acc, key) => {
-      if (acc == null) return undefined;
-
-      // Try to convert to number if it's a numeric string (for array indexes)
-      const index = Number(key);
-      if (!isNaN(index) && Array.isArray(acc)) {
-        return acc[index];
-      }
-
-      return acc[key];
-    }, obj);
-  }
-
-  // createEntity method
-  async createEntity(entityData: any, loggedInUser: UserData): Promise<any> {
-    // Trim and validate name and code
-    const name = entityData.name?.trim();
-    // const code = entityData.code?.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';
-    entityData.organization_id = loggedInUser.organization_id;
-
-    // Check for duplicate name
-    const nameExists = await this.listMasterRepo.findOneByCondition({
-      name,
-      organization_id: loggedInUser.organization_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(
-    organizationId: number,
-    search?: string,
-  ): Promise<any[]> {
-    return await this.listMasterRepo.findAllItems(organizationId, search);
-  }
-}
+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 { ApiRegistryService } from '../../third-party-module/service/api-registry.service';
+import { firstValueFrom } from 'rxjs';
+import { HttpService } from '@nestjs/axios';
+import { EntityManager } from 'typeorm';
+import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
+import { UserData } from 'src/module/user/entity/user.entity';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { STATUS_ACTIVE, STATUS_INACTIVE } from 'src/constant/global.constant';
+import { ListMasterExtension } from './list-master-extension.interface';
+import { ListMasterEngine } from './list-master-engine';
+import { Action } from '../../workflow-automation/interface/action.interface';
+import axios from 'axios';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class ListMasterService {
+  constructor(
+    private readonly entityManager: EntityManager,
+    @Inject(forwardRef(() => EntityServiceImpl))
+    private readonly entityServiceImpl: EntityServiceImpl,
+    @Inject(forwardRef(() => EntityMasterService))
+    private readonly entityMasterService: EntityMasterService,
+    private readonly listMasterRepo: ListMasterRepository,
+    private readonly listItemsRepo: ListMasterItemsRepository,
+    private readonly apiRegistryService: ApiRegistryService,
+    private readonly httpService: HttpService,
+    private readonly listMasterEngine: ListMasterEngine,
+    private readonly configService: ConfigService,
+  ) {}
+
+  private readonly skipLevelFilterEntities = ['BRN'];
+  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,
+    organization_id: number,
+  ): Promise<any> {
+    if (!code) return code;
+
+    // Check if it's a valid list type
+    const listMaster = await this.listItemsRepo.findItemByCode(
+      code,
+      organization_id,
+    );
+    if (listMaster) {
+      return listMaster;
+    }
+  }
+
+  async getDropdownOptions(
+    type: string,
+    params: Record<string, string>,
+    inactiveIdsArray?: number[],
+    loggedInUser?,
+    publicCall = false,
+  ) {
+    const config = await this.listMasterRepo.findByType(
+      type,
+      loggedInUser?.organization_id,
+    );
+
+    if (!config) throw new NotFoundException(`Type ${type} not found`);
+
+    if (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',
+            },
+          },
+        );
+
+        console.log('✅ Internal API response:', response.data);
+        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,
+          inactiveIdsArray,
+          loggedInUser,
+        );
+
+      case 'master':
+        return this.listItemsRepo.findItemsByType(
+          type,
+          config.sort_by,
+          inactiveIdsArray,
+          loggedInUser?.organization_id,
+          params,
+        );
+
+      case 'operator':
+        return this.listItemsRepo.findOperatorsByType(
+          type,
+          loggedInUser?.organization_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>,
+    inactiveIdsArray?: number[],
+    loggedInUser?: UserData,
+  ) {
+    console.log(
+      sourceList,
+      'sourceList',
+      params,
+      'params',
+      inactiveIdsArray,
+      'inactiveIdsArray',
+      loggedInUser,
+      'loggedInUser',
+    );
+    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}.organization_id = :organization_id`,
+            {
+              levelType: loggedInUser.level_type,
+              levelId: loggedInUser.level_id,
+              organization_id: loggedInUser.organization_id,
+            },
+          );
+        } else {
+          // IN the case of BRN, we don't filter by level
+          qb.andWhere(
+            `${tableName}.parent_id = :organization_id
+            AND ${tableName}.type = 'BRN'
+            `,
+            {
+              organization_id: loggedInUser.organization_id,
+            },
+          );
+        }
+      }
+
+      if (loggedInUser?.appcode && sourceList === 'ROL') {
+        if (!this.skipLevelFilterEntities.includes(sourceList)) {
+          qb.andWhere(`${tableName}.appcode = :appcode`, {
+            appcode: loggedInUser.appcode,
+          });
+        }
+      }
+
+      for (const key in params) {
+        qb.andWhere(`${tableName}.${key} = :${key}`, {
+          [key]: params[key],
+        });
+      }
+
+      return qb;
+    };
+
+    const resolveStatus = await this.getResolvedListCode(
+      STATUS_ACTIVE,
+      loggedInUser?.organization_id || 0,
+    );
+
+    // Fetpords
+    const activeQuery = applyCommonFilters(
+      this.entityManager
+        .createQueryBuilder()
+        .select('*')
+        .from(tableName, tableName),
+      resolveStatus.id,
+    );
+
+    const activeResults = await activeQuery.getRawMany();
+    const activeIds = new Set(activeResults.map((r) => r.id));
+
+    // Add active entries first
+    activeResults.forEach((r) => {
+      result.push({ label: r.name, value: r.id });
+    });
+
+    const resolveInactiveStatus = await this.getResolvedListCode(
+      STATUS_INACTIVE,
+      loggedInUser?.organization_id || 0,
+    );
+
+    // Fetch inactive records (with same filters but without status condition)
+    if (inactiveIdsArray?.length) {
+      const inactiveQuery = applyCommonFilters(
+        this.entityManager
+          .createQueryBuilder()
+          .select('*')
+          .from(tableName, tableName),
+        resolveInactiveStatus.id,
+      );
+
+      inactiveQuery.andWhere(`${tableName}.id IN (:...ids)`, {
+        ids: inactiveIdsArray,
+      });
+
+      const inactiveResults = await inactiveQuery.getRawMany();
+
+      // Add only those inactive records not already present in active
+      inactiveResults.forEach((item) => {
+        if (!activeIds.has(item.id)) {
+          result.push({
+            label: `${item.name} [INACTIVE]`,
+            value: item.id,
+          });
+        }
+      });
+    }
+
+    return result;
+  }
+
+  private async fetchFromExternalSource(
+    customSourceId: number,
+    params?: Record<string, string>,
+  ) {
+    const apiRegistry = await this.apiRegistryService.findById(customSourceId);
+    if (!apiRegistry) return [];
+
+    const url = `${apiRegistry.base_url}${apiRegistry.endpoint.replace(/{{(.*?)}}/g, (_, key) => params?.[key.trim()] || '')}`;
+    const payload = this.injectDynamicParams(
+      apiRegistry.request_payload_schema,
+      params,
+    );
+
+    const response = await firstValueFrom(
+      this.httpService.request({
+        url,
+        method: apiRegistry.http_method || 'POST',
+        data: payload,
+        headers: apiRegistry.headers ? apiRegistry.headers : undefined,
+      }),
+    );
+
+    const data = this.extractByPath(
+      response.data,
+      apiRegistry.response_data_path,
+    );
+
+    if (!Array.isArray(data)) {
+      return [{ label: data, value: data }];
+    }
+
+    if (typeof data[0] === 'string') {
+      return data.map((item: string) => ({ label: item, value: item }));
+    }
+
+    return data.map((item: any) => ({
+      label: item[apiRegistry?.label],
+      value: item[apiRegistry?.value],
+    }));
+  }
+
+  private injectDynamicParams(
+    payload: any,
+    params?: Record<string, string>,
+  ): any {
+    if (params) {
+      const stringified = JSON.stringify(payload);
+      const replaced = stringified.replace(
+        /{{(.*?)}}/g,
+        (_, key) => params[key.trim()] || '',
+      );
+      return JSON.parse(replaced);
+    }
+  }
+
+  private extractByPath(obj: any, path: string): any {
+    if (!path || !obj) return obj;
+
+    return path.split('.').reduce((acc, key) => {
+      if (acc == null) return undefined;
+
+      // Try to convert to number if it's a numeric string (for array indexes)
+      const index = Number(key);
+      if (!isNaN(index) && Array.isArray(acc)) {
+        return acc[index];
+      }
+
+      return acc[key];
+    }, obj);
+  }
+
+  // createEntity method
+  async createEntity(entityData: any, loggedInUser: UserData): Promise<any> {
+    // Trim and validate name and code
+    const name = entityData.name?.trim();
+    // const code = entityData.code?.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';
+    entityData.organization_id = loggedInUser.organization_id;
+
+    // Check for duplicate name
+    const nameExists = await this.listMasterRepo.findOneByCondition({
+      name,
+      organization_id: loggedInUser.organization_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(
+    organizationId: number,
+    search?: string,
+  ): Promise<any[]> {
+    return await this.listMasterRepo.findAllItems(organizationId, search);
+  }
+}