rez_core 7.1.1 → 7.1.2

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

@@ -1,288 +1,288 @@
-import { BadRequestException, Inject, Injectable } from '@nestjs/common';
-import { DataSource, Repository } from 'typeorm';
-import { InjectRepository } from '@nestjs/typeorm';
-import { EntityMaster } from '../entity/entity-master.entity';
-import { EntityMasterRepository } from '../repository/entity-master.repository';
-import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
-import { SavedFilterRepositoryService } from 'src/module/filter/repository/saved-filter.repository';
-import { AttributeMasterRepository } from '../repository/attribute-master.repository';
-import { BaseEntity } from '../entity/base-entity.entity';
-import { UserData } from 'src/module/auth/dto/user.dto';
-import { ConfigService } from '@nestjs/config';
-import { EntityServiceImpl } from './entity-service-impl.service';
-import { StorageType } from '../../../constant/entity.constant';
-
-@Injectable()
-export class EntityMasterService {
-  schema: string | undefined;
-
-  constructor(
-    @InjectRepository(EntityMaster)
-    private entityMasterRepository: Repository<EntityMaster>,
-    private attributeMasterRepo: AttributeMasterRepository,
-    private entityMasterRepo: EntityMasterRepository,
-    private readonly dataSource: DataSource,
-    @Inject('ListMasterService')
-    private readonly listMasterService: ListMasterService,
-    private readonly savedFilterRepoService: SavedFilterRepositoryService,
-    private readonly configService: ConfigService,
-    private readonly entityService: EntityServiceImpl,
-  ) {
-    this.schema = this.configService.get('DB_SCHEMA');
-  }
-
-
-  /**
-   * Override createEntity to add dynamic table creation for SELF storage type
-   */
-  async createEntity(
-    entityData: BaseEntity,
-    loggedInUser: UserData | null,
-  ) {
-    // Cast to EntityMaster to access specific fields
-    const entityMasterData = entityData as unknown as EntityMaster;
-
-    const existingByType = await this.entityMasterRepository.findOne({
-      where: {
-        mapped_entity_type: entityMasterData.mapped_entity_type,
-        enterprise_id: loggedInUser?.enterprise_id,
-      },
-    });
-    if (existingByType) {
-      throw new BadRequestException(
-        `Entity with mapped_entity_type "${entityMasterData.mapped_entity_type}" already exists`,
-      );
-    }
-
-    // Validate required fields for entity master
-    if (!entityMasterData.mapped_entity_type) {
-      throw new BadRequestException('mapped_entity_type is required');
-    }
-    if (!entityMasterData.app_id) {
-      throw new BadRequestException('app_id is required');
-    }
-    if (!entityMasterData.storage_type) {
-      throw new BadRequestException('storage_type is required');
-    }
-    if (!entityMasterData.db_table_name && entityMasterData.storage_type == StorageType.SELF) {
-      throw new BadRequestException('db_table_name is required');
-    }
-
-    // Validate that table name doesn't already exist
-    if (StorageType.SELF === entityMasterData.storage_type) {
-
-      const existingByTable = await this.getEntityByTableName(entityMasterData.db_table_name);
-      if (existingByTable) {
-        throw new BadRequestException(
-          `Table with name "${entityMasterData.db_table_name}" already exists`,
-        );
-      }
-
-      await this.createDatabaseTable(
-        entityMasterData.db_table_name,
-      );
-    }
-
-    // Call parent createEntity method to handle standard entity creation
-    return await this.entityService.createEntity(entityData, loggedInUser);
-  }
-
-  /**
-   * Create a database table with all BaseEntity columns
-   */
-  private async createDatabaseTable(
-    tableName: string,
-  ): Promise<void> {
-    const queryRunner = this.dataSource.createQueryRunner();
-
-    try {
-      await queryRunner.connect();
-
-      // Check if table already exists
-      const tableExists = await queryRunner.hasTable(tableName);
-      if (tableExists) {
-        throw new BadRequestException(`Table "${tableName}" already exists in database`);
-      }
-
-      // Create table with all BaseEntity columns
-      const createTableQuery = `
-          CREATE TABLE ${this.schema}.${tableName}
-          (
-              id            BIGSERIAL PRIMARY KEY,
-              entity_type   VARCHAR(50),
-              code          VARCHAR(100),
-              name          VARCHAR(255),
-              description   VARCHAR(1000),
-              status        VARCHAR(50),
-              seq_no        BIGINT,
-              created_by    BIGINT,
-              created_date  TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-              modified_by   BIGINT,
-              modified_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-              enterprise_id INTEGER,
-              level_type    VARCHAR(25),
-              level_id      INTEGER,
-              parent_type   VARCHAR(100),
-              parent_id     BIGINT
-          )
-      `;
-
-      await queryRunner.query(createTableQuery);
-
-    } catch (error) {
-      throw new BadRequestException(
-        `Failed to create table "${tableName}": ${error.message}`,
-      );
-    } finally {
-      await queryRunner.release();
-    }
-  }
-
-  async getEntityById(id: number): Promise<EntityMaster | null> {
-    return this.entityMasterRepo.getEntityById(id);
-  }
-
-  async getAllEntityDropDown(entity_type: string, loggedInUser): Promise<{ label: string; value: any }[]> {
-    return this.entityMasterRepo.getAllEntityDropdownData(entity_type, loggedInUser);
-  }
-
-  async getEntityData(
-    mappedEntityType: string | null,
-    loggedInUser,
-    mapped_entity_id?: number,
-  ): Promise<EntityMaster> {
-    if (mappedEntityType) {
-      let filterCondition = {
-        mapped_entity_type: mappedEntityType,
-        enterprise_id: loggedInUser.enterprise_id,
-      };
-      if (mapped_entity_id) {
-        filterCondition['id'] = mapped_entity_id;
-      }
-      const entityMaster = await this.entityMasterRepository.findOne({
-        where: filterCondition,
-      });
-
-      if (!entityMaster) {
-        throw new Error(
-          `Entity with mappedEntityType "${mappedEntityType}" not found.`,
-        );
-      }
-
-      return entityMaster;
-    } else {
-      throw new Error();
-    }
-  }
-
-  async getEntityByTableName(tableName: string) {
-    const entityMaster = await this.entityMasterRepository.findOne({
-      where: { db_table_name: tableName },
-    });
-    return entityMaster;
-  }
-
-  async save(entityMaster: EntityMaster) {
-    return await this.entityMasterRepository.save(entityMaster);
-  }
-
-  async update(id: number, entityMaster: EntityMaster) {
-    return await this.entityMasterRepository.update(id, entityMaster);
-  }
-
-  async findByMappedEntityType(mappedEntityType: string) {
-    return await this.entityMasterRepository.findOne({
-      where: { mapped_entity_type: mappedEntityType },
-    });
-  }
-
-  async getFilterMetaData(entityType: string, loggedInUser: any) {
-    // Step 1: Get entity_master record by mapped_entity_type
-    const entityMasterData =
-      await this.entityMasterRepo.getEntityByMappedEntityType(
-        entityType,
-        loggedInUser.enterprise_id,
-      );
-
-    if (!entityMasterData) {
-      throw new Error(
-        `Entity master with mapped_entity_type "${entityType}" not found.`,
-      );
-    }
-
-    // Step 2: Get attribute_master (instead of entity_table_column)
-
-    const attributes = await this.attributeMasterRepo.findAttributesByMappedEntityType(entityMasterData.mapped_entity_type, loggedInUser);
-
-    // Step 3: Attach column_list from attribute_master
-    entityMasterData['attribute_list'] = attributes;
-
-    // Step 4: Keep existing operation_list logic
-    entityMasterData['operation_list'] = {
-      text: await this.listMasterService.getDropdownOptions(
-        'OPT',
-        {},
-        [],
-        loggedInUser,
-      ),
-      number: await this.listMasterService.getDropdownOptions(
-        'OPN',
-        {},
-        [],
-        loggedInUser,
-      ),
-      date: await this.listMasterService.getDropdownOptions(
-        'OPD',
-        {},
-        [],
-        loggedInUser,
-      ),
-      select: await this.listMasterService.getDropdownOptions(
-        'OPS',
-        {},
-        [],
-        loggedInUser,
-      ),
-      multiselect: await this.listMasterService.getDropdownOptions(
-        'OPM',
-        {},
-        [],
-        loggedInUser,
-      ),
-      year: await this.listMasterService.getDropdownOptions(
-        'OPY',
-        {},
-        [],
-        loggedInUser,
-      ),
-    };
-
-    // Step 5: Keep filters as is
-    entityMasterData['default_filter'] =
-      await this.savedFilterRepoService.getDefaultFilterByEntityType(
-        entityType,
-      );
-
-    if (loggedInUser.id) {
-      entityMasterData['saved_filter'] =
-        await this.savedFilterRepoService.getSavedFiltersByUserIdAndEntityType(
-          loggedInUser,
-          entityType,
-        );
-    }
-
-    return entityMasterData;
-  }
-
-  async getOperationList(loggedInUser: any) {
-    return await this.entityMasterRepo.getOperationList(loggedInUser);
-  }
-
-  async getAttributesOfTypeDate(entityType: string, loggedInUser: any) {
-    return await this.entityMasterRepo.getAttributesOfTypeDate(
-      entityType,
-      loggedInUser,
-    );
-  }
-
-}
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import { DataSource, Repository } from 'typeorm';
+import { InjectRepository } from '@nestjs/typeorm';
+import { EntityMaster } from '../entity/entity-master.entity';
+import { EntityMasterRepository } from '../repository/entity-master.repository';
+import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
+import { SavedFilterRepositoryService } from 'src/module/filter/repository/saved-filter.repository';
+import { AttributeMasterRepository } from '../repository/attribute-master.repository';
+import { BaseEntity } from '../entity/base-entity.entity';
+import { UserData } from 'src/module/auth/dto/user.dto';
+import { ConfigService } from '@nestjs/config';
+import { EntityServiceImpl } from './entity-service-impl.service';
+import { StorageType } from '../../../constant/entity.constant';
+
+@Injectable()
+export class EntityMasterService {
+  schema: string | undefined;
+
+  constructor(
+    @InjectRepository(EntityMaster)
+    private entityMasterRepository: Repository<EntityMaster>,
+    private attributeMasterRepo: AttributeMasterRepository,
+    private entityMasterRepo: EntityMasterRepository,
+    private readonly dataSource: DataSource,
+    @Inject('ListMasterService')
+    private readonly listMasterService: ListMasterService,
+    private readonly savedFilterRepoService: SavedFilterRepositoryService,
+    private readonly configService: ConfigService,
+    private readonly entityService: EntityServiceImpl,
+  ) {
+    this.schema = this.configService.get('DB_SCHEMA');
+  }
+
+
+  /**
+   * Override createEntity to add dynamic table creation for SELF storage type
+   */
+  async createEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData | null,
+  ) {
+    // Cast to EntityMaster to access specific fields
+    const entityMasterData = entityData as unknown as EntityMaster;
+
+    const existingByType = await this.entityMasterRepository.findOne({
+      where: {
+        mapped_entity_type: entityMasterData.mapped_entity_type,
+        enterprise_id: loggedInUser?.enterprise_id,
+      },
+    });
+    if (existingByType) {
+      throw new BadRequestException(
+        `Entity with mapped_entity_type "${entityMasterData.mapped_entity_type}" already exists`,
+      );
+    }
+
+    // Validate required fields for entity master
+    if (!entityMasterData.mapped_entity_type) {
+      throw new BadRequestException('mapped_entity_type is required');
+    }
+    if (!entityMasterData.app_id) {
+      throw new BadRequestException('app_id is required');
+    }
+    if (!entityMasterData.storage_type) {
+      throw new BadRequestException('storage_type is required');
+    }
+    if (!entityMasterData.db_table_name && entityMasterData.storage_type == StorageType.SELF) {
+      throw new BadRequestException('db_table_name is required');
+    }
+
+    // Validate that table name doesn't already exist
+    if (StorageType.SELF === entityMasterData.storage_type) {
+
+      const existingByTable = await this.getEntityByTableName(entityMasterData.db_table_name);
+      if (existingByTable) {
+        throw new BadRequestException(
+          `Table with name "${entityMasterData.db_table_name}" already exists`,
+        );
+      }
+
+      await this.createDatabaseTable(
+        entityMasterData.db_table_name,
+      );
+    }
+
+    // Call parent createEntity method to handle standard entity creation
+    return await this.entityService.createEntity(entityData, loggedInUser);
+  }
+
+  /**
+   * Create a database table with all BaseEntity columns
+   */
+  private async createDatabaseTable(
+    tableName: string,
+  ): Promise<void> {
+    const queryRunner = this.dataSource.createQueryRunner();
+
+    try {
+      await queryRunner.connect();
+
+      // Check if table already exists
+      const tableExists = await queryRunner.hasTable(tableName);
+      if (tableExists) {
+        throw new BadRequestException(`Table "${tableName}" already exists in database`);
+      }
+
+      // Create table with all BaseEntity columns
+      const createTableQuery = `
+          CREATE TABLE ${this.schema}.${tableName}
+          (
+              id            BIGSERIAL PRIMARY KEY,
+              entity_type   VARCHAR(50),
+              code          VARCHAR(100),
+              name          VARCHAR(255),
+              description   VARCHAR(1000),
+              status        VARCHAR(50),
+              seq_no        BIGINT,
+              created_by    BIGINT,
+              created_date  TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+              modified_by   BIGINT,
+              modified_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+              enterprise_id INTEGER,
+              level_type    VARCHAR(25),
+              level_id      INTEGER,
+              parent_type   VARCHAR(100),
+              parent_id     BIGINT
+          )
+      `;
+
+      await queryRunner.query(createTableQuery);
+
+    } catch (error) {
+      throw new BadRequestException(
+        `Failed to create table "${tableName}": ${error.message}`,
+      );
+    } finally {
+      await queryRunner.release();
+    }
+  }
+
+  async getEntityById(id: number): Promise<EntityMaster | null> {
+    return this.entityMasterRepo.getEntityById(id);
+  }
+
+  async getAllEntityDropDown(entity_type: string, loggedInUser): Promise<{ label: string; value: any }[]> {
+    return this.entityMasterRepo.getAllEntityDropdownData(entity_type, loggedInUser);
+  }
+
+  async getEntityData(
+    mappedEntityType: string | null,
+    loggedInUser,
+    mapped_entity_id?: number,
+  ): Promise<EntityMaster> {
+    if (mappedEntityType) {
+      let filterCondition = {
+        mapped_entity_type: mappedEntityType,
+        enterprise_id: loggedInUser.enterprise_id,
+      };
+      if (mapped_entity_id) {
+        filterCondition['id'] = mapped_entity_id;
+      }
+      const entityMaster = await this.entityMasterRepository.findOne({
+        where: filterCondition,
+      });
+
+      if (!entityMaster) {
+        throw new Error(
+          `Entity with mappedEntityType "${mappedEntityType}" not found.`,
+        );
+      }
+
+      return entityMaster;
+    } else {
+      throw new Error();
+    }
+  }
+
+  async getEntityByTableName(tableName: string) {
+    const entityMaster = await this.entityMasterRepository.findOne({
+      where: { db_table_name: tableName },
+    });
+    return entityMaster;
+  }
+
+  async save(entityMaster: EntityMaster) {
+    return await this.entityMasterRepository.save(entityMaster);
+  }
+
+  async update(id: number, entityMaster: EntityMaster) {
+    return await this.entityMasterRepository.update(id, entityMaster);
+  }
+
+  async findByMappedEntityType(mappedEntityType: string) {
+    return await this.entityMasterRepository.findOne({
+      where: { mapped_entity_type: mappedEntityType },
+    });
+  }
+
+  async getFilterMetaData(entityType: string, loggedInUser: any) {
+    // Step 1: Get entity_master record by mapped_entity_type
+    const entityMasterData =
+      await this.entityMasterRepo.getEntityByMappedEntityType(
+        entityType,
+        loggedInUser.enterprise_id,
+      );
+
+    if (!entityMasterData) {
+      throw new Error(
+        `Entity master with mapped_entity_type "${entityType}" not found.`,
+      );
+    }
+
+    // Step 2: Get attribute_master (instead of entity_table_column)
+
+    const attributes = await this.attributeMasterRepo.findAttributesByMappedEntityType(entityMasterData.mapped_entity_type, loggedInUser);
+
+    // Step 3: Attach column_list from attribute_master
+    entityMasterData['attribute_list'] = attributes;
+
+    // Step 4: Keep existing operation_list logic
+    entityMasterData['operation_list'] = {
+      text: await this.listMasterService.getDropdownOptions(
+        'OPT',
+        {},
+        [],
+        loggedInUser,
+      ),
+      number: await this.listMasterService.getDropdownOptions(
+        'OPN',
+        {},
+        [],
+        loggedInUser,
+      ),
+      date: await this.listMasterService.getDropdownOptions(
+        'OPD',
+        {},
+        [],
+        loggedInUser,
+      ),
+      select: await this.listMasterService.getDropdownOptions(
+        'OPS',
+        {},
+        [],
+        loggedInUser,
+      ),
+      multiselect: await this.listMasterService.getDropdownOptions(
+        'OPM',
+        {},
+        [],
+        loggedInUser,
+      ),
+      year: await this.listMasterService.getDropdownOptions(
+        'OPY',
+        {},
+        [],
+        loggedInUser,
+      ),
+    };
+
+    // Step 5: Keep filters as is
+    entityMasterData['default_filter'] =
+      await this.savedFilterRepoService.getDefaultFilterByEntityType(
+        entityType,
+      );
+
+    if (loggedInUser.id) {
+      entityMasterData['saved_filter'] =
+        await this.savedFilterRepoService.getSavedFiltersByUserIdAndEntityType(
+          loggedInUser,
+          entityType,
+        );
+    }
+
+    return entityMasterData;
+  }
+
+  async getOperationList(loggedInUser: any) {
+    return await this.entityMasterRepo.getOperationList(loggedInUser);
+  }
+
+  async getAttributesOfTypeDate(entityType: string, loggedInUser: any) {
+    return await this.entityMasterRepo.getAttributesOfTypeDate(
+      entityType,
+      loggedInUser,
+    );
+  }
+
+}

package/src/module/meta/service/entity-realation-data.service.ts

@@ -1,9 +1,9 @@
-import { Injectable } from '@nestjs/common';
-import { EntityServiceImpl } from './entity-service-impl.service';
-
-@Injectable()
-export class EntityRelationDataService extends EntityServiceImpl {
-  constructor() {
-    super();
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from './entity-service-impl.service';
+
+@Injectable()
+export class EntityRelationDataService extends EntityServiceImpl {
+  constructor() {
+    super();
+  }
+}