rez_core 1.0.42 → 1.0.43

package/src/module/master/controller/master.controller.ts

@@ -13,14 +13,22 @@ import { Express } from 'express';
 export class MasterController {
   constructor(private readonly masterService: MasterService) {}
 
-  @Post('upload')
+  // @Post('upload')
+  // @UseInterceptors(FileInterceptor('file'))
+  // async uploadFile(@UploadedFile() file) {
+  //   if (!file) {
+  //     throw new Error('File is required');
+  //   }
+  //   return this.masterService.processExcel(file);
+  // }
+
+  @Post('uploadMasterData')
   @UseInterceptors(FileInterceptor('file'))
-  async uploadFile(@UploadedFile() file) {
+
+  async uploadMasterDataXls(@UploadedFile() file: Express.Multer.File) {
     if (!file) {
-      throw new Error('File is required');
+      throw new BadRequestException('File is required');
     }
-    return this.masterService.processExcel(file);
+    return await this.masterService.uploadMasterData(file.buffer);
   }
-
-  
 }

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

@@ -1,11 +1,12 @@
 import { Injectable } from '@nestjs/common';
-import { EntityManager } from 'typeorm';
+import { EntityManager, Unique } from 'typeorm';
 import { ExcelUtil } from 'src/utils/service/excelUtil.service';
 import { EntityMasterService } from '../../meta/service/entity-master.service';
+import { table } from 'console';
 
 interface ParentEntity {
   id: number;
-  code: string; 
+  code: string;
 }
 
 @Injectable()
@@ -17,145 +18,99 @@ export class MasterService {
   ) {}
 
   private readonly metaSheets = [
-    'entity_master',
-    'attribute_master',
-    'list_master',
-    'list_master_items',
+    'cr_entity_master',
+    'cr_attribute_master',
+    'cr_list_master',
+    'cr_list_master_items',
+  ];
+  private readonly sequence = [
+    {
+      table: 'cr_entity_master',
+      unique_fields: ['mapped_entity_type'],
+    },
+    {
+      table: 'cr_attribute_master',
+      unique_fields: ['mapped_entity_type', 'attribute_key'],
+    },
+    {
+      table: 'cr_list_master',
+      unique_fields: ['type'],
+    },
+    {
+      table: 'cr_list_master_items',
+      unique_fields: ['listtype', 'code'],
+    },
   ];
 
   private isMetaSheet(sheetName: string): boolean {
     return this.metaSheets.includes(sheetName.toLowerCase());
   }
 
-  async processExcel(file): Promise<{ message: string }> {
-    console.log('📥 Reading Excel file...');
-    const data = ExcelUtil.readExcel(file.buffer) as Record<string, Record<string, any>[]>;
-
-    for (const [sheetName, records] of Object.entries(data)) {
-      if (!records.length) continue;
-
-      const isMeta = this.isMetaSheet(sheetName);
-      console.log(`📄 Processing sheet: ${sheetName} | Meta: ${isMeta}`);
-
-      if (isMeta) {
-        await this.upsertData(sheetName, records);
-      } else {
-        await this.processEntityData(records);
-      }
-    }
+  async uploadMasterData(file) {
+    const data = ExcelUtil.readExcel(file.buffer);
 
-    return { message: '✅ Data processed successfully' };
-  }
+    for (let i = 0; i < this.sequence.length; i++) {
+      const { table, unique_fields } = this.sequence[i];
+      const sheetData = data[table];
 
-  private async processEntityData(records: Record<string, any>[]): Promise<void> {
-    for (const row of records) {
-      const entityType = row['entity_type'];
-      if (!entityType) {
-        console.warn('⚠️ Skipping row without entity_type:', row);
+      if (!sheetData) {
+        console.log(`Sheet ${table} not found in the Excel file.`);
         continue;
       }
-
-      const { tableName } = await this.getEntityMeta(entityType);
-      const attrMap = await this.getAttributeMap(entityType);
-      const transformed = this.transformRow(row, attrMap);
-
-      // Resolve parent_id if parent_type and parent_id are present
-      if (row['parent_id'] && row['parent_type']) {
-        transformed['parent_id'] = await this.resolveParentId(row['parent_type'], row['parent_id']);
-        transformed['parent_type'] = row['parent_type'];
+      if (this.isMetaSheet(table)) {
+        console.log(`Processing sheet: ${table}`);
+        await this.upsertData(table, unique_fields, sheetData);
       }
+      else{
 
-      await this.insertEntityRow(tableName, transformed);
-    }
-  }
-
-  private async getEntityMeta(entityType: string): Promise<{ tableName: string; mappedEntityType: string }> {
-    const result = await this.entityManager.query(
-      `SELECT db_table_name, mapped_entity_type FROM entity_master WHERE mapped_entity_type = ? LIMIT 1`,
-      [entityType],
-    );
-
-    if (!result.length || !result[0].db_table_name) {
-      throw new Error(`❌ Entity metadata not found for entity_type: ${entityType}`);
+      }
+      
     }
-
     return {
-      tableName: result[0].db_table_name,
-      mappedEntityType: result[0].mapped_entity_type,
+      message: 'Data uploaded successfully',
     };
   }
 
-  private async getAttributeMap(mappedEntityType: string): Promise<Record<string, string>> {
-    const attributes = await this.entityManager.query(
-      'SELECT attribute_key FROM attribute_master WHERE mapped_entity_type = ? AND status = "ACTIVE"',
-      [mappedEntityType],
-    );
-
-    return attributes.reduce((acc, attr) => {
-      acc[attr.attribute_key] = attr.attribute_key;
-      return acc;
-    }, {} as Record<string, string>);
-  }
-
-  private transformRow(row: Record<string, any>, attrMap: Record<string, string>): Record<string, any> {
-    const transformed: Record<string, any> = {};
-    for (const key of Object.keys(row)) {
-      if (attrMap[key]) {
-        transformed[attrMap[key]] = row[key];
-      }
-    }
-    return transformed;
-  }
-
-  private async resolveParentId(parentType: string, parentCode: string): Promise<number> {
-    const { tableName } = await this.getEntityMeta(parentType);
-    const parent = await this.entityManager.findOne<ParentEntity>(tableName, {
-      where: { code: parentCode },
-    });
-
-    if (!parent) {
-      throw new Error(`❌ Parent with code "${parentCode}" not found in "${tableName}"`);
-    }
-
-    return parent.id;
-  }
-
-  private async insertEntityRow(tableName: string, data: Record<string, any>): Promise<void> {
-    const keys = Object.keys(data);
-    if (!keys.length) {
-      console.warn('⚠️ Empty data, skipping insert');
-      return;
-    }
-
-    await this.entityManager
-      .createQueryBuilder()
-      .insert()
-      .into(tableName)
-      .values(data)
-      .orUpdate({
-        overwrite: keys,
-        conflict_target: ['code'],
-      })
-      .execute();
-  }
-
-  private async upsertData(tableName: string, records: Record<string, any>[]): Promise<void> {
-    if (!records.length) return;
-
-    const keys = Object.keys(records[0]);
-    await this.entityManager.transaction(async (manager) => {
-      for (const record of records) {
-        await manager
+  async upsertData(
+    tableName: string,
+    uniqueFields: string[],
+    data: any[],
+  ): Promise<void> {
+    for (const row of data) {
+      const whereClause = uniqueFields
+        .map((field) => `${field} = :${field}`)
+        .join(' AND ');
+
+      const whereParams = uniqueFields.reduce((acc, field) => {
+        acc[field] = row[field];
+        return acc;
+      }, {});
+
+      const existing = await this.entityManager
+        .createQueryBuilder()
+        .select('*')
+        .from(tableName, tableName)
+        .where(whereClause, whereParams)
+        .limit(1)
+        .getRawMany();
+
+      if (existing.length > 0) {
+        // Update
+        await this.entityManager
+          .createQueryBuilder()
+          .update(tableName)
+          .set(row)
+          .where(whereClause, whereParams)
+          .execute();
+      } else {
+        // Insert
+        await this.entityManager
           .createQueryBuilder()
           .insert()
           .into(tableName)
-          .values(record)
-          .orUpdate({
-            overwrite: keys,
-            conflict_target: ['id'],
-          })
+          .values(row)
           .execute();
       }
-    });
+    }
   }
 }

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/entity/attribute-master.entity.ts

@@ -6,7 +6,7 @@ export class AttributeMaster extends BaseEntity {
   @Column({ name: 'mapped_entity_type', type: 'varchar', nullable: true })
   mapped_entity_type: string;
 
-  @Column({ name: 'mapped_entity_id' })
+  @Column({ name: 'mapped_entity_id' ,nullable: true })
   mapped_entity_id: number;
 
   @Column({ name: 'element_type', type: 'varchar', nullable: true, length: 50 })
@@ -64,4 +64,7 @@ export class AttributeMaster extends BaseEntity {
 
   @Column({ name: 'can_export', nullable: true })
   can_export: number;
+
+  @Column({ name: 'appcode', nullable: true })
+  appcode:string;
 }

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

@@ -18,7 +18,7 @@ export class EntityMaster extends BaseEntity {
   mapped_entity_type: string;
 
   @Column({ name: 'appcode', type: 'varchar', length: 50, nullable: true })
-  appCode: string;
+  appcode: string;
 
   @Column({ name: 'category', type: 'varchar', length: 50, nullable: true })
   category: string;
@@ -60,4 +60,6 @@ export class EntityMaster extends BaseEntity {
 
   @Column({ name: 'storage_type', nullable: true, length: 20 })
   storage_type: string;
+
+
 }

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/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/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;
+}

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

@@ -1,19 +1,19 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
-
-@Entity({ name: 'module_action' })
-export class ModuleAction {
-  @PrimaryGeneratedColumn()
-  id: number;
-
-  @Column({type: 'int', nullable: true})
-  module_id: number;
-  
-  @Column({type: 'varchar', length: 100, nullable: true })
-  module_code: string;
-  
-  @Column({type: 'varchar', length: 100, nullable: true })
-  action_name:string
-
-  @Column({type: 'varchar', length: 50, nullable: true })
-  action_type: string;
-}
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'module_action' })
+export class ModuleAction {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({type: 'int', nullable: true})
+  module_id: number;
+  
+  @Column({type: 'varchar', length: 100, nullable: true })
+  module_code: string;
+  
+  @Column({type: 'varchar', length: 100, nullable: true })
+  action_name:string
+
+  @Column({type: 'varchar', length: 50, nullable: true })
+  action_type: string;
+}

package/src/module/third-party-module/entity/third-party-api-registry.entity.ts

@@ -0,0 +1,43 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'third_party_api_registry' })
+export class ThirdPartyApiRegistry {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({nullable: true})
+  api_name: string;
+
+  @Column({nullable: true})
+  provider_name: string;
+
+  @Column({nullable: true})
+  base_url: string;
+
+  @Column({nullable: true})
+  endpoint: string;
+
+  @Column({nullable: true})
+  http_method: string;
+
+  @Column({type: 'json', nullable: true})
+  headers: string;
+
+  @Column({nullable: true})
+  request_payload_schema: string;
+
+  @Column({nullable: true})
+  auth_type: string;
+
+  @Column({nullable: true, type: 'json'})
+  auth_config: string;
+
+  @Column({nullable: true})
+  is_active: number;
+
+  @Column({nullable: true, type: 'datetime'})
+  created_date:  Date;
+
+  @Column({nullable: true, type: 'datetime'})
+  modified_date: Date;
+}

package/src/module/third-party-module/repository/third-party-api-registry.repository.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { ThirdPartyApiRegistry } from '../entity/third-party-api-registry.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class ThirdPartyApiRegistryRepository {
+  constructor(
+    @InjectRepository(ThirdPartyApiRegistry)
+    private thirdPartyApiRegistryRepository: Repository<ThirdPartyApiRegistry>,
+  ) {}
+
+  async findById(id: number) {
+    return await this.thirdPartyApiRegistryRepository.findOne({
+      where: {
+        id: id,
+      },
+    });
+  }
+}