rez_core 1.0.41 → 1.0.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "description": "",
   "author": "",
   "private": false,
@@ -21,6 +21,7 @@
     "prepare": "husky"
   },
   "dependencies": {
+    "@nestjs/axios": "^4.0.0",
     "@nestjs/common": "^11.0.1",
     "@nestjs/config": "^4.0.1",
     "@nestjs/core": "^11.0.1",
@@ -31,6 +32,7 @@
     "@nestjs/typeorm": "^11.0.0",
     "250218_nodejs_core": "file:",
     "aws-sdk": "^2.1692.0",
+    "axios": "^1.9.0",
     "bcrypt": "^5.1.1",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",

package/src/module/listmaster/controller/list-master.controller.ts

@@ -6,9 +6,9 @@ export class ListMasterController {
 
   constructor(private readonly service: ListMasterService) {}
 
-  @Get(':type')
-  getDropdownData(@Param('type') type: string) {
-    return this.service.getDropdownOptions(type);
+  @Get('/getDropdownData/:type')
+  async getDropdownData(@Param('type') type: string) {
+    return await this.service.getDropdownOptions(type);
   }
 
 }

package/src/module/listmaster/entity/list-master.entity.ts

@@ -9,27 +9,18 @@ export class ListMasterData extends BaseEntity {
     this.entity_type = ENTITYTYPE_LISTMASTER;
   }
 
-  @PrimaryGeneratedColumn()
-  id: number;
-
   @Column()
   type: string;
 
   @Column()
-  name: string;
-
-  @Column()
-  status: string;
-
-  @Column()
-  sortby: string;
+  sort_by: string;
 
   @Column()
-  isfactory: number;
+  is_factory: number;
 
   @Column()
   source: string;
 
   @Column({ nullable: true })
-  sourcelist: string;
+  source_list: string;
 }

package/src/module/listmaster/listmaster.module.ts

@@ -6,9 +6,11 @@ import { ListMasterRepository } from './repository/list-master.repository';
 import { ListMasterItemsRepository } from './repository/list-master-items.repository';
 import { ListMasterService } from './service/list-master.service';
 import { EntityModule } from '../meta/entity.module';
+import { ListMasterController } from './controller/list-master.controller';
 
 @Module({
   imports: [TypeOrmModule.forFeature([ListMasterData, ListMasterItems]),EntityModule],
   providers: [ListMasterRepository, ListMasterItemsRepository, ListMasterService],
+  controllers: [ListMasterController]
 })
 export class ListMasterModule {}

package/src/module/listmaster/service/list-master.service.ts

@@ -1,5 +1,9 @@
 import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
-import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
 import { ListMasterItemsRepository } from '../repository/list-master-items.repository';
 import { ListMasterRepository } from '../repository/list-master.repository';
 
@@ -19,7 +23,7 @@ export class ListMasterService extends EntityServiceImpl {
 
     switch (config.source) {
       case 'entity':
-        return this.fetchFromEntity(config.sourcelist);
+        return this.fetchFromEntity(type);
 
       case 'master':
         return this.listItemsRepo.findItemsByType(type);
@@ -33,12 +37,22 @@ export class ListMasterService extends EntityServiceImpl {
     }
   }
 
-  private async fetchFromEntity(sourcelist: string) {
-    if (sourcelist === 'USR') {
-      // Example: hardcoded until dynamic entity registry is done
-      return [{ label: 'User A', value: 1 }, { label: 'User B', value: 2 }];
+  private async fetchFromEntity(sourceList: string) {
+    let result: { label: string; value: number }[] = [];
+    if (sourceList) {
+      const entityMaster =
+        await this.entityMasterService.getEntityData(sourceList);
+
+      let baseEntities = await super.getEntityList(
+        entityMaster.mapped_entity_type,
+      );
+      baseEntities.forEach((entity) => {
+        result.push({
+          label: entity.name,
+          value: parseInt(String(entity.id)),
+        });
+      });
     }
-
-    throw new NotFoundException(`Entity source ${sourcelist} not handled yet`);
+    return result;
   }
-}
+}

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/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/service/media-data.service.ts

@@ -44,7 +44,7 @@ export class MediaDataService extends EntityServiceImpl {
     const ext = fileName.split('.').pop()?.toLowerCase() ?? '';
 
     const id = uuidv4();
-    const s3Key = `uploads/${mappedAttributeKey}/${id}.${ext}`;
+    const s3Key = `uploads/${id}.${ext}`;
     console.log(s3Key)
 
     const uploadUrl = await this.s3.getSignedUrlPromise('putObject', {

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,
+      },
+    });
+  }
+}

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

@@ -0,0 +1,13 @@
+import { Injectable } from '@nestjs/common';
+import { ThirdPartyApiRegistryRepository } from '../repository/third-party-api-registry.repository';
+
+@Injectable()
+export class ApiRegistryService {
+  constructor(
+    private readonly thirdPartyApiRegistryRepository: ThirdPartyApiRegistryRepository,
+  ) {}
+
+  async findById(id: number) {
+    return await this.thirdPartyApiRegistryRepository.findById(id);
+  }
+}

package/src/module/third-party-module/third-party.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ThirdPartyApiRegistry } from './entity/third-party-api-registry.entity';
+import { ThirdPartyApiRegistryRepository } from './repository/third-party-api-registry.repository';
+import { ApiRegistryService } from './service/api-registry.service';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([ThirdPartyApiRegistry])],
+  providers: [ThirdPartyApiRegistryRepository, ApiRegistryService],
+  exports: [ApiRegistryService],
+})
+export class ThirdPartyModule {}