rez_core 1.0.39 → 1.0.41

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

@@ -0,0 +1,33 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+import { ENTITYTYPE_LISTMASTERITEMS } from '../../../constant/global.constant';
+
+@Entity({name: 'cr_list_master_items'})
+export class ListMasterItems extends BaseEntity{
+  constructor() {
+    super();
+    this.entity_type = ENTITYTYPE_LISTMASTERITEMS;
+  }
+
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  listtype: string;
+
+  @Column()
+  name: string;
+
+  @Column()
+  status: string;
+
+  @Column({ default: 0 })
+  isdefault: number;
+
+  @Column({ nullable: true })
+  description: string;
+
+  @Column({ default: 0 })
+  sortindex: number;
+ 
+}

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

@@ -0,0 +1,35 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+import { ENTITYTYPE_LISTMASTER } from '../../../constant/global.constant';
+
+@Entity({ name: 'cr_list_master' })
+export class ListMasterData extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ENTITYTYPE_LISTMASTER;
+  }
+
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  type: string;
+
+  @Column()
+  name: string;
+
+  @Column()
+  status: string;
+
+  @Column()
+  sortby: string;
+
+  @Column()
+  isfactory: number;
+
+  @Column()
+  source: string;
+
+  @Column({ nullable: true })
+  sourcelist: string;
+}

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

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ListMasterData } from './entity/list-master.entity';
+import { ListMasterItems } from './entity/list-master-items.entity';
+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';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([ListMasterData, ListMasterItems]),EntityModule],
+  providers: [ListMasterRepository, ListMasterItemsRepository, ListMasterService],
+})
+export class ListMasterModule {}

package/src/module/listmaster/repository/list-master-items.repository.ts

@@ -0,0 +1,21 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { ListMasterItems } from '../entity/list-master-items.entity';
+
+@Injectable()
+export class ListMasterItemsRepository{
+
+    constructor(
+        @InjectRepository(ListMasterItems) private repo: Repository<ListMasterItems>,
+      ) {}
+    
+    async findItemsByType(type: string) {
+        const items = await this.repo.find({
+          where: { listtype: type, status: 'active' },
+          order: { sortindex: 'ASC' },
+        });
+        return items.map(i => ({ label: i.name, value: i.name }));
+      }
+
+}

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

@@ -0,0 +1,15 @@
+import { Injectable } from '@nestjs/common';
+import { ListMasterData } from '../entity/list-master.entity';
+import { Repository } from 'typeorm';
+import { InjectRepository } from '@nestjs/typeorm';
+
+@Injectable()
+export class ListMasterRepository{
+
+    constructor(
+        @InjectRepository(ListMasterData) private readonly repo:  Repository<ListMasterData>) {}
+    
+    findByType(type: string) {
+        return this.repo.findOne({ where: { type } });
+      }
+}

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

@@ -0,0 +1,44 @@
+import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
+import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
+import { ListMasterItemsRepository } from '../repository/list-master-items.repository';
+import { ListMasterRepository } from '../repository/list-master.repository';
+
+@Injectable()
+export class ListMasterService extends EntityServiceImpl {
+  constructor(
+    private readonly listMasterRepo: ListMasterRepository,
+    private readonly listItemsRepo: ListMasterItemsRepository,
+  ) {
+    super();
+  }
+
+  async getDropdownOptions(type: string) {
+    const config = await this.listMasterRepo.findByType(type);
+
+    if (!config) throw new NotFoundException(`Type ${type} not found`);
+
+    switch (config.source) {
+      case 'entity':
+        return this.fetchFromEntity(config.sourcelist);
+
+      case 'master':
+        return this.listItemsRepo.findItemsByType(type);
+
+      case 'custom':
+        // Placeholder
+        return { message: `Custom API for type ${type} not implemented` };
+
+      default:
+        throw new BadRequestException(`Unknown source: ${config.source}`);
+    }
+  }
+
+  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 }];
+    }
+
+    throw new NotFoundException(`Entity source ${sourcelist} not handled yet`);
+  }
+}

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

@@ -1,22 +1,26 @@
-import {
-  Controller,
-  Post,
-  UploadedFile,
-  UseInterceptors,
-} from '@nestjs/common';
-import { FileInterceptor } from '@nestjs/platform-express';
-import { MasterService } from '../service/master.service';
-
-@Controller('master')
-export class MasterController {
-  constructor(private readonly masterService: MasterService) {}
-
-  @Post('upload')
-  @UseInterceptors(FileInterceptor('file'))
-  async uploadFile(@UploadedFile() file) {
-    if (!file) {
-      throw new Error('File is required');
-    }
-    return this.masterService.processExcel(file);
-  }
-}
+import {
+  BadRequestException,
+  Controller,
+  Post,
+  UploadedFile,
+  UseInterceptors,
+} from '@nestjs/common';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { MasterService } from '../service/master.service';
+import { Express } from 'express';
+
+@Controller('master')
+export class MasterController {
+  constructor(private readonly masterService: MasterService) {}
+
+  @Post('upload')
+  @UseInterceptors(FileInterceptor('file'))
+  async uploadFile(@UploadedFile() file) {
+    if (!file) {
+      throw new Error('File is required');
+    }
+    return this.masterService.processExcel(file);
+  }
+
+  
+}

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

@@ -1,27 +1,148 @@
 import { Injectable } from '@nestjs/common';
-import { ExcelUtil } from '../../../utils/service/excelUtil.service';
 import { EntityManager } from 'typeorm';
