rez_core 5.0.84 → 5.0.86

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

@@ -1,525 +1,525 @@
-import { EntityService } from './entity.service';
-import {
-  BadRequestException,
-  forwardRef,
-  Inject,
-  Injectable,
-  NotFoundException,
-} from '@nestjs/common';
-import { UserData } from '../../user/entity/user.entity';
-import { EntityMasterService } from './entity-master.service';
-import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
-import { BaseEntity } from '../entity/base-entity.entity';
-import { LoggingService } from '../../../utils/service/loggingUtil.service';
-import { EntityListData } from '../dto/entity-list-data.dto';
-import { EntityListService } from './entity-list.service';
-import { EntityManager } from 'typeorm';
-import { ExcelData } from '../../../utils/dto/excel-data.dto';
-import * as fs from 'fs';
-import * as path from 'path';
-import { ExcelHelper } from '../../../utils/service/excel-helper.service';
-import { ExcelsheetData } from '../../../utils/dto/excelsheet-data.dto';
-import { EntityTableService } from './entity-table.service';
-import { EntityTableColumnService } from './entity-table-column.service';
-import {
-  ENTITYTYPE_ENTITYMASTER,
-  STATUS_ACTIVE,
-} from '../../../constant/global.constant';
-import { EntityValidationService } from './entity-validation.service';
-import { AttributeMasterService } from './attribute-master.service';
-import { ResolverService } from './resolver.service';
-
-@Injectable()
-export class EntityServiceImpl implements EntityService<BaseEntity> {
-  @Inject() protected readonly entityMasterService: EntityMasterService;
-  @Inject()
-  protected readonly entityTableColumnService: EntityTableColumnService;
-  @Inject() protected readonly entityTableService: EntityTableService;
-  @Inject() protected readonly reflectionHelper: ReflectionHelper;
-  @Inject() protected readonly entityListService: EntityListService;
-  @Inject() protected readonly loggingService: LoggingService;
-  @Inject()
-  protected readonly entityValidationService: EntityValidationService;
-  protected readonly attributeMasterService: AttributeMasterService;
-  @Inject(forwardRef(() => ResolverService))
-  protected readonly resolverService: ResolverService;
-
-  async createEntity(
-    entityData: BaseEntity,
-    loggedInUser: UserData | null,
-    manager?: EntityManager | null,
-    appcode?: string,
-  ) {
-    if (!entityData.entity_type) {
-      throw new BadRequestException(`EntityType is missing`);
-    }
-    const entityMaster = await this.entityMasterService.getEntityData(
-      entityData.entity_type,
-      loggedInUser,
-    );
-
-    const validationErrors =
-      await this.entityValidationService.validateEntityData(
-        entityData,
-        entityMaster,
-        loggedInUser,
-      );
-    console.log('Validation Errors:', validationErrors); // Debug log
-    if (validationErrors && validationErrors.length > 0) {
-      return {
-        success: false,
-        message: 'Validation failed',
-        errors: validationErrors,
-      };
-    }
-
-    const repo = manager
-      ? manager.getRepository(entityMaster.entity_data_class) // <-- Use transaction-safe repo
-      : this.reflectionHelper.getRepoService(entityMaster.entity_data_class);
-
-    if (!repo) {
-      throw new Error(
-        `Repository service not found for entityType: ${entityData.entity_type}`,
-      );
-    }
-
-    if (!entityData.code && loggedInUser) {
-      let maxSeqNo = await this.getMaxSequenceNumber(
-        entityData.entity_type,
-        entityData.parent_id,
-        entityData.parent_type,
-        loggedInUser,
-      );
-      maxSeqNo = Number(maxSeqNo) + 1;
-      entityData.code = entityData.entity_type + maxSeqNo;
-    }
-
-    // const resolveStatus = await this.listMasterService.getResolvedListCode(
-    //   STATUS_ACTIVE,
-    //   loggedInUser?.organization_id || 0,
-    // );
-
-    const statusList = await repo.query(
-      `SELECT id
-       FROM frm_list_master_items
-       WHERE code = $1
-         AND organization_id = $2`,
-      [STATUS_ACTIVE, loggedInUser?.organization_id || 0],
-    );
-
-    console.log('Status List:', statusList); // Debug log
-    console.log(
-      `status_code,${STATUS_ACTIVE},statusList, ${loggedInUser?.organization_id}`,
-    ); // Debug log
-
-    entityData.created_date = new Date();
-    if (loggedInUser) {
-      entityData.created_by = loggedInUser.id;
-      if (!entityData.organization_id)
-        entityData.organization_id = loggedInUser.organization_id;
-      if (!entityData.enterprise_id)
-        entityData.enterprise_id = loggedInUser.enterprise_id;
-      if (!entityData.level_type)
-        entityData.level_type = loggedInUser.level_type;
-      if (!entityData.level_id) entityData.level_id = loggedInUser.level_id;
-      if (!entityData.status) entityData.status = statusList[0].id;
-    }
-
-    let savedData = repo.save(entityData);
-
-    return savedData;
-  }
-
-  async deleteEntity(entityType: string, entityId: number, loggedInUser) {
-    const entityMaster = await this.entityMasterService.getEntityData(
-      entityType,
-      loggedInUser,
-    );
-
-    const repoService = this.reflectionHelper.getRepoService(
-      entityMaster.entity_data_class,
-    );
-    if (!repoService) {
-      throw new Error(
-        `Repository service not found for entityType: ${entityType}`,
-      );
-    }
-
-    const entityData = await repoService.findOne({ where: { id: entityId } });
-
-    if (!entityData) {
-      throw new Error(`Entity not found for entityType: ${entityType}`);
-    }
-
-    await repoService.delete(entityId);
-
-    return {
-      success: true,
-      message: `Entity with id ${entityId} deleted successfully.`,
-    };
-  }
-
-  async findByCode(
-    entityType: string,
-    code: string,
-    loggedInUser,
-  ): Promise<BaseEntity> {
-    const entityData = await this.entityMasterService.getEntityData(
-      entityType,
-      loggedInUser,
-    );
-
-    const repoService = this.reflectionHelper.getRepoService(
-      entityData.entity_data_class,
-    );
-    if (!repoService) {
-      throw new Error(
-        `Repository service not found for entityType: ${entityType}`,
-      );
-    }
-    const result = await repoService?.findOne({ where: { code: code } });
-
-    if (!result) {
-      throw new Error(`Entity not found for entityType: ${entityType}`);
-    }
-    return result;
-  }
-
-  async getEntityData(
-    entityType: string,
-    id: number,
-    loggedInUser,
-  ): Promise<any> {
-    const entityData = await this.entityMasterService.getEntityData(
-      entityType,
-      loggedInUser,
-    );
-
-    const repoService = this.reflectionHelper.getRepoService(
-      entityData.entity_data_class,
-    );
-    if (!repoService) {
-      throw new Error(
-        `Repository service not found for entityType: ${entityType}`,
-      );
-    }
-    return await repoService.findOne({ where: { id: id } });
-  }
-
-  async getEntityDataAll(
-    entityType: string,
-    type: {},
-    loggedInUser: UserData,
-  ): Promise<BaseEntity[] | null> {
-    const entityData = await this.entityMasterService.getEntityData(
-      entityType,
-      loggedInUser,
-    );
-
-    const repoService = this.reflectionHelper.getRepoService(
-      entityData.entity_data_class,
-    );
-    if (!repoService) {
-      throw new Error(
-        `Repository service not found for entityType: ${entityType}`,
-      );
-    }
-    return await repoService.find({ where: type });
-  }
-
-  async getEntityDataByCode(
-    entityType: string,
-    code: string,
-    loggedInUser: UserData,
-  ): Promise<BaseEntity | null> {
-    const entityData = await this.entityMasterService.getEntityData(
-      entityType,
-      loggedInUser,
-    );
-
-    const repoService = this.reflectionHelper.getRepoService(
-      entityData.entity_data_class,
-    );
-    if (!repoService) {
-      throw new BadRequestException(
-        `Repository service not found for entityType: ${entityType}`,
-      );
-    }
-    const data = await repoService.findOne({ where: { code: code } });
-
-    if (!data) {
-      throw new NotFoundException(`Data not found for Code: ${code}`);
-    }
-    return data;
-  }
-
-  async getEntityList(
-    entityType: string,
-    filters: Record<string, any> = {},
-    loggedInUser: UserData,
-  ): Promise<BaseEntity[]> {
-    const entityData = await this.entityMasterService.getEntityData(
-      entityType,
-      loggedInUser,
-    );
-    const repoService = this.reflectionHelper.getRepoService(
-      entityData.entity_data_class,
-    );
-
-    if (!repoService) {
-      throw new Error(
-        `Repository service not found for entityType: ${entityType}`,
-      );
-    }
-
-    const result = await repoService.find({
-      where: filters,
-    });
-
-    return result;
-  }
-
-  async updateEntity(
-    entityData: BaseEntity,
-    loggedInUser: UserData,
-    appcode?: string,
-  ) {
-    const entityMaster = await this.entityMasterService.getEntityData(
-      entityData.entity_type,
-      loggedInUser,
-    );
-
-    const validationErrors =
-      await this.entityValidationService.validateEntityData(
-        entityData,
-        entityMaster,
-        loggedInUser,
-      );
-    console.log('Validation Errors For Update:', validationErrors); // Debug log
-    if (validationErrors && validationErrors.length > 0) {
-      return {
-        success: false,
-        message: 'Validation failed',
-        errors: validationErrors,
-      };
-    }
-
-    const repoService = this.reflectionHelper.getRepoService(
-      entityMaster.entity_data_class,
-    );
-    if (!repoService) {
-      throw new Error(
-        `Repository service not found for entityType: ${entityData.entity_type}`,
-      );
-    }
-
-    entityData.modified_date = new Date();
-    if (loggedInUser) {
-      entityData.modified_by = loggedInUser.id;
-      if (!entityData.organization_id && entityData.entity_type !== 'ORG')
-        entityData.organization_id = loggedInUser.organization_id;
-      if (!entityData.enterprise_id)
-        entityData.enterprise_id = loggedInUser.enterprise_id;
-    }
-    await repoService.update(entityData.id, entityData);
-    return await repoService.findOne({ where: { id: entityData.id } });
-  }
-
-  async getFilterDataWithTabs(
-    entityType: string,
-    listType: string,
-    filters: Record<string, any>,
-    sortColumn: string | undefined,
-    sortOrder: string | undefined,
-    pageNumber: number,
-    pageSize: number,
-    tabColumn?: string,
-    tabValue?: string,
-    appcode?: string,
-  ): Promise<EntityListData> {
-    return await this.entityListService.getFilterDataWithTabs(
-      entityType,
-      listType,
-      filters,
-      sortColumn,
-      sortOrder,
-      pageNumber,
-      pageSize,
-      tabColumn,
-      tabValue,
-      appcode,
-    );
-  }
-
-  async generateExcelReport(
-    entityType: string,
-    filterCriteria: Record<string, any>,
-    listEntityType: string,
-    displayType: string,
-    sampleExport: boolean,
-    loggedInUser: UserData,
-  ): Promise<string | null> {
-    let fileName: string;
-    try {
-      const excelData = new ExcelData();
-      await this.populateExcelData(
-        excelData,
-        entityType,
-        filterCriteria,
-        listEntityType,
-        displayType,
-        sampleExport,
-        loggedInUser,
-      );
-
-      const modifiedDate = new Date().toISOString().replace(/[-T:.Z]/g, '');
-      const tempDir = path.join(__dirname, '../../temp');
-      if (!fs.existsSync(tempDir)) {
-        fs.mkdirSync(tempDir, { recursive: true });
-      }
-      fileName = path.join(tempDir, `export_${modifiedDate}.xlsx`);
-      excelData.filePath = fileName;
-      ExcelHelper.writeExcel(excelData);
-    } catch (error) {
-      throw error;
-    }
-    return fileName;
-  }
-
-  private async populateExcelData(
-    excelData: ExcelData,
-    entityType: string,
-    filterCriteria: Record<string, any>,
-    listEntityType: string,
-    displayType: string,
-    sampleExport: boolean,
-    loggedInUser: UserData,
-  ) {
-    const entityTable =
-      await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
-        entityType,
-        listEntityType,
-        displayType,
-        loggedInUser.organization_id,
-      );
-    const sheet: ExcelsheetData = {
-      sheetName: entityTable?.data_source || 'sheet',
-      headers: [],
-      rowList: [],
-    };
-
-    if (entityTable) {
-      const entityTableColumnList =
-        await this.entityTableColumnService.findByParentIdAndParentType(
-          entityTable.id,
-          entityTable.entity_type,
-          loggedInUser.organization_id,
-        );
-
-      sheet.headers = entityTableColumnList.map((col) => col.name);
-      const attributeList = entityTableColumnList.map(
-        (col) => col.attribute_key,
-      );
-
-      let filteredList: any[] = [];
-      if (!sampleExport) {
-        filteredList = await this.entityListService.getFilteredList(
-          entityTable,
-          filterCriteria,
-          undefined,
-          undefined,
-          undefined,
-          undefined,
-        );
-      }
-
-      sheet.rowList = filteredList.map((item) =>
-        attributeList.map((attr) =>
-          item[attr] !== undefined ? item[attr] : null,
-        ),
-      );
-      excelData.addSheet(sheet);
-    }
-  }
-
-  private async getMaxSequenceNumber(
-    entityType: string,
-    parentId: number,
-    parentType: string,
-    loggedInUser: UserData,
-  ): Promise<number> {
-    let tableName: string;
-    if (ENTITYTYPE_ENTITYMASTER === entityType) {
-      tableName = 'frm_entity_master';
-    } else {
-      const entityMaster = await this.entityMasterService.getEntityData(
-        entityType,
-        loggedInUser,
-      );
-      tableName = entityMaster.db_table_name;
-    }
-    return await this.entityListService.getMaxSequenceNumber(
-      tableName,
-      parentType,
-      parentId,
-    );
-  }
-
-  async getSingleResolvedData(
-    loggedInUser: UserData,
-    entityData: any,
-    entityType: string,
-  ): Promise<any> {
-    return this.resolverService.getResolvedData(
-      loggedInUser,
-      entityData,
-      entityType,
-    );
-  }
-
-  async getResolvedEntityData(
-    entityType: string,
-    entityId: number,
-    loggedInUser: UserData,
-  ): Promise<any> {
-    const entityData = await this.entityMasterService.getEntityData(
-      entityType,
-      loggedInUser,
-    );
-
-    const repoService = this.reflectionHelper.getRepoService(
-      entityData.entity_data_class,
-    );
-
-    if (!repoService) {
-      throw new Error(
-        `Repository service not found for entityType: ${entityType}`,
-      );
-    }
-    const data = await repoService.findOne({ where: { id: entityId } });
-
-    return this.resolverService.getResolvedData(loggedInUser, data, entityType);
-  }
-
-  async getResolvedEntityDataByDataSource(
-    entityType: string,
-    entityId: number,
-    loggedInUser: UserData,
-  ): Promise<any> {
-    const entityData = await this.entityMasterService.getEntityData(
-      entityType,
-      loggedInUser,
-    );
-
-    if (!entityData.data_source) {
-      throw new Error('Database table name is missing in entity master.');
-    }
-
-    const data = await this.reflectionHelper.getEntityData(
-      entityId,
-      entityData.data_source,
-    );
-
-    return this.resolverService.getResolvedData(loggedInUser, data, entityType);
-  }
-}
+import { EntityService } from './entity.service';
+import {
+  BadRequestException,
+  forwardRef,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { UserData } from '../../user/entity/user.entity';
+import { EntityMasterService } from './entity-master.service';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
+import { BaseEntity } from '../entity/base-entity.entity';
+import { LoggingService } from '../../../utils/service/loggingUtil.service';
+import { EntityListData } from '../dto/entity-list-data.dto';
+import { EntityListService } from './entity-list.service';
+import { EntityManager } from 'typeorm';
+import { ExcelData } from '../../../utils/dto/excel-data.dto';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ExcelHelper } from '../../../utils/service/excel-helper.service';
+import { ExcelsheetData } from '../../../utils/dto/excelsheet-data.dto';
+import { EntityTableService } from './entity-table.service';
+import { EntityTableColumnService } from './entity-table-column.service';
+import {
+  ENTITYTYPE_ENTITYMASTER,
+  STATUS_ACTIVE,
+} from '../../../constant/global.constant';
+import { EntityValidationService } from './entity-validation.service';
+import { AttributeMasterService } from './attribute-master.service';
+import { ResolverService } from './resolver.service';
+
+@Injectable()
+export class EntityServiceImpl implements EntityService<BaseEntity> {
+  @Inject() protected readonly entityMasterService: EntityMasterService;
+  @Inject()
+  protected readonly entityTableColumnService: EntityTableColumnService;
+  @Inject() protected readonly entityTableService: EntityTableService;
+  @Inject() protected readonly reflectionHelper: ReflectionHelper;
+  @Inject() protected readonly entityListService: EntityListService;
+  @Inject() protected readonly loggingService: LoggingService;
+  @Inject()
+  protected readonly entityValidationService: EntityValidationService;
+  protected readonly attributeMasterService: AttributeMasterService;
+  @Inject(forwardRef(() => ResolverService))
+  protected readonly resolverService: ResolverService;
+
+  async createEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData | null,
+    manager?: EntityManager | null,
+    appcode?: string,
+  ) {
+    if (!entityData.entity_type) {
+      throw new BadRequestException(`EntityType is missing`);
+    }
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityData.entity_type,
+      loggedInUser,
+    );
+
+    const validationErrors =
+      await this.entityValidationService.validateEntityData(
+        entityData,
+        entityMaster,
+        loggedInUser,
+      );
+    console.log('Validation Errors:', validationErrors); // Debug log
+    if (validationErrors && validationErrors.length > 0) {
+      return {
+        success: false,
+        message: 'Validation failed',
+        errors: validationErrors,
+      };
+    }
+
+    const repo = manager
+      ? manager.getRepository(entityMaster.entity_data_class) // <-- Use transaction-safe repo
+      : this.reflectionHelper.getRepoService(entityMaster.entity_data_class);
+
+    if (!repo) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityData.entity_type}`,
+      );
+    }
+
+    if (!entityData.code && loggedInUser) {
+      let maxSeqNo = await this.getMaxSequenceNumber(
+        entityData.entity_type,
+        entityData.parent_id,
+        entityData.parent_type,
+        loggedInUser,
+      );
+      maxSeqNo = Number(maxSeqNo) + 1;
+      entityData.code = entityData.entity_type + maxSeqNo;
+    }
+
+    // const resolveStatus = await this.listMasterService.getResolvedListCode(
+    //   STATUS_ACTIVE,
+    //   loggedInUser?.organization_id || 0,
+    // );
+
+    const statusList = await repo.query(
+      `SELECT id
+       FROM frm_list_master_items
+       WHERE code = $1
+         AND organization_id = $2`,
+      [STATUS_ACTIVE, loggedInUser?.organization_id || 0],
+    );
+
+    console.log('Status List:', statusList); // Debug log
+    console.log(
+      `status_code,${STATUS_ACTIVE},statusList, ${loggedInUser?.organization_id}`,
+    ); // Debug log
+
+    entityData.created_date = new Date();
+    if (loggedInUser) {
+      entityData.created_by = loggedInUser.id;
+      if (!entityData.organization_id)
+        entityData.organization_id = loggedInUser.organization_id;
+      if (!entityData.enterprise_id)
+        entityData.enterprise_id = loggedInUser.enterprise_id;
+      if (!entityData.level_type)
+        entityData.level_type = loggedInUser.level_type;
+      if (!entityData.level_id) entityData.level_id = loggedInUser.level_id;
+      if (!entityData.status) entityData.status = statusList[0].id;
+    }
+
+    let savedData = repo.save(entityData);
+
+    return savedData;
+  }
+
+  async deleteEntity(entityType: string, entityId: number, loggedInUser) {
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
+
+    const repoService = this.reflectionHelper.getRepoService(
+      entityMaster.entity_data_class,
+    );
+    if (!repoService) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityType}`,
+      );
+    }
+
+    const entityData = await repoService.findOne({ where: { id: entityId } });
+
+    if (!entityData) {
+      throw new Error(`Entity not found for entityType: ${entityType}`);
+    }
+
+    await repoService.delete(entityId);
+
+    return {
+      success: true,
+      message: `Entity with id ${entityId} deleted successfully.`,
+    };
+  }
+
+  async findByCode(
+    entityType: string,
+    code: string,
+    loggedInUser,
+  ): Promise<BaseEntity> {
+    const entityData = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
+
+    const repoService = this.reflectionHelper.getRepoService(
+      entityData.entity_data_class,
+    );
+    if (!repoService) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityType}`,
+      );
+    }
+    const result = await repoService?.findOne({ where: { code: code } });
+
+    if (!result) {
+      throw new Error(`Entity not found for entityType: ${entityType}`);
+    }
+    return result;
+  }
+
+  async getEntityData(
+    entityType: string,
+    id: number,
+    loggedInUser,
+  ): Promise<any> {
+    const entityData = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
+
+    const repoService = this.reflectionHelper.getRepoService(
+      entityData.entity_data_class,
+    );
+    if (!repoService) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityType}`,
+      );
+    }
+    return await repoService.findOne({ where: { id: id } });
+  }
+
+  async getEntityDataAll(
+    entityType: string,
+    type: {},
+    loggedInUser: UserData,
+  ): Promise<BaseEntity[] | null> {
+    const entityData = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
+
+    const repoService = this.reflectionHelper.getRepoService(
+      entityData.entity_data_class,
+    );
+    if (!repoService) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityType}`,
+      );
+    }
+    return await repoService.find({ where: type });
+  }
+
+  async getEntityDataByCode(
+    entityType: string,
+    code: string,
+    loggedInUser: UserData,
+  ): Promise<BaseEntity | null> {
+    const entityData = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
+
+    const repoService = this.reflectionHelper.getRepoService(
+      entityData.entity_data_class,
+    );
+    if (!repoService) {
+      throw new BadRequestException(
+        `Repository service not found for entityType: ${entityType}`,
+      );
+    }
+    const data = await repoService.findOne({ where: { code: code } });
+
+    if (!data) {
+      throw new NotFoundException(`Data not found for Code: ${code}`);
+    }
+    return data;
+  }
+
+  async getEntityList(
+    entityType: string,
+    filters: Record<string, any> = {},
+    loggedInUser: UserData,
+  ): Promise<BaseEntity[]> {
+    const entityData = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
+    const repoService = this.reflectionHelper.getRepoService(
+      entityData.entity_data_class,
+    );
+
+    if (!repoService) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityType}`,
+      );
+    }
+
+    const result = await repoService.find({
+      where: filters,
+    });
+
+    return result;
+  }
+
+  async updateEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData,
+    appcode?: string,
+  ) {
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityData.entity_type,
+      loggedInUser,
+    );
+
+    const validationErrors =
+      await this.entityValidationService.validateEntityData(
+        entityData,
+        entityMaster,
+        loggedInUser,
+      );
+    console.log('Validation Errors For Update:', validationErrors); // Debug log
+    if (validationErrors && validationErrors.length > 0) {
+      return {
+        success: false,
+        message: 'Validation failed',
+        errors: validationErrors,
+      };
+    }
+
+    const repoService = this.reflectionHelper.getRepoService(
+      entityMaster.entity_data_class,
+    );
+    if (!repoService) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityData.entity_type}`,
+      );
+    }
+
+    entityData.modified_date = new Date();
+    if (loggedInUser) {
+      entityData.modified_by = loggedInUser.id;
+      if (!entityData.organization_id && entityData.entity_type !== 'ORG')
+        entityData.organization_id = loggedInUser.organization_id;
+      if (!entityData.enterprise_id)
+        entityData.enterprise_id = loggedInUser.enterprise_id;
+    }
+    await repoService.update(entityData.id, entityData);
+    return await repoService.findOne({ where: { id: entityData.id } });
+  }
+
+  async getFilterDataWithTabs(
+    entityType: string,
+    listType: string,
+    filters: Record<string, any>,
+    sortColumn: string | undefined,
+    sortOrder: string | undefined,
+    pageNumber: number,
+    pageSize: number,
+    tabColumn?: string,
+    tabValue?: string,
+    appcode?: string,
+  ): Promise<EntityListData> {
+    return await this.entityListService.getFilterDataWithTabs(
+      entityType,
+      listType,
+      filters,
+      sortColumn,
+      sortOrder,
+      pageNumber,
+      pageSize,
+      tabColumn,
+      tabValue,
+      appcode,
+    );
+  }
+
+  async generateExcelReport(
+    entityType: string,
+    filterCriteria: Record<string, any>,
+    listEntityType: string,
+    displayType: string,
+    sampleExport: boolean,
+    loggedInUser: UserData,
+  ): Promise<string | null> {
+    let fileName: string;
+    try {
+      const excelData = new ExcelData();
+      await this.populateExcelData(
+        excelData,
+        entityType,
+        filterCriteria,
+        listEntityType,
+        displayType,
+        sampleExport,
+        loggedInUser,
+      );
+
+      const modifiedDate = new Date().toISOString().replace(/[-T:.Z]/g, '');
+      const tempDir = path.join(__dirname, '../../temp');
+      if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true });
+      }
+      fileName = path.join(tempDir, `export_${modifiedDate}.xlsx`);
+      excelData.filePath = fileName;
+      ExcelHelper.writeExcel(excelData);
+    } catch (error) {
+      throw error;
+    }
+    return fileName;
+  }
+
+  private async populateExcelData(
+    excelData: ExcelData,
+    entityType: string,
+    filterCriteria: Record<string, any>,
+    listEntityType: string,
+    displayType: string,
+    sampleExport: boolean,
+    loggedInUser: UserData,
+  ) {
+    const entityTable =
+      await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
+        entityType,
+        listEntityType,
+        displayType,
+        loggedInUser.organization_id,
+      );
+    const sheet: ExcelsheetData = {
+      sheetName: entityTable?.data_source || 'sheet',
+      headers: [],
+      rowList: [],
+    };
+
+    if (entityTable) {
+      const entityTableColumnList =
+        await this.entityTableColumnService.findByParentIdAndParentType(
+          entityTable.id,
+          entityTable.entity_type,
+          loggedInUser.organization_id,
+        );
+
+      sheet.headers = entityTableColumnList.map((col) => col.name);
+      const attributeList = entityTableColumnList.map(
+        (col) => col.attribute_key,
+      );
+
+      let filteredList: any[] = [];
+      if (!sampleExport) {
+        filteredList = await this.entityListService.getFilteredList(
+          entityTable,
+          filterCriteria,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+        );
+      }
+
+      sheet.rowList = filteredList.map((item) =>
+        attributeList.map((attr) =>
+          item[attr] !== undefined ? item[attr] : null,
+        ),
+      );
+      excelData.addSheet(sheet);
+    }
+  }
+
+  private async getMaxSequenceNumber(
+    entityType: string,
+    parentId: number,
+    parentType: string,
+    loggedInUser: UserData,
+  ): Promise<number> {
+    let tableName: string;
+    if (ENTITYTYPE_ENTITYMASTER === entityType) {
+      tableName = 'frm_entity_master';
+    } else {
+      const entityMaster = await this.entityMasterService.getEntityData(
+        entityType,
+        loggedInUser,
+      );
+      tableName = entityMaster.db_table_name;
+    }
+    return await this.entityListService.getMaxSequenceNumber(
+      tableName,
+      parentType,
+      parentId,
+    );
+  }
+
+  async getSingleResolvedData(
+    loggedInUser: UserData,
+    entityData: any,
+    entityType: string,
+  ): Promise<any> {
+    return this.resolverService.getResolvedData(
+      loggedInUser,
+      entityData,
+      entityType,
+    );
+  }
+
+  async getResolvedEntityData(
+    entityType: string,
+    entityId: number,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    const entityData = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
+
+    const repoService = this.reflectionHelper.getRepoService(
+      entityData.entity_data_class,
+    );
+
+    if (!repoService) {
+      throw new Error(
+        `Repository service not found for entityType: ${entityType}`,
+      );
+    }
+    const data = await repoService.findOne({ where: { id: entityId } });
+
+    return this.resolverService.getResolvedData(loggedInUser, data, entityType);
+  }
+
+  async getResolvedEntityDataByDataSource(
+    entityType: string,
+    entityId: number,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    const entityData = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
+
+    if (!entityData.data_source) {
+      throw new Error('Database table name is missing in entity master.');
+    }
+
+    const data = await this.reflectionHelper.getEntityData(
+      entityId,
+      entityData.data_source,
+    );
+
+    return this.resolverService.getResolvedData(loggedInUser, data, entityType);
+  }
+}