rez_core 6.1.0 → 6.1.1

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

@@ -1,164 +1,164 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { AttributeMaster } from '../entity/attribute-master.entity';
-import { EntityManager, Repository } from 'typeorm';
-import { UserData } from 'src/module/user/entity/user.entity';
-import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
-import { ConfigService } from '@nestjs/config';
-
-@Injectable()
-export class AttributeMasterRepository {
-  constructor(
-    @InjectRepository(AttributeMaster)
-    private readonly attributeMasterRepository: Repository<AttributeMaster>,
-    private readonly entityManger: EntityManager,
-    private readonly reflectionHelper: ReflectionHelper,
-    private readonly configService: ConfigService,
-  ) {
-  }
-
-  schema = this.configService.get('DB_SCHEMA');
-
-  // ---------- Existing Methods ----------
-  async findByMappedEntityIdAndMappedEntityTypeAndAttributeKeyAndOrganizationId(
-    mappedEntityId: number,
-    mappedEntityType: string,
-    attributeKey: string,
-    organizationId: number,
-  ): Promise<AttributeMaster | null> {
-    return await this.attributeMasterRepository.findOne({
-      where: {
-        mapped_entity_id: mappedEntityId,
-        mapped_entity_type: mappedEntityType,
-        attribute_key: attributeKey,
-        organization_id: organizationId,
-      },
-    });
-  }
-
-  async findAttributesByMappedEntityType(
-    entityType: string,
-    loggedInUser: UserData,
-  ): Promise<AttributeMaster[]> {
-    return await this.attributeMasterRepository.find({
-      where: {
-        mapped_entity_type: entityType,
-        enterprise_id: loggedInUser.enterprise_id,
-      },
-    });
-  }
-
-  async createAttribute(
-    attributeData: AttributeMaster,
-  ): Promise<AttributeMaster> {
-    return await this.attributeMasterRepository.save(attributeData);
-  }
-
-  async updateAttribute(
-    attributeData: AttributeMaster,
-    id: number,
-  ): Promise<AttributeMaster | null> {
-    await this.attributeMasterRepository.update({ id }, attributeData);
-    return this.attributeMasterRepository.findOne({ where: { id } });
-  }
-
-  async getAttributeById(id: number): Promise<AttributeMaster | null> {
-    return await this.attributeMasterRepository.findOne({ where: { id } });
-  }
-
-  async getAllAttributeByEntity(entity_type: string, loggedInUser): Promise<{ label: string; value: any }[]> {
-    let data = await this.attributeMasterRepository.find({
-      where: {
-        enterprise_id: loggedInUser.enterprise_id,
-        mapped_entity_type: entity_type,
-      },
-    });
-    if (data) {
-      const dropdownData = data.map((attribute) => {
-        return {
-          'label': attribute.name,
-          'value': attribute.attribute_key,
-          'data_type': attribute.data_type,
-          'data_source_list': attribute.datasource_list,
-        };
-      });
-
-      return dropdownData;
-    }
-    return [];
-  }
-
-  async getAttributesDropdownList(
-    entityType: string,
-    loggedInUser: UserData,
-  ): Promise<{ label: string; value: number }[]> {
-    const data = await this.attributeMasterRepository.find({
-      where: {
-        mapped_entity_type: entityType,
-        enterprise_id: loggedInUser.enterprise_id,
-      },
-    });
-
-    return data.map((item) => ({
-      label: item.name,
-      value: item.id,
-    }));
-  }
-
-  // ---------- New Raw SQL Methods ----------
-  async getTableNameByEntityType(
-    entityType: string,
-    loggedInUser: UserData,
-  ): Promise<string | null> {
-    const entityMasterRepo = this.reflectionHelper.getRepoService('EntityMaster');
-    const result = await entityMasterRepo.findOne({
-      where: {
-        mapped_entity_type: entityType,
-        enterprise_id: loggedInUser.enterprise_id,
-      },
-    });
-    if (result) {
-      return result.db_table_name;
-    }
-    return null;
-  }
-
-  async checkIfColumnExists(
-    tableName: string,
-    columnName: string,
-  ): Promise<boolean> {
-    const result = await this.entityManger.query(
-      `
-          SELECT column_name
-          FROM information_schema.columns
-          WHERE table_name = $1
-            AND column_name = $2
-      `,
-      [tableName, columnName],
-    );
-
-    return result.length > 0;
-  }
-
-  async addColumnToTable(
-    tableName: string,
-    columnName: string,
-    columnType: string,
-  ): Promise<void> {
-
-    const alterQuery = `
-        ALTER TABLE ${this.schema}.${tableName}
-            ADD COLUMN IF NOT EXISTS ${columnName} ${columnType}
-    `;
-
-    await this.entityManger.query(alterQuery);
-  }
-
-  async findByMappedEntityTypeAndAttributeKeyAndOrganizationId(mapped_entity_type: string, attribute_key: string, enterprise_id: number) {
-    return await this.attributeMasterRepository.findOne({
-      where: {
-        mapped_entity_type, attribute_key, enterprise_id,
-      },
-    });
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { AttributeMaster } from '../entity/attribute-master.entity';
+import { EntityManager, Repository } from 'typeorm';
+import { UserData } from 'src/module/user/entity/user.entity';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class AttributeMasterRepository {
+  constructor(
+    @InjectRepository(AttributeMaster)
+    private readonly attributeMasterRepository: Repository<AttributeMaster>,
+    private readonly entityManger: EntityManager,
+    private readonly reflectionHelper: ReflectionHelper,
+    private readonly configService: ConfigService,
+  ) {
+  }
+
+  schema = this.configService.get('DB_SCHEMA');
+
+  // ---------- Existing Methods ----------
+  async findByMappedEntityIdAndMappedEntityTypeAndAttributeKeyAndOrganizationId(
+    mappedEntityId: number,
+    mappedEntityType: string,
+    attributeKey: string,
+    organizationId: number,
+  ): Promise<AttributeMaster | null> {
+    return await this.attributeMasterRepository.findOne({
+      where: {
+        mapped_entity_id: mappedEntityId,
+        mapped_entity_type: mappedEntityType,
+        attribute_key: attributeKey,
+        organization_id: organizationId,
+      },
+    });
+  }
+
+  async findAttributesByMappedEntityType(
+    entityType: string,
+    loggedInUser: UserData,
+  ): Promise<AttributeMaster[]> {
+    return await this.attributeMasterRepository.find({
+      where: {
+        mapped_entity_type: entityType,
+        enterprise_id: loggedInUser.enterprise_id,
+      },
+    });
+  }
+
+  async createAttribute(
+    attributeData: AttributeMaster,
+  ): Promise<AttributeMaster> {
+    return await this.attributeMasterRepository.save(attributeData);
+  }
+
+  async updateAttribute(
+    attributeData: AttributeMaster,
+    id: number,
+  ): Promise<AttributeMaster | null> {
+    await this.attributeMasterRepository.update({ id }, attributeData);
+    return this.attributeMasterRepository.findOne({ where: { id } });
+  }
+
+  async getAttributeById(id: number): Promise<AttributeMaster | null> {
+    return await this.attributeMasterRepository.findOne({ where: { id } });
+  }
+
+  async getAllAttributeByEntity(entity_type: string, loggedInUser): Promise<{ label: string; value: any }[]> {
+    let data = await this.attributeMasterRepository.find({
+      where: {
+        enterprise_id: loggedInUser.enterprise_id,
+        mapped_entity_type: entity_type,
+      },
+    });
+    if (data) {
+      const dropdownData = data.map((attribute) => {
+        return {
+          'label': attribute.name,
+          'value': attribute.attribute_key,
+          'data_type': attribute.data_type,
+          'data_source_list': attribute.datasource_list,
+        };
+      });
+
+      return dropdownData;
+    }
+    return [];
+  }
+
+  async getAttributesDropdownList(
+    entityType: string,
+    loggedInUser: UserData,
+  ): Promise<{ label: string; value: number }[]> {
+    const data = await this.attributeMasterRepository.find({
+      where: {
+        mapped_entity_type: entityType,
+        enterprise_id: loggedInUser.enterprise_id,
+      },
+    });
+
+    return data.map((item) => ({
+      label: item.name,
+      value: item.id,
+    }));
+  }
+
+  // ---------- New Raw SQL Methods ----------
+  async getTableNameByEntityType(
+    entityType: string,
+    loggedInUser: UserData,
+  ): Promise<string | null> {
+    const entityMasterRepo = this.reflectionHelper.getRepoService('EntityMaster');
+    const result = await entityMasterRepo.findOne({
+      where: {
+        mapped_entity_type: entityType,
+        enterprise_id: loggedInUser.enterprise_id,
+      },
+    });
+    if (result) {
+      return result.db_table_name;
+    }
+    return null;
+  }
+
+  async checkIfColumnExists(
+    tableName: string,
+    columnName: string,
+  ): Promise<boolean> {
+    const result = await this.entityManger.query(
+      `
+          SELECT column_name
+          FROM information_schema.columns
+          WHERE table_name = $1
+            AND column_name = $2
+      `,
+      [tableName, columnName],
+    );
+
+    return result.length > 0;
+  }
+
+  async addColumnToTable(
+    tableName: string,
+    columnName: string,
+    columnType: string,
+  ): Promise<void> {
+
+    const alterQuery = `
+        ALTER TABLE ${this.schema}.${tableName}
+            ADD COLUMN IF NOT EXISTS ${columnName} ${columnType}
+    `;
+
+    await this.entityManger.query(alterQuery);
+  }
+
+  async findByMappedEntityTypeAndAttributeKeyAndOrganizationId(mapped_entity_type: string, attribute_key: string, enterprise_id: number) {
+    return await this.attributeMasterRepository.findOne({
+      where: {
+        mapped_entity_type, attribute_key, enterprise_id,
+      },
+    });
+  }
+}

package/src/module/meta/repository/entity-attribute-update.repository.ts

@@ -1,48 +1,48 @@
-import { Injectable } from '@nestjs/common';
-import { EntityManager } from 'typeorm';
-import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
-
-@Injectable()
-export class EntityUpdateRepository {
-  constructor(private readonly entityManager: EntityManager,
-              private readonly reflectionHelper: ReflectionHelper,
-  ) {
-  }
-
-
-  async updateEntityAttribute(entity, config) {
-    const { entityType, organization_id } = entity;
-
-    // 1. Get the table name
-    const entityMasterRepo = this.reflectionHelper.getRepoService('EntityMaster');
-
-    const result = await entityMasterRepo.findOne({
-      where: {
-        mapped_entity_type: entityType,
-        organization_id,
-      },
-    });
-
-    if (!result) {
-      throw new Error('Entity table not found');
-    }
-
-    const entityTableName = result.db_table_name;
-
-    // 2. Determine the ID condition
-
-    const isLead = config.entity_type === 'LEAD';
-    const idColumn = isLead ? 'id' : 'parent_id';
-
-    // 3. Update using dynamic table name
-
-    return await this.entityManager
-      .createQueryBuilder()
-      .update(entityTableName)
-      .set({ [config.attribute_key]: config.attribute_value })
-      .where(`${idColumn} = :id`, { id: entity.id })
-      .execute();
-
-  }
-
-}
+import { Injectable } from '@nestjs/common';
+import { EntityManager } from 'typeorm';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
+
+@Injectable()
+export class EntityUpdateRepository {
+  constructor(private readonly entityManager: EntityManager,
+              private readonly reflectionHelper: ReflectionHelper,
+  ) {
+  }
+
+
+  async updateEntityAttribute(entity, config) {
+    const { entityType, organization_id } = entity;
+
+    // 1. Get the table name
+    const entityMasterRepo = this.reflectionHelper.getRepoService('EntityMaster');
+
+    const result = await entityMasterRepo.findOne({
+      where: {
+        mapped_entity_type: entityType,
+        organization_id,
+      },
+    });
+
+    if (!result) {
+      throw new Error('Entity table not found');
+    }
+
+    const entityTableName = result.db_table_name;
+
+    // 2. Determine the ID condition
+
+    const isLead = config.entity_type === 'LEAD';
+    const idColumn = isLead ? 'id' : 'parent_id';
+
+    // 3. Update using dynamic table name
+
+    return await this.entityManager
+      .createQueryBuilder()
+      .update(entityTableName)
+      .set({ [config.attribute_key]: config.attribute_value })
+      .where(`${idColumn} = :id`, { id: entity.id })
+      .execute();
+
+  }
+
+}

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

@@ -1,120 +1,120 @@
-import { Inject, Injectable } from '@nestjs/common';
-import { EntityMaster } from '../entity/entity-master.entity';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
-import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
-import { EntityRelation } from '../entity/entity-relation.entity';
-import { AttributeMaster } from '../entity/attribute-master.entity';
-import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
-
-@Injectable()
-export class EntityMasterRepository {
-  constructor(
-    @InjectRepository(EntityMaster)
-    private readonly entityMasterRepository: Repository<EntityMaster>,
-    @Inject('ListMasterService')
-    private readonly listMasterService: ListMasterService,
-    @InjectRepository(EntityRelation)
-    private readonly entityRelationRepo: Repository<EntityRelation>,
-    @InjectRepository(AttributeMaster)
-    private readonly attributeMasterRepository: Repository<AttributeMaster>,
-    private readonly reflectionHelper: ReflectionHelper,
-  ) {
-  }
-
-  async getEntityById(id: number): Promise<EntityMaster | null> {
-    let data = await this.entityMasterRepository.findOne({ where: { id } });
-    if (data) {
-      const listMasterItemsRepo = this.reflectionHelper.getRepoService('ListMasterItems');
-      let listMasterItemsata = await listMasterItemsRepo.findOne({
-        where: { id: data.status },
-      });
-
-      data.status = listMasterItemsata?.name;
-    }
-    return data;
-  }
-
-  async getAllEntityDropdownData(entity_type: string, loggedInUser): Promise<{ label: string; value: any }[]> {
-
-
-    let relations = await this.entityRelationRepo
-      .createQueryBuilder('rel')
-      .select([
-        'rel.name AS label',
-        'rel.target_entity_type AS value',
-      ])
-      .where('rel.source_entity_type = :entityType', { entityType: entity_type })
-      .andWhere('rel.enterprise_id = :entId', { entId: loggedInUser.enterprise_id })
-      .getRawMany();
-
-    // console.log(relations,"-------------")
-    let parentEntityLabelName = await this.getEntityByMappedEntityType(entity_type, loggedInUser.enterprise_id);
-
-    let dropdownData: any[] = [...relations];
-    if (parentEntityLabelName) {
-      dropdownData.push({
-        label: parentEntityLabelName.name, value: entity_type,
-      });
-    }
-
-    return dropdownData.length ? dropdownData : [];
-  }
-
-
-  async getEntityByMappedEntityType(
-    mappedEntityType: string,
-    enterprise_id: any,
-  ): Promise<EntityMaster | null> {
-    return await this.entityMasterRepository.findOne({
-      where: {
-        mapped_entity_type: mappedEntityType,
-        enterprise_id: enterprise_id,
-      },
-    });
-  }
-
-  async getOperationList(loggedInUser: any) {
-    const [text, number, date, select, multiselect, year] = await Promise.all([
-      this.listMasterService.getDropdownOptions('OPT', {}, [], loggedInUser),
-      this.listMasterService.getDropdownOptions('OPN', {}, [], loggedInUser),
-      this.listMasterService.getDropdownOptions('OPD', {}, [], loggedInUser),
-      this.listMasterService.getDropdownOptions('OPS', {}, [], loggedInUser),
-      this.listMasterService.getDropdownOptions('OPM', {}, [], loggedInUser),
-      this.listMasterService.getDropdownOptions('OPY', {}, [], loggedInUser),
-    ]);
-
-    return { text, number, date, select, multiselect, year };
-  }
-
-  async getAttributesOfTypeDate(entity_type, loggedInUser) {
-    const enterprise_id = loggedInUser.enterprise_id;
-
-    const attributes = await this.attributeMasterRepository.find({
-      where: {
-        mapped_entity_type: entity_type,
-        data_type: 'date',
-        enterprise_id,
-      },
-    });
-
-    return attributes.map((attr) => ({
-      label: attr.name,
-      value: attr.attribute_key,
-    }));
-  }
-
-  async findByEnterpriseIdAndAppCode(enterprise_id, appcode?) {
-    let where = {
-      enterprise_id,
-    };
-
-    if (appcode) {
-      where['appcode'] = appcode;
-    }
-    return await this.entityMasterRepository.find({
-      where,
-      select: ['name', 'mapped_entity_type']
-    });
-  }
-}
+import { Inject, Injectable } from '@nestjs/common';
+import { EntityMaster } from '../entity/entity-master.entity';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
+import { EntityRelation } from '../entity/entity-relation.entity';
+import { AttributeMaster } from '../entity/attribute-master.entity';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
+
+@Injectable()
+export class EntityMasterRepository {
+  constructor(
+    @InjectRepository(EntityMaster)
+    private readonly entityMasterRepository: Repository<EntityMaster>,
+    @Inject('ListMasterService')
+    private readonly listMasterService: ListMasterService,
+    @InjectRepository(EntityRelation)
+    private readonly entityRelationRepo: Repository<EntityRelation>,
+    @InjectRepository(AttributeMaster)
+    private readonly attributeMasterRepository: Repository<AttributeMaster>,
+    private readonly reflectionHelper: ReflectionHelper,
+  ) {
+  }
+
+  async getEntityById(id: number): Promise<EntityMaster | null> {
+    let data = await this.entityMasterRepository.findOne({ where: { id } });
+    if (data) {
+      const listMasterItemsRepo = this.reflectionHelper.getRepoService('ListMasterItems');
+      let listMasterItemsata = await listMasterItemsRepo.findOne({
+        where: { id: data.status },
+      });
+
+      data.status = listMasterItemsata?.name;
+    }
+    return data;
+  }
+
+  async getAllEntityDropdownData(entity_type: string, loggedInUser): Promise<{ label: string; value: any }[]> {
+
+
+    let relations = await this.entityRelationRepo
+      .createQueryBuilder('rel')
+      .select([
+        'rel.name AS label',
+        'rel.target_entity_type AS value',
+      ])
+      .where('rel.source_entity_type = :entityType', { entityType: entity_type })
+      .andWhere('rel.enterprise_id = :entId', { entId: loggedInUser.enterprise_id })
+      .getRawMany();
+
+    // console.log(relations,"-------------")
+    let parentEntityLabelName = await this.getEntityByMappedEntityType(entity_type, loggedInUser.enterprise_id);
+
+    let dropdownData: any[] = [...relations];
+    if (parentEntityLabelName) {
+      dropdownData.push({
+        label: parentEntityLabelName.name, value: entity_type,
+      });
+    }
+
+    return dropdownData.length ? dropdownData : [];
+  }
+
+
+  async getEntityByMappedEntityType(
+    mappedEntityType: string,
+    enterprise_id: any,
+  ): Promise<EntityMaster | null> {
+    return await this.entityMasterRepository.findOne({
+      where: {
+        mapped_entity_type: mappedEntityType,
+        enterprise_id: enterprise_id,
+      },
+    });
+  }
+
+  async getOperationList(loggedInUser: any) {
+    const [text, number, date, select, multiselect, year] = await Promise.all([
+      this.listMasterService.getDropdownOptions('OPT', {}, [], loggedInUser),
+      this.listMasterService.getDropdownOptions('OPN', {}, [], loggedInUser),
+      this.listMasterService.getDropdownOptions('OPD', {}, [], loggedInUser),
+      this.listMasterService.getDropdownOptions('OPS', {}, [], loggedInUser),
+      this.listMasterService.getDropdownOptions('OPM', {}, [], loggedInUser),
+      this.listMasterService.getDropdownOptions('OPY', {}, [], loggedInUser),
+    ]);
+
+    return { text, number, date, select, multiselect, year };
+  }
+
+  async getAttributesOfTypeDate(entity_type, loggedInUser) {
+    const enterprise_id = loggedInUser.enterprise_id;
+
+    const attributes = await this.attributeMasterRepository.find({
+      where: {
+        mapped_entity_type: entity_type,
+        data_type: 'date',
+        enterprise_id,
+      },
+    });
+
+    return attributes.map((attr) => ({
+      label: attr.name,
+      value: attr.attribute_key,
+    }));
+  }
+
+  async findByEnterpriseIdAndAppCode(enterprise_id, appcode?) {
+    let where = {
+      enterprise_id,
+    };
+
+    if (appcode) {
+      where['appcode'] = appcode;
+    }
+    return await this.entityMasterRepository.find({
+      where,
+      select: ['name', 'mapped_entity_type']
+    });
+  }
+}