+import { ExcelUtil } from 'src/utils/service/excelUtil.service';
+import { EntityMasterService } from '../../meta/service/entity-master.service';
+
+interface ParentEntity {
+  id: number;
+  code: string; 
+}
 
 @Injectable()
 export class MasterService {
   constructor(
     private readonly entityManager: EntityManager,
-    private ExcelUtil: ExcelUtil,
+    private readonly entityMasterService: EntityMasterService,
+    private readonly excelUtil: ExcelUtil,
   ) {}
 
-  async processExcel(file): Promise<any> {
-    const data = ExcelUtil.readExcel(file.buffer);
+  private readonly metaSheets = [
+    'entity_master',
+    'attribute_master',
+    'list_master',
+    'list_master_items',
+  ];
+
+  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);
+      }
+    }
+
+    return { message: '✅ Data processed successfully' };
+  }
+
+  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);
+        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'];
+      }
+
+      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,
+    };
+  }
+
+  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;
+  }
 
-    for (const [tableName, records] of Object.entries(data)) {
-      await this.upsertData(tableName, records);
+  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;
     }
 
-    return { message: 'Data processed successfully' };
+    await this.entityManager
+      .createQueryBuilder()
+      .insert()
+      .into(tableName)
+      .values(data)
+      .orUpdate({
+        overwrite: keys,
+        conflict_target: ['code'],
+      })
+      .execute();
   }
 
-  private async upsertData(tableName: string, records: any[]): Promise<void> {
+  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
@@ -29,7 +150,10 @@ export class MasterService {
           .insert()
           .into(tableName)
           .values(record)
-          .orUpdate(Object.keys(record), ['id']) // Using 'id' as unique identifier
+          .orUpdate({
+            overwrite: keys,
+            conflict_target: ['id'],
+          })
           .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

@@ -1,67 +1,67 @@
-import { BaseEntity } from './base-entity.entity';
-import { Column, Entity } from 'typeorm';
-
-@Entity({ name: 'cr_attribute_master' })
-export class AttributeMaster extends BaseEntity {
-  @Column({ name: 'mapped_entity_type', type: 'varchar', nullable: true })
-  mapped_entity_type: string;
-
-  @Column({ name: 'mapped_entity_id' })
-  mapped_entity_id: number;
-
-  @Column({ name: 'element_type', type: 'varchar', nullable: true, length: 50 })
-  element_type: string;
-
-  @Column({
-    name: 'data_source_type',
-    type: 'varchar',
-    nullable: true,
-    length: 50,
-  })
-  data_source_type: string;
-
-  @Column({ name: 'datasource_list', type: 'varchar', nullable: true })
-  datasource_list: string;
-
-  @Column({
-    name: 'custom_values',
-    type: 'varchar',
-    length: 2000,
-    nullable: true,
-  })
-  custom_values: string;
-
-  @Column({ name: 'max_length', nullable: true })
-  max_length: number;
-
-  @Column({ name: 'required', nullable: true })
-  required: number;
-
-  @Column({
-    name: 'description',
-    type: 'varchar',
-    length: 2000,
-    nullable: true,
-  })
-  description: string;
-
-  @Column({
-    name: 'attribute_key',
-    type: 'varchar',
-    nullable: true,
-    length: 50,
-  })
-  attribute_key: string;
-
-  @Column({ name: 'db_datatype', type: 'varchar', nullable: true, length: 50 })
-  db_datatype: string;
-
-  @Column({ name: 'category', type: 'varchar', nullable: true, length: 50 })
-  category: string;
-
-  @Column({ name: 'is_unique', nullable: true })
-  is_unique: number;
-
-  @Column({ name: 'can_export', nullable: true })
-  can_export: number;
-}
+import { BaseEntity } from './base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_attribute_master' })
+export class AttributeMaster extends BaseEntity {
+  @Column({ name: 'mapped_entity_type', type: 'varchar', nullable: true })
+  mapped_entity_type: string;
+
+  @Column({ name: 'mapped_entity_id' })
+  mapped_entity_id: number;
+
+  @Column({ name: 'element_type', type: 'varchar', nullable: true, length: 50 })
+  element_type: string;
+
+  @Column({
+    name: 'data_source_type',
+    type: 'varchar',
+    nullable: true,
+    length: 50,
+  })
+  data_source_type: string;
+
+  @Column({ name: 'datasource_list', type: 'varchar', nullable: true })
+  datasource_list: string;
+
+  @Column({
+    name: 'custom_values',
+    type: 'varchar',
+    length: 2000,
+    nullable: true,
+  })
+  custom_values: string;
+
+  @Column({ name: 'max_length', nullable: true })
+  max_length: number;
+
+  @Column({ name: 'required', nullable: true })
+  required: number;
+
+  @Column({
+    name: 'description',
+    type: 'varchar',
+    length: 2000,
+    nullable: true,
+  })
+  description: string;
+
+  @Column({
+    name: 'attribute_key',
+    type: 'varchar',
+    nullable: true,
+    length: 50,
+  })
+  attribute_key: string;
+
+  @Column({ name: 'db_datatype', type: 'varchar', nullable: true, length: 50 })
+  db_datatype: string;
+
+  @Column({ name: 'category', type: 'varchar', nullable: true, length: 50 })
+  category: string;
+
+  @Column({ name: 'is_unique', nullable: true })
+  is_unique: number;
+
+  @Column({ name: 'can_export', nullable: true })
+  can_export: number;
+}

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

@@ -48,7 +48,7 @@ export class EntityMaster extends BaseEntity {
     length: 200,
     nullable: true,
   })
-  dbTableName: string;
+  db_table_name: string;
 
   @Column({
     name: 'description',

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