rez_core 1.0.63 → 1.0.65

package/src/module/master/service/master.service.ts

@@ -1,16 +1,11 @@
 import { Injectable } from '@nestjs/common';
-import { EntityManager, Unique } from 'typeorm';
+import { EntityManager } from 'typeorm';
 import { ExcelUtil } from 'src/utils/service/excelUtil.service';
 import { EntityMasterService } from '../../meta/service/entity-master.service';
-import { table } from 'console';
 import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
 import { EntityMaster } from 'src/module/meta/entity/entity-master.entity';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
-
-interface ParentEntity {
-  id: number;
-  code: string;
-}
+import { ReflectionHelper } from 'src/utils/service/reflection-helper.service';
 
 @Injectable()
 export class MasterService {
@@ -19,6 +14,8 @@ export class MasterService {
     private readonly entityMasterService: EntityMasterService,
     private readonly attributeMasterService: AttributeMasterService,
     private readonly excelUtil: ExcelUtil,
+        private reflectionHelper: ReflectionHelper,
+    
     private readonly entityServiceImpl: EntityServiceImpl,
   ) {}
 
@@ -46,7 +43,6 @@ export class MasterService {
       unique_fields: ['listtype', 'code'],
     },
   ];
-
   private readonly dataSequence = [
     {
       table: 'cr_user',
@@ -70,43 +66,7 @@ export class MasterService {
     },
   ];
 
-  private isMetaSheet(sheetName: string): boolean {
-    return this.metaSheets.includes(sheetName.toLowerCase());
-  }
-
-  private async resolveParent(row: any): Promise<void> {
-    const parentType = row.parent_type; // (Future use maybe)
-    const code = row.parent_id;
-
-    if (!code) {
-      throw new Error('Parent code is missing in the row');
-    }
-
-    const parentEntity: EntityMaster | null =
-      await this.entityMasterService.findByMappedEntityType(parentType);
-
-    const tableName: any = parentEntity?.db_table_name;
-    if (!tableName) {
-      throw new Error(`Table name not found for parent type ${parentType}`);
-    }
-
-    // Using RAW SQL Query
-    const entityData = await this.entityManager.query(
-      `SELECT * FROM ${tableName} WHERE code = ? LIMIT 1`,
-      [code],
-    );
-
-    if (!entityData || entityData.length === 0) {
-      throw new Error(
-        `Parent entity with code ${code} not found in table ${tableName}`,
-      );
-    }
-
-    // entityData is an array when using .query()
-    row.parent_id = entityData[0].id;
-  }
-
-  async uploadMasterData(file) {
+  async uploadMeta(file) {
     const data = ExcelUtil.readExcel(file.buffer);
 
     for (let i = 0; i < this.sequence.length; i++) {
@@ -122,6 +82,14 @@ export class MasterService {
         await this.upsertData(table, unique_fields, sheetData);
       }
     }
+    return {
+      message: 'Data uploaded successfully',
+    };
+  }
+
+  async uploadData(file) {
+    const data = ExcelUtil.readExcel(file.buffer);
+
     for (let i = 0; i < this.dataSequence.length; i++) {
       const { table, unique_fields } = this.dataSequence[i];
       const sheetData = data[table];
@@ -139,7 +107,6 @@ export class MasterService {
           entityMasterData?.mapped_entity_type,
         );
 
-        console.log(attributes,"((((((((((((((((((((((((((")
       for (const row of sheetData) {
         if (row.parent_type !== undefined && row.parent_id !== undefined) {
           this.resolveParent(row);
@@ -147,7 +114,7 @@ export class MasterService {
 
         for (const attribute of attributes) {
           if (attribute.data_source_type === 'entity') {
-            console.log(attribute.data_source_type)
+            console.log(attribute.data_source_type);
             let entityMaster = await this.entityMasterService.getEntityData(
               attribute.datasource_list,
             );
@@ -168,6 +135,95 @@ export class MasterService {
     };
   }
 
+  async uploadEntityData(file, entityType, loggedInUser) {
+    const data = ExcelUtil.readExcel(file.buffer);
+    const entityMaster = await this.entityMasterService.findByMappedEntityType(entityType);
+    if (!entityMaster) {
+      throw new Error(`Entity master not found for entityType: ${entityType}`);
+    }
+  
+    const tableName = entityMaster.db_table_name;
+    const sheetData = data[tableName];
+  
+    if (!sheetData) {
+      throw new Error(`Sheet for ${tableName} not found in uploaded file`);
+    }
+  
+    const attributes = await this.attributeMasterService.findAttributesByMappedEntityType(entityType);
+  
+    const uniqueFields = attributes
+      .filter(attr => attr.is_unique)
+      .map(attr => attr.attribute_key);
+  
+    if (uniqueFields.length === 0) {
+      throw new Error(`No unique fields found for entityType: ${entityType}`);
+    }
+  
+    // Transform reference fields
+    for (const row of sheetData) {
+      if (row.parent_type && row.parent_id) {
+        await this.resolveParent(row);
+      }
+  
+      for (const attr of attributes) {
+        if (attr.data_source_type === 'entity' && row[attr.attribute_key]) {
+          const refEntity = await this.entityMasterService.getEntityData(attr.datasource_list);
+          const refData = await this.entityManager.query(
+            `SELECT * FROM ${refEntity.db_table_name} WHERE code = ? LIMIT 1`,
+            [row[attr.attribute_key]],
+          );
+  
+          if (!refData.length) {
+            throw new Error(`Reference entity not found for code: ${row[attr.attribute_key]}`);
+          }
+  
+          row[attr.attribute_key] = refData[0].id;
+        }
+      }
+    }
+  
+    await this.upsertViaService(entityType, sheetData, attributes, uniqueFields, loggedInUser);
+  
+    return { message: 'Entity data uploaded successfully' };
+  }
+  
+
+  private isMetaSheet(sheetName: string): boolean {
+    return this.metaSheets.includes(sheetName.toLowerCase());
+  }
+
+  private async resolveParent(row: any): Promise<void> {
+    const parentType = row.parent_type; // (Future use maybe)
+    const code = row.parent_id;
+
+    if (!code) {
+      throw new Error('Parent code is missing in the row');
+    }
+
+    const parentEntity: EntityMaster | null =
+      await this.entityMasterService.findByMappedEntityType(parentType);
+
+    const tableName: any = parentEntity?.db_table_name;
+    if (!tableName) {
+      throw new Error(`Table name not found for parent type ${parentType}`);
+    }
+
+    // Using RAW SQL Query
+    const entityData = await this.entityManager.query(
+      `SELECT * FROM ${tableName} WHERE code = ? LIMIT 1`,
+      [code],
+    );
+
+    if (!entityData || entityData.length === 0) {
+      throw new Error(
+        `Parent entity with code ${code} not found in table ${tableName}`,
+      );
+    }
+
+    // entityData is an array when using .query()
+    row.parent_id = entityData[0].id;
+  }
+
   async upsertData(
     tableName: string,
     uniqueFields: string[],
@@ -210,4 +266,45 @@ export class MasterService {
       }
     }
   }
+
+  async upsertViaService(
+    entityType: string,
+    data: any[],
+    attributes: any[],
+    uniqueFields: string[],
+    loggedInUser: any,
+  ): Promise<void> {
+    const entityMaster = await this.entityMasterService.findByMappedEntityType(entityType);
+    if (!entityMaster) throw new Error(`Entity master not found for ${entityType}`);
+  
+    const serviceName = entityMaster.entity_service;
+    const entityService = await this.reflectionHelper.getBean<EntityServiceImpl>(serviceName);
+  
+    if (!entityService) throw new Error(`Entity service not found for ${entityType}`);
+  
+    for (const row of data) {
+      const whereClause = uniqueFields.reduce((acc, field) => {
+        acc[field] = row[field];
+        return acc;
+      }, {});
+  
+      const existing = await this.entityManager
+        .createQueryBuilder()
+        .select('*')
+        .from(entityMaster.db_table_name, entityMaster.db_table_name)
+        .where(whereClause)
+        .limit(1)
+        .getRawOne();
+  
+      row.entity_type = entityType;
+      if (existing) {
+        row.id = existing.id;
+        await entityService.updateEntity(row, loggedInUser);
+      } else {
+        await entityService.createEntity(row, loggedInUser);
+      }
+    }
+  }
+  
+
 }

package/src/module/meta/controller/meta.controller.ts

@@ -0,0 +1,22 @@
+import { Controller, HttpStatus, Post, Query, Res, UseGuards } from '@nestjs/common';
+import { EntityTableService } from '../service/entity-table.service';
+import { Response } from 'express';
+import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
+
+@Controller('meta')
+@UseGuards(JwtAuthGuard)
+export class MetaController {
+  constructor(private readonly entityTableService: EntityTableService) {}
+
+  @Post('get-table-data')
+  async getTableMetaData(@Query('entity_type') entityType: string,
+                         @Query('list_type') listType: string,
+                         @Res() response: Response) {
+    let entityTableDto = await this.entityTableService.getTableMetaDataForListing(entityType, listType);
+    return response.status(HttpStatus.OK).json({
+      success: true,
+      data: entityTableDto,
+      message: 'Data fetch successfully!'
+    })
+  }
+}

package/src/module/meta/dto/entity-list-data.dto.ts

@@ -1,6 +1,6 @@
-import { EntityTab } from './entity-tab.dto';
-
-export class EntityListData {
-  entity_list: any;
-  entity_tabs: EntityTab[];
-}
+import { EntityTab } from './entity-tab.dto';
+
+export class EntityListData {
+  entity_list: any;
+  entity_tabs: EntityTab[];
+}

package/src/module/meta/dto/entity-table.dto.ts

@@ -0,0 +1,6 @@
+import { EntityTable } from '../entity/entity-table.entity';
+import { EntityTableColumn } from '../entity/entity-table-column.entity';
+
+export class EntityTableDto extends EntityTable{
+  column_list: EntityTableColumn[];
+}

package/src/module/meta/entity/preference.entity.ts

@@ -1,65 +1,65 @@
-import { BaseEntity } from './base-entity.entity';
-import { Column, Entity } from 'typeorm';
-import { ENTITYTYPE_PREFERENCEMASTER } from '../../../constant/global.constant';
-
-@Entity({ name: 'cr_preference_master' })
-export class PreferenceMaster extends BaseEntity {
-  constructor() {
-    super();
-    this.entity_type = ENTITYTYPE_PREFERENCEMASTER;
-  }
-
-  @Column({ name: 'appcode', type: 'varchar', length: 200, nullable: true })
-  appCode: string;
-
-  @Column({
-    name: 'display_name',
-    type: 'varchar',
-    length: 200,
-    nullable: true,
-  })
-  display_name: string;
-
-  @Column({
-    name: 'preference_key',
-    type: 'varchar',
-    length: 200,
-    nullable: true,
-  })
-  preference_key: string;
-
-  @Column({
-    name: 'preference_value',
-    type: 'varchar',
-    length: 200,
-    nullable: true,
-  })
-  preference_value: string;
-
-  @Column({
-    name: 'description',
-    type: 'varchar',
-    length: 2000,
-    nullable: true,
-  })
-  description: string;
-
-  @Column({ name: 'reflect_on', type: 'varchar', length: 200, nullable: true })
-  reflect_on: string;
-
-  @Column({
-    name: 'default_value',
-    type: 'varchar',
-    length: 200,
-    nullable: true,
-  })
-  default_value: string;
-
-  @Column({
-    name: 'possible_values',
-    type: 'varchar',
-    length: 200,
-    nullable: true,
-  })
-  possible_values: string;
-}
+import { BaseEntity } from './base-entity.entity';
+import { Column, Entity } from 'typeorm';
+import { ENTITYTYPE_PREFERENCEMASTER } from '../../../constant/global.constant';
+
+@Entity({ name: 'cr_preference_master' })
+export class PreferenceMaster extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ENTITYTYPE_PREFERENCEMASTER;
+  }
+
+  @Column({ name: 'appcode', type: 'varchar', length: 200, nullable: true })
+  appCode: string;
+
+  @Column({
+    name: 'display_name',
+    type: 'varchar',
+    length: 200,
+    nullable: true,
+  })
+  display_name: string;
+
+  @Column({
+    name: 'preference_key',
+    type: 'varchar',
+    length: 200,
+    nullable: true,
+  })
+  preference_key: string;
+
+  @Column({
+    name: 'preference_value',
+    type: 'varchar',
+    length: 200,
+    nullable: true,
+  })
+  preference_value: string;
+
+  @Column({
+    name: 'description',
+    type: 'varchar',
+    length: 2000,
+    nullable: true,
+  })
+  description: string;
+
+  @Column({ name: 'reflect_on', type: 'varchar', length: 200, nullable: true })
+  reflect_on: string;
+
+  @Column({
+    name: 'default_value',
+    type: 'varchar',
+    length: 200,
+    nullable: true,
+  })
+  default_value: string;
+
+  @Column({
+    name: 'possible_values',
+    type: 'varchar',
+    length: 200,
+    nullable: true,
+  })
+  possible_values: string;
+}

package/src/module/meta/entity.module.ts

@@ -34,6 +34,7 @@ import { FieldGroupService } from './service/field-group.service';
 import { ViewMasterService } from './service/view-master.service';
 import { ViewMasterController } from './controller/view-master.controller';
 import { ViewMaterRespository } from './repository/view-master.repository';
+import { MetaController } from './controller/meta.controller';
 
 @Module({
   imports: [
@@ -84,6 +85,6 @@ import { ViewMaterRespository } from './repository/view-master.repository';
     FieldGroupService,
     'ViewMasterService',
   ],
-  controllers: [EntityController, MasterController, MediaController, ViewMasterController],
+  controllers: [EntityController, MasterController, MediaController, ViewMasterController, MetaController],
 })
 export class EntityModule {}

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

@@ -16,6 +16,7 @@ export class EntityTableColumnRepository {
         parent_id: parentId,
         parent_type: parentType,
       },
+      order: { col_position: 'ASC' }
     });
   }
 }

