rez_core 6.5.75 → 6.5.77

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

@@ -1,11 +1,15 @@
-import { forwardRef, Inject, Injectable } from '@nestjs/common';
-import { DataSource, Repository } from 'typeorm';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import { DataSource, EntityManager, 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 { StorageType } from '../../../constant/storage-type.constant';
+import { BaseEntity } from '../entity/base-entity.entity';
+import { UserData } from '../../user/entity/user.entity';
+import { EntityDynamicService } from './entity-dynamic.service';
 
 @Injectable()
 export class EntityMasterService {
@@ -15,17 +19,143 @@ export class EntityMasterService {
     private attributeMasterRepo: AttributeMasterRepository,
     private entityMasterRepo: EntityMasterRepository,
     private readonly dataSource: DataSource,
+    @Inject('EntityDynamicService')
+    private readonly entityService: EntityDynamicService,
     @Inject('ListMasterService')
     private readonly listMasterService: ListMasterService,
     private readonly savedFilterRepoService: SavedFilterRepositoryService,
-  ) {}
+  ) {
+  }
+
+  /**
+   * Override createEntity to add dynamic table creation for SELF storage type
+   */
+  async createEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData | null,
+    manager?: EntityManager | null,
+  ) {
+    // Cast to EntityMaster to access specific fields
+    const entityMasterData = entityData as unknown as EntityMaster;
+
+    // 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) {
+      throw new BadRequestException('db_table_name is required');
+    }
+
+    // Validate that table name doesn't already exist
+    const existingByTable = await this.getEntityByTableName(entityMasterData.db_table_name);
+    if (existingByTable) {
+      throw new BadRequestException(
+        `Table with name "${entityMasterData.db_table_name}" already exists`,
+      );
+    }
+
+    // Validate that mapped_entity_type doesn't already exist for this enterprise
+    if (loggedInUser) {
+      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`,
+        );
+      }
+    }
+
+    // Create table if storage_type is SELF
+    if (entityMasterData.storage_type === StorageType.SELF) {
+      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 ${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);
+
+      // Create indexes for common query patterns
+      await queryRunner.query(
+        `CREATE INDEX idx_${tableName}_entity_type ON ${tableName}(entity_type)`,
+      );
+      await queryRunner.query(
+        `CREATE INDEX idx_${tableName}_code ON ${tableName}(code)`,
+      );
+      await queryRunner.query(
+        `CREATE INDEX idx_${tableName}_enterprise ON ${tableName}(enterprise_id)`,
+      );
+      await queryRunner.query(
+        `CREATE INDEX idx_${tableName}_parent ON ${tableName}(parent_type, parent_id)`,
+      );
+
+    } 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 getAllEntityDropDown(entity_type: string, loggedInUser): Promise<{ label: string; value: any }[]> {
+    return this.entityMasterRepo.getAllEntityDropdownData(entity_type, loggedInUser);
   }
 
   async getEntityData(
@@ -167,5 +297,4 @@ export class EntityMasterService {
     );
   }
 
-
 }

package/src/module/meta/service/media-data.service.ts

@@ -236,212 +236,6 @@ export class MediaDataService extends EntityServiceImpl {
     }
   }
 
-  public async buildUploadPathGenericdd(
-    mappedEntityType: string,
-    loggedInUser,
-    mappedEntityId?: number,
-    parentId?: number,
-    parentType?: string,
-  ) {
-    // 1️⃣ Fetch entity metadata
-    const entityMaster = await this.entityMasterService.getEntityData(
-      mappedEntityType,
-      loggedInUser,
-    );
-    if (!entityMaster) {
-      throw new Error(`Entity master not found for ${mappedEntityType}`);
-    }
-
-    let pathTemplate = entityMaster.doc_upload_path ?? '';
-    const entityOverwrite = entityMaster.overwrite_path ?? 0;
-
-    if (!pathTemplate) {
-      throw new Error(`doc_upload_path not defined for ${mappedEntityType}`);
-    }
-
-    // 2️⃣ Prepare replacement map
-    const replacements: Record<string, string | null> = {};
-
-    // --- ORG ---
-    const organizationRepo =
-      this.reflectionHelper.getRepoService('OrganizationData');
-    let organizationData = await organizationRepo.findOne({
-      where: {
-        id: loggedInUser.organization_id,
-      },
-    });
-
-    replacements['org_code'] = organizationData.code;
-
-    // --- LEVEL CODE ---
-    // Priority: If parent is provided, use parent for level_code; otherwise use normal logic
-    let levelEntityId: number;
-    let levelEntityType: string;
-
-    if (parentId && parentType) {
-      // When parent is provided, parent becomes the level_code
-      levelEntityId = parentId;
-      levelEntityType = parentType;
-    } else {
-      // Normal logic: determine which entity to use for level_code
-      levelEntityId = entityOverwrite ? mappedEntityId : loggedInUser.level_id;
-      levelEntityType = entityOverwrite
-        ? mappedEntityType
-        : loggedInUser.level_type;
-    }
-
-    // Get entity data for level_code
-    const getEntityData = await this.entityMasterService.getEntityData(
-      levelEntityType,
-      loggedInUser,
-    );
-
-    if (!getEntityData) return null;
-    const levelEntityDataResult = await this.entityManager.query(
-      `SELECT *
-       FROM ${getEntityData?.db_table_name}
-       WHERE id = $1`,
-      [levelEntityId],
-    );
-
-    const levelEntityData = levelEntityDataResult[0] || null;
-
-    if (levelEntityData?.code) {
-      replacements['level_code'] = levelEntityData.code; // universal alias
-    }
-
-    // --- MAPPED ENTITY CODE (when parent is provided) ---
-    // When parent is provided, the mapped entity becomes an additional level
-    if (parentId && parentType && mappedEntityId && mappedEntityType) {
-      const mappedEntityKey = `${mappedEntityType.toLowerCase()}_code`;
-      const mappedEntityData = await super.getEntityData(
-        mappedEntityType,
-        mappedEntityId,
-        loggedInUser,
-      );
-      if (mappedEntityData?.code) {
-        replacements[mappedEntityKey] = mappedEntityData.code;
-
-        // Modify path template to include mapped entity
-        // Example: ${org_code}/${level_code} becomes ${org_code}/${level_code}/${tem_code}
-        const mappedVariable = `\${${mappedEntityKey}}`;
-        if (!pathTemplate.includes(mappedVariable)) {
-          pathTemplate = pathTemplate + `/${mappedVariable}`;
-        }
-      }
-    }
-
-    // --- TEMPLATE CODE (if parent is provided) ---
-    // Special handling for template_code when parent_id and parent_type are provided
-    if (parentId && parentType) {
-      // const templateEntityData = await super.getEntityData(
-      //   parentType,
-      //   parentId,
-      //   loggedInUser,
-      // );
-
-      // Get entity data for level_code
-      const getEntityData = await this.entityMasterService.getEntityData(
-        mappedEntityType,
-        loggedInUser,
-      );
-
-      if (!getEntityData) return null;
-      const levelEntityDataResult = await this.entityManager.query(
-        `SELECT *
-         FROM ${getEntityData?.db_table_name}
-         WHERE id = $1`,
-        [mappedEntityId],
-      );
-
-      if (
-        levelEntityDataResult?.[0].code &&
-        parentType != 'SCH' &&
-        loggedInUser.level_type != 'SCH'
-      ) {
-        replacements['template_code'] = levelEntityDataResult[0].code;
-        // If we have parent template, modify the path to include it
-        pathTemplate = '${org_code}/template/${template_code}';
-      } else {
-        const getEntityData = await this.entityMasterService.getEntityData(
-          mappedEntityType,
-          loggedInUser,
-        );
-
-        if (!getEntityData) return null;
-        const levelEntityDataResult = await this.entityManager.query(
-          `SELECT *
-           FROM ${getEntityData?.db_table_name}
-           WHERE id = $1`,
-          [mappedEntityId],
-        );
-
-        replacements['template_code'] = levelEntityDataResult?.[0].code;
-
-        pathTemplate = '${org_code}/${level_code}/template/${template_code}';
-      }
-    }
-
-    // --- Dynamic variables inside path ---
-    const matches = pathTemplate.match(/\$\{(\w+)\}/g) || [];
-
-    for (const variable of matches) {
-      const key = variable.replace(/\$\{|\}/g, '');
-      if (replacements[key]) continue; // already resolved
-
-      if (key === 'org_code') continue; // already set
-      if (key === 'level_code') continue; // already set above
-      if (key === 'template_code') continue; // handled above if parent is provided
-
-      if (key.endsWith('_code')) {
-        // derive entity type dynamically
-        const entityType = key.replace('_code', '').toUpperCase();
-
-        let entityId: number | undefined;
-
-        // Special handling for template_code - use parent if available, otherwise mapped entity
-        if (key === 'template_code') {
-          if (parentType?.toUpperCase() === 'TEMPLATE' && parentId) {
-            entityId = parentId;
-          } else if (mappedEntityType === 'TEMPLATE') {
-            entityId = mappedEntityId;
-          }
-        } else {
-          // For other _code variables, check if parent matches the entity type
-          if (parentType?.toUpperCase() === entityType && parentId) {
-            entityId = parentId;
-          } else if (mappedEntityType === entityType) {
-            entityId = mappedEntityId;
-          }
-        }
-
-        // Generic lookup
-        if (entityId) {
-          const entityData = await super.getEntityData(
-            entityType,
-            entityId,
-            loggedInUser,
-          );
-          replacements[key] = entityData?.code ?? null;
-        }
-      }
-    }
-
-    // --- ORG special case ---
-    // If ORG level & overwrite = 0 → use org_code, otherwise use the mapped entity's code
-    if (loggedInUser.level_type === 'ORG' && entityOverwrite === 0) {
-      // When overwrite is 0 and user is ORG level, but we want to use mapped entity
-      // Don't set level_code to null - it should already be set above based on entityOverwrite logic
-    }
-
-    // 3️⃣ Final substitution and cleanup
-    if (pathTemplate) {
-      const finalPath = this.resolveUploadPath(pathTemplate, replacements);
-      return finalPath;
-    }
-    return null;
-  }
-
   public async buildUploadPathGeneric(
     mappedEntityType: string,
     loggedInUser,