rez_core 1.0.40 → 1.0.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "1.0.40",
+  "version": "1.0.41",
   "description": "",
   "author": "",
   "private": false,

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

@@ -22,19 +22,5 @@ export class MasterController {
     return this.masterService.processExcel(file);
   }
 
-  @Post('uploadMasterData')
-  @UseInterceptors(FileInterceptor('file'))
-  async uploadMasterDataXls(@UploadedFile() file: Express.Multer.File) {
-    if (!file) {
-      throw new BadRequestException('File is required');
-    }
-    // const tempFilePath = join(__dirname, '../../uploads', `${Date.now()}_${file.originalname}`);
-    // await writeFile(tempFilePath, file.buffer);
-
-    try {
-      await this.masterService.uploadMasterData(file.buffer);
-    } finally {
-      // FileUtil.deleteFile(tempFilePath);
-    }
-  }
+  
 }

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

@@ -1,29 +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 readonly entityMasterService: EntityMasterService,
-    private ExcelUtil: ExcelUtil,
+    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'];
+      }
 
-    for (const [tableName, records] of Object.entries(data)) {
-      await this.upsertData(tableName, records);
+      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 { message: 'Data processed successfully' };
+    return {
+      tableName: result[0].db_table_name,
+      mappedEntityType: result[0].mapped_entity_type,
+    };
   }
 
-  private async upsertData(tableName: string, records: any[]): Promise<void> {
+  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
@@ -31,27 +150,12 @@ 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();
       }
     });
   }
-
-  async uploadMasterData(file) {
-    const data = ExcelUtil.readExcel(file.buffer);
-    await this.importEntityMasterData(data['cr_entity_master']);
-  }
-
-  private async importEntityMasterData(entityMasterList) {
-    for (let entityMaster of entityMasterList) {
-      let existingData = await this.entityMasterService.findByMappedEntityType(entityMaster.mapped_entity_type);
-
-      if (existingData) {
-        entityMaster.id = existingData.id;
-        await this.entityMasterService.update(existingData.id, entityMaster);
-      } else {
-        await this.entityMasterService.save(entityMaster);
-      }
-    }
-  }
 }

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

@@ -34,4 +34,16 @@ export class ModuleAccessController {
   async updateModuleAccess(@Body() moduleAccessData: any[]) {
     return this.moduleAccessService.updateModuleAccess(moduleAccessData);
   }
+
+  @Post('create-role')
+async createRole(@Body() body: {
+  name: string;
+  description?: string;
+  status?: 'ACTIVE' | 'INACTIVE';
+  copyFromRoleId?: number;
+}) {
+  return this.moduleAccessService.createRole(body);
+}
+
+
 }

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

@@ -5,6 +5,7 @@ import { Role } from 'src/module/user/entity/role.entity';
 import { ModuleAccess } from '../entity/module-access.entity';
 import { ModuleAction } from '../entity/module-action.entity';
 import { ModuleData } from '../entity/module.entity';
+import { ClockIDGenService } from 'src/utils/service/clockIDGenUtil.service';
 
 @Injectable()
 export class ModuleAccessRepository {
@@ -17,6 +18,8 @@ export class ModuleAccessRepository {
     private readonly moduleAccessRepo: Repository<ModuleAccess>,
     @InjectRepository(ModuleAction)
     private readonly moduleActionRepo: Repository<ModuleAction>,
+        private readonly clockIDGenService: ClockIDGenService,
+    
   ) {}
 
   async getRoles() {
@@ -91,10 +94,10 @@ export class ModuleAccessRepository {
     // Function to recursively build module hierarchy
     const buildHierarchy = (parentWbs: string) => {
       return modules
-        .filter(
-          (mod) =>
-            mod.wbs_code.startsWith(parentWbs) && mod.wbs_code !== parentWbs,
-        )
+      .filter(mod => {
+        return mod.wbs_code.startsWith(parentWbs + '.') &&
+               mod.wbs_code.split('.').length === parentWbs.split('.').length + 1;
+      })
         .map((mod) => ({
           name: mod.name,
           code: mod.module_code,
@@ -150,4 +153,59 @@ export class ModuleAccessRepository {
       return false;
     }
   }
+
+
+  async createRole(body: {
+    name: string;
+    description?: string;
+    status?: 'ACTIVE' | 'INACTIVE';
+    copyFromRoleId?: number;
+  }) {
+    const { name, description, status, copyFromRoleId } = body;
+  
+    const code =  this.clockIDGenService.idGenerator('ROL');; // Replace with your custom clock ID generator
+  
+    const newRole = this.roleRepo.create({
+      name,
+      code,
+      description,
+      status: status || 'ACTIVE',
+    });
+  
+    const savedRole = await this.roleRepo.save(newRole);
+  
+    if (copyFromRoleId) {
+      const sourceRole = await this.roleRepo.findOne({ where: { id: copyFromRoleId } });
+  
+      if (!sourceRole) {
+        throw new Error('Source role not found');
+      }
+  
+      const sourcePermissions = await this.moduleAccessRepo.find({
+        where: { role_code: sourceRole.code },
+      });
+  
+      const clonedPermissions = sourcePermissions.map((perm) =>
+        this.moduleAccessRepo.create({
+          role_code: code,
+          module_code: perm.module_code,
+          action_type: perm.action_type,
+          access_flag: perm.access_flag,
+          app_code: perm.app_code,
+        })
+      );
+  
+      await this.moduleAccessRepo.save(clonedPermissions);
+    }
+  
+    return {
+      success: true,
+      msg: 'Role created successfully',
+      role: {
+        id: savedRole.id,
+        name: savedRole.name,
+        code: savedRole.code,
+      },
+    };
+  }
 }

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

@@ -39,4 +39,14 @@ export class ModuleAccessService {
       return { success: false, msg: 'Failed to update module access' };
     }
   }
+
+  async createRole(body: {
+    name: string;
+    description?: string;
+    status?: 'ACTIVE' | 'INACTIVE';
+    copyFromRoleId?: number;
+  }) {
+    return this.moduleAccessRepository.createRole(body);
+  }
+  
 }