package/src/module/meta/repository/preference.repository.ts

@@ -1,20 +1,20 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { PreferenceMaster } from '../entity/preference.entity';
-import { Repository } from 'typeorm';
-
-@Injectable()
-export class PreferenceRepository {
-  constructor(
-    @InjectRepository(PreferenceMaster)
-    private readonly preferenceRepository: Repository<PreferenceMaster>,
-  ) {}
-
-  async findByPreferenceKey(
-    preferenceKey: string,
-  ): Promise<PreferenceMaster | null> {
-    return await this.preferenceRepository.findOne({
-      where: { preference_key: preferenceKey },
-    });
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { PreferenceMaster } from '../entity/preference.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class PreferenceRepository {
+  constructor(
+    @InjectRepository(PreferenceMaster)
+    private readonly preferenceRepository: Repository<PreferenceMaster>,
+  ) {}
+
+  async findByPreferenceKey(
+    preferenceKey: string,
+  ): Promise<PreferenceMaster | null> {
+    return await this.preferenceRepository.findOne({
+      where: { preference_key: preferenceKey },
+    });
+  }
+}

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

@@ -1,9 +1,15 @@
 import { Injectable } from '@nestjs/common';
 import { EntityTableRepository } from '../repository/entity-table.repository';
+import { EntityTableColumnRepository } from '../repository/entity-table-column.repository';
+import { EntityTableDto } from '../dto/entity-table.dto';
+import { DISPLAY_LIST } from '../../../constant/global.constant';
 
 @Injectable()
 export class EntityTableService {
-  constructor(private entityTableRepository: EntityTableRepository) {}
+  constructor(
+    private entityTableRepository: EntityTableRepository,
+    private readonly entityTableColumnRepository: EntityTableColumnRepository,
+  ) {}
 
   async findByEntityTypeAndListType(entityType: string, listType: string) {
     return await this.entityTableRepository.findByEntityTypeAndListType(
@@ -12,7 +18,41 @@ export class EntityTableService {
     );
   }
 
-  async findByEntityTypeAndListTypeAndDisplayType(entityType: string, listType: string, displayType: string) {
-    return await this.entityTableRepository.findByEntityTypeAndListTypeAndDisplayType(entityType, listType, displayType);
+  async findByEntityTypeAndListTypeAndDisplayType(
+    entityType: string,
+    listType: string,
+    displayType: string,
+  ) {
+    return await this.entityTableRepository.findByEntityTypeAndListTypeAndDisplayType(
+      entityType,
+      listType,
+      displayType,
+    );
+  }
+
+  async getTableMetaDataForListing(entityType: string, listType: string) {
+    return await this.getTableMetaData(entityType, listType, DISPLAY_LIST);
+  }
+
+  async getTableMetaData(
+    entityType: string,
+    listType: string,
+    displayType: string,
+  ) {
+    let entityTable = await this.findByEntityTypeAndListTypeAndDisplayType(
+      entityType,
+      listType,
+      displayType,
+    );
+
+    let entityTableDto = entityTable as EntityTableDto;
+    if (entityTable) {
+      entityTableDto.column_list =
+        await this.entityTableColumnRepository.findByParentIdAndParentType(
+          entityTable.id,
+          entityTable.entity_type,
+        );
+    }
+    return entityTableDto;
   }
 }

package/src/module/module/controller/menu.controller.ts

@@ -1,15 +1,15 @@
-import { Controller, Get, Request, UseGuards } from '@nestjs/common';
-import { MenuService } from '../service/menu.service';
-import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
-
-@Controller('menu')
-export class MenuController {
-  constructor(private readonly menuService: MenuService) {}
-
-  @UseGuards(JwtAuthGuard)
-  @Get()
-  async getMenu(@Request() req) {
-    const userId = req.user.userId;
-    return this.menuService.getUserMenu(userId);
-  }
-}
+import { Controller, Get, Request, UseGuards } from '@nestjs/common';
+import { MenuService } from '../service/menu.service';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+
+@Controller('menu')
+export class MenuController {
+  constructor(private readonly menuService: MenuService) {}
+
+  @UseGuards(JwtAuthGuard)
+  @Get()
+  async getMenu(@Request() req) {
+    const userId = req.user.userId;
+    return this.menuService.getUserMenu(userId);
+  }
+}

package/src/module/module/entity/module-access.entity.ts

@@ -1,22 +1,22 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
-
-@Entity({ name: 'cr_module_access' })
-export class ModuleAccess {
-  @PrimaryGeneratedColumn()
-  id: number;
-
-  @Column({type: 'varchar', length: 100, nullable: true})
-  module_code: string;
-
-  @Column({type: 'varchar', length: 100, nullable: true })
-  role_code: string;
-
-  @Column({type: 'int', nullable: true })
-  access_flag: number;
-
-  @Column({type: 'varchar', length: 100, nullable: true })
-  action_type: string;
-
-  @Column({type: 'varchar', length: 100, nullable: true})
-  app_code: string;
-}
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'cr_module_access' })
+export class ModuleAccess {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({type: 'varchar', length: 100, nullable: true})
+  module_code: string;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  role_code: string;
+
+  @Column({type: 'int', nullable: true })
+  access_flag: number;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  action_type: string;
+
+  @Column({type: 'varchar', length: 100, nullable: true})
+  app_code: string;
+}