rez_core 1.0.42 → 1.0.44

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

@@ -0,0 +1,32 @@
+import { BaseEntity } from './base-entity.entity';
+import { Column, Entity } from 'typeorm';
+import { ENTITYTYPE_VIEWMASTER } from '../../../constant/global.constant';
+
+@Entity({ name: 'cr_view_master' })
+export class ViewMaster extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ENTITYTYPE_VIEWMASTER;
+  }
+
+  @Column({ length: 50, nullable: true })
+  mapped_entity_type: string;
+
+  @Column({type: 'varchar', nullable: true})
+  section_layout: string;
+
+  @Column({nullable: true})
+  section_information: string;
+
+  @Column({nullable: true})
+  description: string;
+
+  @Column({type: 'json', nullable: true})
+  published_form_layout: string;
+
+  @Column({type: 'json', nullable: true})
+  published_form_fields: string;
+
+  @Column({type: 'int'})
+  is_default: number;
+}

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/view-master.service.ts

@@ -0,0 +1,41 @@
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from './entity-service-impl.service';
+import { BaseEntity } from '../entity/base-entity.entity';
+import { UserData } from '../../user/entity/user.entity';
+import { EntityManager } from 'typeorm';
+import { ViewMaster } from '../entity/view-master.entity';
+
+@Injectable()
+export class ViewMasterService extends EntityServiceImpl {
+  constructor() {
+    super();
+  }
+
+  async createEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData | null,
+    manager?: EntityManager,
+  ): Promise<BaseEntity> {
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityData.entity_type,
+    );
+    entityData.parent_id = entityMaster.id;
+    entityData.parent_type = entityMaster.entity_type;
+
+    const savedEntity = await super.createEntity(
+      entityData,
+      loggedInUser,
+      manager,
+    );
+    return savedEntity;
+  }
+
+  async updateEntity(
+    entityData: ViewMaster,
+    loggedInUserData: UserData | null,
+  ): Promise<BaseEntity> {
+
+    return entityData;
+  }
+
+}

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/controller/module-access.controller.ts

@@ -1,4 +1,4 @@
-import { Body, Controller, Get, Post, Query, UseGuards } from '@nestjs/common';
+import { Body, Controller, Get, Param, Post, Query, UseGuards } from '@nestjs/common';
 import { ModuleAccessService } from '../service/module-access.service';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
 
@@ -7,7 +7,6 @@ import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
 export class ModuleAccessController {
   constructor(private readonly moduleAccessService: ModuleAccessService) {}
 
-
   @Get('roles')
   async getRoles() {
     return this.moduleAccessService.getRoles();
@@ -36,14 +35,31 @@ export class ModuleAccessController {
   }
 
   @Post('create-role')
-async createRole(@Body() body: {
-  name: string;
-  description?: string;
-  status?: 'ACTIVE' | 'INACTIVE';
-  copyFromRoleId?: number;
-}) {
-  return this.moduleAccessService.createRole(body);
-}
+  async createRole(
+    @Body()
+    body: {
+      name: string;
+      description?: string;
+      status?: 'ACTIVE' | 'INACTIVE';
+      copyFromRoleId?: number;
+    },
+  ) {
+    return this.moduleAccessService.createRole(body);
+  }
 
+  @Post('update-role/:id')
+  async updateRole(
+    @Param('id') id: number,
+    @Body()
+    body: {
+      name?: string;
+      description?: string;
+      status?: 'ACTIVE' | 'INACTIVE';
+      copyFromRoleId?: number; // <-- ADD THIS
+    },
+  ) {
+    return this.moduleAccessService.updateRole(id, body);
+  }
+  
 
 }