rez_core 4.0.197 → 4.0.198

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

@@ -1,138 +1,138 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { AttributeMaster } from '../entity/attribute-master.entity';
-import { In, Repository, DataSource } from 'typeorm';
-import { UserData } from 'src/module/user/entity/user.entity';
-
-@Injectable()
-export class AttributeMasterRepository {
-  constructor(
-    @InjectRepository(AttributeMaster)
-    private readonly attributeMasterRepository: Repository<AttributeMaster>,
-    private readonly dataSource: DataSource,
-  ) {}
-
-  // ---------- 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: In([entityType]),
-        organization_id: loggedInUser.organization_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: {
-    organization_id: loggedInUser.organization_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,
-        organization_id: loggedInUser.organization_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 result = await this.dataSource.query(
-      `SELECT db_table_name FROM frm_entity_master WHERE mapped_entity_type = ? AND organization_id = ?`,
-      [entityType, loggedInUser.organization_id],
-    );
-    return result.length ? result[0].db_table_name : null;
-  }
-
-  async checkIfColumnExists(
-    tableName: string,
-    columnName: string,
-  ): Promise<boolean> {
-    const result = await this.dataSource.query(
-      `SHOW COLUMNS FROM \`${tableName}\` LIKE ?`,
-      [columnName],
-    );
-    return result.length > 0;
-  }
-
-  async addColumnToTable(
-    tableName: string,
-    columnName: string,
-    columnType: string,
-  ): Promise<void> {
-    const alterQuery = `ALTER TABLE \`${tableName}\` ADD COLUMN \`${columnName}\` ${columnType} NULL`;
-    await this.dataSource.query(alterQuery);
-  }
-
-  async findByMappedEntityTypeAndAttributeKeyAndOrganizationId(mapped_entity_type: string, attribute_key: string, organization_id: number) {
-    return await this.attributeMasterRepository.findOne({
-      where: {
-        mapped_entity_type, attribute_key, organization_id
-      }
-    })
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { AttributeMaster } from '../entity/attribute-master.entity';
+import { In, Repository, DataSource } from 'typeorm';
+import { UserData } from 'src/module/user/entity/user.entity';
+
+@Injectable()
+export class AttributeMasterRepository {
+  constructor(
+    @InjectRepository(AttributeMaster)
+    private readonly attributeMasterRepository: Repository<AttributeMaster>,
+    private readonly dataSource: DataSource,
+  ) {}
+
+  // ---------- 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: In([entityType]),
+        organization_id: loggedInUser.organization_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: {
+    organization_id: loggedInUser.organization_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,
+        organization_id: loggedInUser.organization_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 result = await this.dataSource.query(
+      `SELECT db_table_name FROM frm_entity_master WHERE mapped_entity_type = $1 AND organization_id = $2`,
+      [entityType, loggedInUser.organization_id],
+    );
+    return result.length ? result[0].db_table_name : null;
+  }
+
+  async checkIfColumnExists(
+    tableName: string,
+    columnName: string,
+  ): Promise<boolean> {
+    const result = await this.dataSource.query(
+      `SHOW COLUMNS FROM \`${tableName}\` LIKE $1`,
+      [columnName],
+    );
+    return result.length > 0;
+  }
+
+  async addColumnToTable(
+    tableName: string,
+    columnName: string,
+    columnType: string,
+  ): Promise<void> {
+    const alterQuery = `ALTER TABLE \`${tableName}\` ADD COLUMN \`${columnName}\` ${columnType} NULL`;
+    await this.dataSource.query(alterQuery);
+  }
+
+  async findByMappedEntityTypeAndAttributeKeyAndOrganizationId(mapped_entity_type: string, attribute_key: string, organization_id: number) {
+    return await this.attributeMasterRepository.findOne({
+      where: {
+        mapped_entity_type, attribute_key, organization_id
+      }
+    })
+  }
+}

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

@@ -1,44 +1,44 @@
-import { Injectable } from '@nestjs/common';
-import { DataSource } from 'typeorm';
-
-@Injectable()
-export class EntityUpdateRepository {
-  constructor(private readonly dataSource: DataSource) {}
-
-
- async updateEntityAttribute(entity, config ) {
-  const {entityType, organization_id} = entity;
-
-  // 1. Get the table name
-
-  const result = await this.dataSource.query(
-    `SELECT db_table_name 
-     FROM frm_entity_master 
-     WHERE mapped_entity_type = ?
-     and organization_id = ?`,
-    [config.entity_type, organization_id],
-  );
-
-  if (!result.length) {
-    throw new Error("Entity table not found");
-  }
-
-  const entityTableName = result[0].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.dataSource
-  .createQueryBuilder()
-  .update(entityTableName)
-  .set({ [config.attribute_key]: config.attribute_value })
-  .where(`${idColumn} = :id`, { id: entity.id })
-  .execute();
-
-}
-
-}
+import { Injectable } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+
+@Injectable()
+export class EntityUpdateRepository {
+  constructor(private readonly dataSource: DataSource) {}
+
+
+ async updateEntityAttribute(entity, config ) {
+  const {entityType, organization_id} = entity;
+
+  // 1. Get the table name
+
+  const result = await this.dataSource.query(
+    `SELECT db_table_name 
+     FROM frm_entity_master 
+     WHERE mapped_entity_type = ?
+     and organization_id = ?`,
+    [config.entity_type, organization_id],
+  );
+
+  if (!result.length) {
+    throw new Error("Entity table not found");
+  }
+
+  const entityTableName = result[0].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.dataSource
+  .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,99 +1,99 @@
-import { Inject, Injectable } from '@nestjs/common';
-import { EntityMaster } from '../entity/entity-master.entity';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository, DataSource } from 'typeorm';
-import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
-import { EntityRelationService } from '../service/entity-relation.service';
-import { EntityRelation } from '../entity/entity-relation.entity';
-
-@Injectable()
-export class EntityMasterRepository {
-  constructor(
-    @InjectRepository(EntityMaster)
-    private readonly entityMasterRepository: Repository<EntityMaster>,
-    private readonly dataSource: DataSource,
-    @Inject('ListMasterService')
-    private readonly listMasterService: ListMasterService,
-    @InjectRepository(EntityRelation)
-    private readonly entityRelationRepo: Repository<EntityRelation>
-  ) {}
-
-  async getEntityById(id: number): Promise<EntityMaster | null> {
-    let data = await this.entityMasterRepository.findOne({ where: { id } });
-    if (data) {
-      let listMasterData = await this.entityMasterRepository.query(
-        `SELECT * FROM frm_list_master_items where id = ?`,
-        [data?.status],
-      );
-      data.status = listMasterData?.[0].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.organization_id = :orgId', { orgId: loggedInUser.organization_id })
-  .getRawMany();
-
-  // console.log(relations,"-------------")
- let parentEntityLabelName = await this.entityMasterRepository.findOne({where:{organization_id: loggedInUser.organization_id,mapped_entity_type:entity_type}});
-let dropdownData :any[]=[...relations];
-if(parentEntityLabelName) {
-   dropdownData.push({label:parentEntityLabelName.name,value:entity_type
-  });
-}
-
-return dropdownData.length ? dropdownData:[];
-}
-
-
-  async getEntityByMappedEntityType(
-    mappedEntityType: string,
-    organizationId: number,
-  ): Promise<EntityMaster | null> {
-    return await this.entityMasterRepository.findOne({
-      where: {
-        mapped_entity_type: mappedEntityType,
-        organization_id: organizationId,
-      },
-    });
-  }
-
-  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 organization_id = loggedInUser.organization_id;
-
-    const attributes = await this.dataSource.query(
-      `SELECT * FROM frm_entity_attribute WHERE mapped_entity_type = ? AND data_type = 'DATE' AND organization_id = ?`,
-      [entity_type, organization_id],
-    );
-
-    const attributeList = attributes.map((attr) => ({
-      label: attr.name,
-      value: attr.attribute_key,
-    }));
-
-    return attributeList;
-  }
-}
+import { Inject, Injectable } from '@nestjs/common';
+import { EntityMaster } from '../entity/entity-master.entity';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository, DataSource } from 'typeorm';
+import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
+import { EntityRelationService } from '../service/entity-relation.service';
+import { EntityRelation } from '../entity/entity-relation.entity';
+
+@Injectable()
+export class EntityMasterRepository {
+  constructor(
+    @InjectRepository(EntityMaster)
+    private readonly entityMasterRepository: Repository<EntityMaster>,
+    private readonly dataSource: DataSource,
+    @Inject('ListMasterService')
+    private readonly listMasterService: ListMasterService,
+    @InjectRepository(EntityRelation)
+    private readonly entityRelationRepo: Repository<EntityRelation>
+  ) {}
+
+  async getEntityById(id: number): Promise<EntityMaster | null> {
+    let data = await this.entityMasterRepository.findOne({ where: { id } });
+    if (data) {
+      let listMasterData = await this.entityMasterRepository.query(
+        `SELECT * FROM frm_list_master_items where id = $1`,
+        [data?.status],
+      );
+      data.status = listMasterData?.[0].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.organization_id = :orgId', { orgId: loggedInUser.organization_id })
+  .getRawMany();
+
+  // console.log(relations,"-------------")
+ let parentEntityLabelName = await this.entityMasterRepository.findOne({where:{organization_id: loggedInUser.organization_id,mapped_entity_type:entity_type}});
+let dropdownData :any[]=[...relations];
+if(parentEntityLabelName) {
+   dropdownData.push({label:parentEntityLabelName.name,value:entity_type
+  });
+}
+
+return dropdownData.length ? dropdownData:[];
+}
+
+
+  async getEntityByMappedEntityType(
+    mappedEntityType: string,
+    organizationId: number,
+  ): Promise<EntityMaster | null> {
+    return await this.entityMasterRepository.findOne({
+      where: {
+        mapped_entity_type: mappedEntityType,
+        organization_id: organizationId,
+      },
+    });
+  }
+
+  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 organization_id = loggedInUser.organization_id;
+
+    const attributes = await this.dataSource.query(
+      `SELECT * FROM frm_entity_attribute WHERE mapped_entity_type = $1 AND data_type = 'DATE' AND organization_id = $2`,
+      [entity_type, organization_id],
+    );
+
+    const attributeList = attributes.map((attr) => ({
+      label: attr.name,
+      value: attr.attribute_key,
+    }));
+
+    return attributeList;
+  }
+}

package/src/module/meta/repository/entity-table-column.repository.ts

@@ -1,39 +1,39 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { EntityTableColumn } from '../entity/entity-table-column.entity';
-import { Repository } from 'typeorm';
-
-@Injectable()
-export class EntityTableColumnRepository {
-  constructor(
-    @InjectRepository(EntityTableColumn)
-    private entityTableColumnRepository: Repository<EntityTableColumn>,
-  ) {}
-
-  async findByParentIdAndParentType(
-    parentId: number,
-    parentType: string,
-    organization_id,
-    isVisible?: boolean,
-  ) {
-    if (isVisible) {
-      return await this.entityTableColumnRepository.find({
-        where: {
-          parent_id: parentId,
-          parent_type: parentType,
-          organization_id: organization_id,
-        },
-        order: { col_position: 'ASC' },
-      });
-    }
-    return await this.entityTableColumnRepository.find({
-      where: {
-        parent_id: parentId,
-        parent_type: parentType,
-        visible: '1',
-        organization_id: organization_id,
-      },
-      order: { col_position: 'ASC' },
-    });
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { EntityTableColumn } from '../entity/entity-table-column.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class EntityTableColumnRepository {
+  constructor(
+    @InjectRepository(EntityTableColumn)
+    private entityTableColumnRepository: Repository<EntityTableColumn>,
+  ) {}
+
+  async findByParentIdAndParentType(
+    parentId: number,
+    parentType: string,
+    organization_id,
+    isVisible?: boolean,
+  ) {
+    if (isVisible) {
+      return await this.entityTableColumnRepository.find({
+        where: {
+          parent_id: parentId,
+          parent_type: parentType,
+          organization_id: organization_id,
+        },
+        order: { col_position: 'ASC' },
+      });
+    }
+    return await this.entityTableColumnRepository.find({
+      where: {
+        parent_id: parentId,
+        parent_type: parentType,
+        visible: '1',
+        organization_id: organization_id,
+      },
+      order: { col_position: 'ASC' },
+    });
+  }
+}