rez_core 7.1.1 → 7.1.2

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

@@ -1,329 +1,329 @@
-import { forwardRef, Inject, Injectable } from '@nestjs/common';
-import { AttributeMasterRepository } from '../repository/attribute-master.repository';
-import { UserData } from 'src/module/auth/dto/user.dto';
-import { AttributeMaster } from '../entity/attribute-master.entity';
-import { EntityServiceImpl } from './entity-service-impl.service';
-import { getDbColumnType, getDbDataTypeName } from '../../../constant/db-data-type.constant';
-import { AttributeStorageType } from '../../../constant/attribute.constant';
-import { StorageType } from '../../../constant/entity.constant';
-import { EntityMasterService } from './entity-master.service';
-import { EntityRelationRepository } from '../repository/entity-relation.repository';
-
-@Injectable()
-export class AttributeMasterService {
-  constructor(
-    private readonly attributeMasterRepository: AttributeMasterRepository,
-    @Inject(forwardRef(() => EntityServiceImpl))
-    private readonly entityServiceImpl: EntityServiceImpl,
-    @Inject('EntityMasterService')
-    private readonly entityMasterService: EntityMasterService,
-    private readonly entityRelationService: EntityRelationRepository,
-  ) {
-  }
-
-  async findAttributesByMappedEntityType(
-    entity_type: string,
-    loggedInUser: UserData,
-  ) {
-    return this.attributeMasterRepository.findAttributesByMappedEntityType(
-      entity_type,
-      loggedInUser,
-    );
-  }
-
-  /**
-   * Override createEntity to handle attribute-specific logic
-   * - Automatically sets db_datatype based on element_type
-   * - Creates database column if storage_type is DB_COL AND entity storage_type is SELF
-   */
-  async createEntity(
-    entityData: AttributeMaster,
-    loggedInUser: UserData | null,
-  ): Promise<AttributeMaster> {
-    // Automatically set db_datatype based on element_type
-    if (entityData.element_type) {
-      entityData.db_datatype = getDbDataTypeName(entityData.element_type);
-    }
-
-    // Only create DB column if attribute storage_type is DB_COL
-    if (AttributeStorageType.DB_COL.toLowerCase() === entityData.storage_type.toLowerCase() && loggedInUser) {
-      // Get the table name and storage type from entity_master
-      const entityInfo = await this.attributeMasterRepository.getTableNameByEntityType(
-        entityData.mapped_entity_type,
-        loggedInUser,
-      );
-
-      if (!entityInfo.tableName) {
-        throw new Error(
-          `No table found for entity type ${entityData.mapped_entity_type}`,
-        );
-      }
-
-      // Only add column if entity storage_type is SELF (has its own table)
-      if (entityInfo.storageType?.toLowerCase() === StorageType.SELF.toLowerCase()) {
-        // Get the database column type from element_type and db_length
-        const columnType = getDbColumnType(entityData.element_type, entityData.db_length);
-
-        // Check if column already exists
-        const columnExists = await this.attributeMasterRepository.checkIfColumnExists(
-          entityInfo.tableName,
-          entityData.attribute_key,
-        );
-
-        // Add column if it doesn't exist
-        if (!columnExists) {
-          await this.attributeMasterRepository.addColumnToTable(
-            entityInfo.tableName,
-            entityData.attribute_key,
-            columnType,
-          );
-        }
-      }
-    } else {
-      entityData.storage_type = AttributeStorageType.EAV;
-    }
-    // Call entity service to handle standard entity creation logic
-    return await this.entityServiceImpl.createEntity(entityData, loggedInUser);
-  }
-
-  /**
-   * Override updateEntity to handle attribute-specific logic
-   * - Updates db_datatype if element_type changes
-   * - Handles column type changes if storage_type is DB_COL AND entity storage_type is SELF
-   */
-  async updateEntity(
-    entityData: AttributeMaster,
-    loggedInUser: UserData,
-  ): Promise<AttributeMaster | null> {
-    // Get existing attribute to compare
-    const existingAttr = await this.attributeMasterRepository.getAttributeById(entityData.id);
-    if (!existingAttr) {
-      throw new Error(`Attribute with id ${entityData.id} not found`);
-    }
-
-    // Update db_datatype if element_type has changed
-    if (entityData.element_type && entityData.element_type !== existingAttr.element_type) {
-      entityData.db_datatype = getDbDataTypeName(entityData.element_type);
-    }
-
-    // Handle column type changes if storage_type is DB_COL
-    if (entityData.storage_type.toLowerCase() === AttributeStorageType.DB_COL.toLowerCase() ||
-      existingAttr.storage_type.toLowerCase() === AttributeStorageType.DB_COL.toLowerCase()) {
-
-      const entityInfo = await this.attributeMasterRepository.getTableNameByEntityType(
-        entityData.mapped_entity_type || existingAttr.mapped_entity_type,
-        loggedInUser,
-      );
-
-      if (!entityInfo.tableName) {
-        throw new Error(
-          `No table found for entity type ${entityData.mapped_entity_type || existingAttr.mapped_entity_type}`,
-        );
-      }
-
-      // Only perform column operations if entity storage_type is SELF
-      if (entityInfo.storageType?.toLowerCase() === StorageType.SELF.toLowerCase()) {
-        // Case 1: Storage type changed from EAV to DB_COL - add column
-        if (entityData.storage_type.toLowerCase() === AttributeStorageType.DB_COL.toLowerCase() &&
-          existingAttr.storage_type.toLowerCase() === AttributeStorageType.EAV.toLowerCase()) {
-          const columnType = getDbColumnType(
-            entityData.element_type || existingAttr.element_type,
-            entityData.db_length || existingAttr.db_length,
-          );
-          const columnExists = await this.attributeMasterRepository.checkIfColumnExists(
-            entityInfo.tableName,
-            entityData.attribute_key || existingAttr.attribute_key,
-          );
-
-          if (!columnExists) {
-            await this.attributeMasterRepository.addColumnToTable(
-              entityInfo.tableName,
-              entityData.attribute_key || existingAttr.attribute_key,
-              columnType,
-            );
-          }
-        }
-
-        // Case 2: Storage type changed from DB_COL to EAV - drop column
-        else if (entityData.storage_type.toLowerCase() === AttributeStorageType.EAV.toLowerCase() &&
-          existingAttr.storage_type.toLowerCase() === AttributeStorageType.DB_COL.toLowerCase()) {
-          const columnExists = await this.attributeMasterRepository.checkIfColumnExists(
-            entityInfo.tableName,
-            existingAttr.attribute_key,
-          );
-
-          if (columnExists) {
-            await this.attributeMasterRepository.dropColumnFromTable(
-              entityInfo.tableName,
-              existingAttr.attribute_key,
-            );
-          }
-        }
-
-        // Case 3: Element type or db_length changed while storage_type is DB_COL - alter column type
-        else if (entityData.storage_type.toLowerCase() === AttributeStorageType.DB_COL.toLowerCase() &&
-          existingAttr.storage_type.toLowerCase() === AttributeStorageType.DB_COL.toLowerCase() &&
-          (
-            (entityData.element_type && entityData.element_type !== existingAttr.element_type) ||
-            (entityData.db_length && entityData.db_length !== existingAttr.db_length)
-          )) {
-          const newColumnType = getDbColumnType(
-            entityData.element_type || existingAttr.element_type,
-            entityData.db_length || existingAttr.db_length,
-          );
-          await this.attributeMasterRepository.alterColumnType(
-            entityInfo.tableName,
-            entityData.attribute_key || existingAttr.attribute_key,
-            newColumnType,
-          );
-        }
-      }
-    }
-
-    // Call entity service to handle standard entity update logic
-    return await this.entityServiceImpl.updateEntity(entityData, loggedInUser);
-  }
-
-  /**
-   * Backward compatibility wrapper for createEntity
-   * @deprecated Use createEntity instead
-   */
-  async createAttribute(
-    attributeData: AttributeMaster,
-    loggedInUser: UserData,
-  ): Promise<AttributeMaster> {
-    return this.createEntity(attributeData, loggedInUser);
-  }
-
-  /**
-   * Backward compatibility wrapper for updateEntity
-   * @deprecated Use updateEntity instead
-   */
-  async updateAttribute(
-    attributeData: AttributeMaster,
-    id: number,
-    loggedInUser: UserData,
-  ): Promise<AttributeMaster | null> {
-    attributeData.id = id;
-    return this.updateEntity(attributeData, loggedInUser);
-  }
-
-
-  async getAttributeById(id: number): Promise<AttributeMaster | null> {
-    return this.attributeMasterRepository.getAttributeById(id);
-  }
-
-  async getAttributesByEntityType(entity_type, loggedInUser) {
-    return this.attributeMasterRepository.getAllAttributeByEntity(entity_type, loggedInUser);
-  }
-
-  async getAttributesByMappedEntityType(
-    entityType: string,
-    loggedInUser: UserData,
-  ): Promise<AttributeMaster[]> {
-    return this.attributeMasterRepository.findAttributesByMappedEntityType(
-      entityType,
-      loggedInUser,
-    );
-  }
-
-  async getAttributesDropdownList(
-    entityType: string,
-    loggedInUser: UserData,
-  ): Promise<{ label: string; value: number }[]> {
-    return this.attributeMasterRepository.getAttributesDropdownList(
-      entityType,
-      loggedInUser,
-    );
-  }
-
-  async findByMappedEntityTypeAndAttributeKey(mapped_entity_type: string, attribute_key: string, loggedInUser: UserData) {
-    return await this.attributeMasterRepository.findByMappedEntityTypeAndAttributeKeyAndOrganizationId(
-      mapped_entity_type,
-      attribute_key,
-      loggedInUser.enterprise_id,
-    );
-  }
-
-  async getAttributesForDirect(
-    entityType: string,
-    enterpriseId: number,
-    allowedElementTypes: string[],
-  ): Promise<AttributeMaster[]> {
-    return this.attributeMasterRepository.getAttributesDirect(
-      entityType,
-      enterpriseId,
-      allowedElementTypes,
-    );
-  }
-
-  async getEntityAttributes(entityType: string, loggedInUser: UserData, direct?: boolean) {
-    const allowedElementTypes = [
-      'label',
-      'text',
-      'textarea',
-      'select',
-      'number',
-      'decimal',
-      'date',
-      'time',
-      'datetime',
-      'phone',
-      'email',
-      'checkbox',
-      'multicheckbox',
-      'radio',
-      'file-upload'
-    ];
-    let entityMaster = await this.entityMasterService.getEntityData(entityType, loggedInUser);
-    if (entityMaster.is_flat_json && !direct) {
-      return await this.getAttributesForFlatJson(entityType, loggedInUser, allowedElementTypes);
-    } else {
-      let attributeMasters = await this.attributeMasterRepository.getAttributesDirect(entityType, loggedInUser.enterprise_id, allowedElementTypes);
-      return attributeMasters.map(attribute => ({
-        id: attribute.id,
-        name: attribute.name,
-        attribute_key: attribute.attribute_key,
-        element_type: attribute.element_type,
-      }));
-    }
-  }
-
-  async getAttributesForFlatJson(entityType: string, loggedInUser: UserData, allowedElementTypes: string[]) {
-    let attributes: any[] = [];
-
-    const mainAttributes = await this.getAttributesForDirect(entityType, loggedInUser.enterprise_id, allowedElementTypes);
-
-    mainAttributes.map(attribute => {
-      attributes.push({
-        name: attribute.name,
-        attribute_key: `${entityType}__${attribute.attribute_key}`,
-        element_type: attribute.element_type,
-      });
-    });
-
-    const relatedRelations = await this.entityRelationService.getOneToOneRelations(
-      entityType,
-      loggedInUser.enterprise_id,
-    );
-
-    const relatedEntityTypes = relatedRelations.map(
-      (r) => r.target_entity_type,
-    );
-
-    if (relatedEntityTypes.length > 0) {
-      for (const type of relatedEntityTypes) {
-        const attrs = await this.getAttributesForDirect(type, loggedInUser.enterprise_id, allowedElementTypes);
-        attrs.map(attribute => {
-          attributes.push({
-            name: attribute.name,
-            attribute_key: `${type}__${attribute.attribute_key}`,
-            element_type: attribute.element_type,
-          });
-        });
-      }
-    }
-
-    return attributes;
-  }
-}
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
+import { AttributeMasterRepository } from '../repository/attribute-master.repository';
+import { UserData } from 'src/module/auth/dto/user.dto';
+import { AttributeMaster } from '../entity/attribute-master.entity';
+import { EntityServiceImpl } from './entity-service-impl.service';
+import { getDbColumnType, getDbDataTypeName } from '../../../constant/db-data-type.constant';
+import { AttributeStorageType } from '../../../constant/attribute.constant';
+import { StorageType } from '../../../constant/entity.constant';
+import { EntityMasterService } from './entity-master.service';
+import { EntityRelationRepository } from '../repository/entity-relation.repository';
+
+@Injectable()
+export class AttributeMasterService {
+  constructor(
+    private readonly attributeMasterRepository: AttributeMasterRepository,
+    @Inject(forwardRef(() => EntityServiceImpl))
+    private readonly entityServiceImpl: EntityServiceImpl,
+    @Inject('EntityMasterService')
+    private readonly entityMasterService: EntityMasterService,
+    private readonly entityRelationService: EntityRelationRepository,
+  ) {
+  }
+
+  async findAttributesByMappedEntityType(
+    entity_type: string,
+    loggedInUser: UserData,
+  ) {
+    return this.attributeMasterRepository.findAttributesByMappedEntityType(
+      entity_type,
+      loggedInUser,
+    );
+  }
+
+  /**
+   * Override createEntity to handle attribute-specific logic
+   * - Automatically sets db_datatype based on element_type
+   * - Creates database column if storage_type is DB_COL AND entity storage_type is SELF
+   */
+  async createEntity(
+    entityData: AttributeMaster,
+    loggedInUser: UserData | null,
+  ): Promise<AttributeMaster> {
+    // Automatically set db_datatype based on element_type
+    if (entityData.element_type) {
+      entityData.db_datatype = getDbDataTypeName(entityData.element_type);
+    }
+
+    // Only create DB column if attribute storage_type is DB_COL
+    if (AttributeStorageType.DB_COL.toLowerCase() === entityData.storage_type.toLowerCase() && loggedInUser) {
+      // Get the table name and storage type from entity_master
+      const entityInfo = await this.attributeMasterRepository.getTableNameByEntityType(
+        entityData.mapped_entity_type,
+        loggedInUser,
+      );
+
+      if (!entityInfo.tableName) {
+        throw new Error(
+          `No table found for entity type ${entityData.mapped_entity_type}`,
+        );
+      }
+
+      // Only add column if entity storage_type is SELF (has its own table)
+      if (entityInfo.storageType?.toLowerCase() === StorageType.SELF.toLowerCase()) {
+        // Get the database column type from element_type and db_length
+        const columnType = getDbColumnType(entityData.element_type, entityData.db_length);
+
+        // Check if column already exists
+        const columnExists = await this.attributeMasterRepository.checkIfColumnExists(
+          entityInfo.tableName,
+          entityData.attribute_key,
+        );
+
+        // Add column if it doesn't exist
+        if (!columnExists) {
+          await this.attributeMasterRepository.addColumnToTable(
+            entityInfo.tableName,
+            entityData.attribute_key,
+            columnType,
+          );
+        }
+      }
+    } else {
+      entityData.storage_type = AttributeStorageType.EAV;
+    }
+    // Call entity service to handle standard entity creation logic
+    return await this.entityServiceImpl.createEntity(entityData, loggedInUser);
+  }
+
+  /**
+   * Override updateEntity to handle attribute-specific logic
+   * - Updates db_datatype if element_type changes
+   * - Handles column type changes if storage_type is DB_COL AND entity storage_type is SELF
+   */
+  async updateEntity(
+    entityData: AttributeMaster,
+    loggedInUser: UserData,
+  ): Promise<AttributeMaster | null> {
+    // Get existing attribute to compare
+    const existingAttr = await this.attributeMasterRepository.getAttributeById(entityData.id);
+    if (!existingAttr) {
+      throw new Error(`Attribute with id ${entityData.id} not found`);
+    }
+
+    // Update db_datatype if element_type has changed
+    if (entityData.element_type && entityData.element_type !== existingAttr.element_type) {
+      entityData.db_datatype = getDbDataTypeName(entityData.element_type);
+    }
+
+    // Handle column type changes if storage_type is DB_COL
+    if (entityData.storage_type.toLowerCase() === AttributeStorageType.DB_COL.toLowerCase() ||
+      existingAttr.storage_type.toLowerCase() === AttributeStorageType.DB_COL.toLowerCase()) {
+
+      const entityInfo = await this.attributeMasterRepository.getTableNameByEntityType(
+        entityData.mapped_entity_type || existingAttr.mapped_entity_type,
+        loggedInUser,
+      );
+
+      if (!entityInfo.tableName) {
+        throw new Error(
+          `No table found for entity type ${entityData.mapped_entity_type || existingAttr.mapped_entity_type}`,
+        );
+      }
+
+      // Only perform column operations if entity storage_type is SELF
+      if (entityInfo.storageType?.toLowerCase() === StorageType.SELF.toLowerCase()) {
+        // Case 1: Storage type changed from EAV to DB_COL - add column
+        if (entityData.storage_type.toLowerCase() === AttributeStorageType.DB_COL.toLowerCase() &&
+          existingAttr.storage_type.toLowerCase() === AttributeStorageType.EAV.toLowerCase()) {
+          const columnType = getDbColumnType(
+            entityData.element_type || existingAttr.element_type,
+            entityData.db_length || existingAttr.db_length,
+          );
+          const columnExists = await this.attributeMasterRepository.checkIfColumnExists(
+            entityInfo.tableName,
+            entityData.attribute_key || existingAttr.attribute_key,
+          );
+
+          if (!columnExists) {
+            await this.attributeMasterRepository.addColumnToTable(
+              entityInfo.tableName,
+              entityData.attribute_key || existingAttr.attribute_key,
+              columnType,
+            );
+          }
+        }
+
+        // Case 2: Storage type changed from DB_COL to EAV - drop column
+        else if (entityData.storage_type.toLowerCase() === AttributeStorageType.EAV.toLowerCase() &&
+          existingAttr.storage_type.toLowerCase() === AttributeStorageType.DB_COL.toLowerCase()) {
+          const columnExists = await this.attributeMasterRepository.checkIfColumnExists(
+            entityInfo.tableName,
+            existingAttr.attribute_key,
+          );
+
+          if (columnExists) {
+            await this.attributeMasterRepository.dropColumnFromTable(
+              entityInfo.tableName,
+              existingAttr.attribute_key,
+            );
+          }
+        }
+
+        // Case 3: Element type or db_length changed while storage_type is DB_COL - alter column type
+        else if (entityData.storage_type.toLowerCase() === AttributeStorageType.DB_COL.toLowerCase() &&
+          existingAttr.storage_type.toLowerCase() === AttributeStorageType.DB_COL.toLowerCase() &&
+          (
+            (entityData.element_type && entityData.element_type !== existingAttr.element_type) ||
+            (entityData.db_length && entityData.db_length !== existingAttr.db_length)
+          )) {
+          const newColumnType = getDbColumnType(
+            entityData.element_type || existingAttr.element_type,
+            entityData.db_length || existingAttr.db_length,
+          );
+          await this.attributeMasterRepository.alterColumnType(
+            entityInfo.tableName,
+            entityData.attribute_key || existingAttr.attribute_key,
+            newColumnType,
+          );
+        }
+      }
+    }
+
+    // Call entity service to handle standard entity update logic
+    return await this.entityServiceImpl.updateEntity(entityData, loggedInUser);
+  }
+
+  /**
+   * Backward compatibility wrapper for createEntity
+   * @deprecated Use createEntity instead
+   */
+  async createAttribute(
+    attributeData: AttributeMaster,
+    loggedInUser: UserData,
+  ): Promise<AttributeMaster> {
+    return this.createEntity(attributeData, loggedInUser);
+  }
+
+  /**
+   * Backward compatibility wrapper for updateEntity
+   * @deprecated Use updateEntity instead
+   */
+  async updateAttribute(
+    attributeData: AttributeMaster,
+    id: number,
+    loggedInUser: UserData,
+  ): Promise<AttributeMaster | null> {
+    attributeData.id = id;
+    return this.updateEntity(attributeData, loggedInUser);
+  }
+
+
+  async getAttributeById(id: number): Promise<AttributeMaster | null> {
+    return this.attributeMasterRepository.getAttributeById(id);
+  }
+
+  async getAttributesByEntityType(entity_type, loggedInUser) {
+    return this.attributeMasterRepository.getAllAttributeByEntity(entity_type, loggedInUser);
+  }
+
+  async getAttributesByMappedEntityType(
+    entityType: string,
+    loggedInUser: UserData,
+  ): Promise<AttributeMaster[]> {
+    return this.attributeMasterRepository.findAttributesByMappedEntityType(
+      entityType,
+      loggedInUser,
+    );
+  }
+
+  async getAttributesDropdownList(
+    entityType: string,
+    loggedInUser: UserData,
+  ): Promise<{ label: string; value: number }[]> {
+    return this.attributeMasterRepository.getAttributesDropdownList(
+      entityType,
+      loggedInUser,
+    );
+  }
+
+  async findByMappedEntityTypeAndAttributeKey(mapped_entity_type: string, attribute_key: string, loggedInUser: UserData) {
+    return await this.attributeMasterRepository.findByMappedEntityTypeAndAttributeKeyAndOrganizationId(
+      mapped_entity_type,
+      attribute_key,
+      loggedInUser.enterprise_id,
+    );
+  }
+
+  async getAttributesForDirect(
+    entityType: string,
+    enterpriseId: number,
+    allowedElementTypes: string[],
+  ): Promise<AttributeMaster[]> {
+    return this.attributeMasterRepository.getAttributesDirect(
+      entityType,
+      enterpriseId,
+      allowedElementTypes,
+    );
+  }
+
+  async getEntityAttributes(entityType: string, loggedInUser: UserData, direct?: boolean) {
+    const allowedElementTypes = [
+      'label',
+      'text',
+      'textarea',
+      'select',
+      'number',
+      'decimal',
+      'date',
+      'time',
+      'datetime',
+      'phone',
+      'email',
+      'checkbox',
+      'multicheckbox',
+      'radio',
+      'file-upload'
+    ];
+    let entityMaster = await this.entityMasterService.getEntityData(entityType, loggedInUser);
+    if (entityMaster.is_flat_json && !direct) {
+      return await this.getAttributesForFlatJson(entityType, loggedInUser, allowedElementTypes);
+    } else {
+      let attributeMasters = await this.attributeMasterRepository.getAttributesDirect(entityType, loggedInUser.enterprise_id, allowedElementTypes);
+      return attributeMasters.map(attribute => ({
+        id: attribute.id,
+        name: attribute.name,
+        attribute_key: attribute.attribute_key,
+        element_type: attribute.element_type,
+      }));
+    }
+  }
+
+  async getAttributesForFlatJson(entityType: string, loggedInUser: UserData, allowedElementTypes: string[]) {
+    let attributes: any[] = [];
+
+    const mainAttributes = await this.getAttributesForDirect(entityType, loggedInUser.enterprise_id, allowedElementTypes);
+
+    mainAttributes.map(attribute => {
+      attributes.push({
+        name: attribute.name,
+        attribute_key: `${entityType}__${attribute.attribute_key}`,
+        element_type: attribute.element_type,
+      });
+    });
+
+    const relatedRelations = await this.entityRelationService.getOneToOneRelations(
+      entityType,
+      loggedInUser.enterprise_id,
+    );
+
+    const relatedEntityTypes = relatedRelations.map(
+      (r) => r.target_entity_type,
+    );
+
+    if (relatedEntityTypes.length > 0) {
+      for (const type of relatedEntityTypes) {
+        const attrs = await this.getAttributesForDirect(type, loggedInUser.enterprise_id, allowedElementTypes);
+        attrs.map(attribute => {
+          attributes.push({
+            name: attribute.name,
+            attribute_key: `${type}__${attribute.attribute_key}`,
+            element_type: attribute.element_type,
+          });
+        });
+      }
+    }
+
+    return attributes;
+  }
+}