rez_core 1.0.58 → 1.0.60

package/package.json

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

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

@@ -1,4 +1,4 @@
-import { Body, Controller, HttpCode, HttpStatus, Param, Post } from '@nestjs/common';
+import { Body, Controller, HttpCode, HttpStatus, Param, Post, Query } from '@nestjs/common';
 import { ListMasterService } from '../service/list-master.service';
 
 @Controller('list-master')
@@ -7,7 +7,7 @@ export class ListMasterController {
 
   @Post('/getDropdownData/:type')
   @HttpCode(HttpStatus.OK)
-  async getDropdownData(@Param('type') type: string, @Body() params) {
-    return await this.service.getDropdownOptions(type, params);
+  async getDropdownData(@Param('type') type: string, @Body() params,@Query() query: Record<string, string>,) {
+    return await this.service.getDropdownOptions(type, params,query);
   }
 }

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

@@ -21,14 +21,14 @@ export class ListMasterService extends EntityServiceImpl {
     super();
   }
 
-  async getDropdownOptions(type: string, params: Record<string, string>) {
+  async getDropdownOptions(type: string, params: Record<string, string>,option) {
     const config = await this.listMasterRepo.findByType(type);
 
     if (!config) throw new NotFoundException(`Type ${type} not found`);
 
     switch (config.source) {
       case 'entity':
-        return this.fetchFromEntity(type);
+        return this.fetchFromEntity(type,option);
 
       case 'master':
         return this.listItemsRepo.findItemsByType(type);
@@ -41,15 +41,18 @@ export class ListMasterService extends EntityServiceImpl {
     }
   }
 
-  private async fetchFromEntity(sourceList: string) {
+  private async fetchFromEntity(sourceList: string,option) {
     let result: { label: string; value: number }[] = [];
     if (sourceList) {
       const entityMaster =
         await this.entityMasterService.getEntityData(sourceList);
 
-      let baseEntities = await super.getEntityList(
-        entityMaster.mapped_entity_type,
-      );
+        const filters: any = {};
+        if (option?.onlyActive === 'true') {
+          filters.status = 'ACTIVE';
+        }
+    
+        const baseEntities = await super.getEntityList(entityMaster.mapped_entity_type,filters);
       baseEntities.forEach((entity) => {
         result.push({
           label: entity.name,

package/src/module/meta/service/entity-service-impl.service.ts

@@ -62,10 +62,13 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
     entityData.created_date = new Date();
     if (loggedInUser) {
       entityData.created_by = loggedInUser.id;
+      if (!entityData.organization_id)
+        entityData.organization_id = loggedInUser.organization_id;
+      if (!entityData.enterprise_id)
+        entityData.enterprise_id = loggedInUser.enterprise_id;
     }
 
-    const savedEntity = repo.save(entityData);
-    return savedEntity;
+    return repo.save(entityData);
   }
 
   deleteEntity(
@@ -110,24 +113,24 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
     return await repoService.findOne({ where: { id: id } });
   }
 
-  async getEntityList(entityType: string): Promise<BaseEntity[]> {
+  async getEntityList(entityType: string, filters: Record<string, any> = {}): Promise<BaseEntity[]> {
     const entityData = await this.entityMasterService.getEntityData(entityType);
-    const repoService = this.reflectionHelper.getRepoService(
-      entityData.entity_data_class,
-    );
+    const repoService = this.reflectionHelper.getRepoService(entityData.entity_data_class);
+  
     if (!repoService) {
-      throw new Error(
-        `Repository service not found for entityType: ${entityType}`,
-      );
+      throw new Error(`Repository service not found for entityType: ${entityType}`);
     }
-
-    const result = await repoService.find();
+  
+    const result = await repoService.find({
+      where: filters,
+    });
+  
     return result;
   }
 
   async updateEntity(
     entityData: BaseEntity,
-    loggedInUserData: UserData | null,
+    loggedInUser: UserData | null,
   ): Promise<BaseEntity> {
     const entityMaster = await this.entityMasterService.getEntityData(
       entityData.entity_type,
@@ -143,8 +146,12 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
     }
 
     entityData.modified_date = new Date();
-    if (loggedInUserData) {
-      entityData.modified_by = loggedInUserData.id;
+    if (loggedInUser) {
+      entityData.modified_by = loggedInUser.id;
+      if (!entityData.organization_id)
+        entityData.organization_id = loggedInUser.organization_id;
+      if (!entityData.enterprise_id)
+        entityData.enterprise_id = loggedInUser.enterprise_id;
     }
     await repoService.update(entityData.id, entityData);
     return await repoService.findOne({ where: { id: entityData.id } });

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

@@ -1,19 +1,17 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { Column, Entity, PrimaryGeneratedColumn, Unique } from 'typeorm';
 
-@Entity({ name: 'module_action' })
+@Entity({ name: 'cr_module_action' })  // <- new table name
+@Unique(['module_code', 'action_type'])  // enforce uniqueness per module + action
 export class ModuleAction {
   @PrimaryGeneratedColumn()
   id: number;
 
-  @Column({type: 'int', nullable: true})
-  module_id: number;
-  
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @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 })
+  @Column({ type: 'varchar', length: 100, nullable: true })
+  action_name: string;
+
+  @Column({ type: 'varchar', length: 50, nullable: true })
   action_type: string;
 }

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

@@ -2,7 +2,6 @@ import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { ModuleData } from './entity/module.entity';
 import { UtilsModule } from '../../utils/utils.module';
-import { ModuleAccess } from './entity/module-access.entity';
 import { ModuleAction } from './entity/module-action.entity';
 import { ModuleAccessService } from './service/module-access.service';
 import { MenuController } from './controller/menu.controller';
@@ -14,6 +13,7 @@ import { ModuleAccessController } from './controller/module-access.controller';
 import { UserRoleMapping } from '../user/entity/user-role-mapping.entity';
 import { UserModule } from '../user/user.module';
 import { Role } from '../user/entity/role.entity';
+import { ModuleAccess } from './entity/module-access.entity';
 
 @Module({
   imports: [

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

@@ -24,41 +24,34 @@ export class ModuleAccessRepository {
 
   async getRoles() {
     const roles = await this.roleRepo.find();
-    return roles.map((role) => ({
+    return roles.map(role => ({
       label: role.name,
       value: role.id,
     }));
   }
 
   async getModules() {
-    const modules = await this.moduleRepo.find({
-      where: { module_level: 'MAINMOD' },
-    });
-    return modules.map((mod) => ({
+    const modules = await this.moduleRepo.find({ where: { module_level: 'MAINMOD' } });
+    return modules.map(mod => ({
       label: mod.name,
       value: mod.id,
     }));
   }
 
   async getAccessListing(roleIds: number[]) {
-    // Fetch roles using role IDs
     const roles = await this.roleRepo.find({ where: { id: In(roleIds) } });
+    const roleCodes = roles.map(role => role.code);
 
-    // Extract role codes from roles
-    const roleCodes = roles.map((role) => role.code);
-
-    // Fetch module access using role codes
     const moduleAccesses = await this.moduleAccessRepo.find({
       where: { role_code: In(roleCodes) },
     });
 
-    // Map role data to include access permissions
-    return roles.map((role) => ({
+    return roles.map(role => ({
       role_code: role.code,
       name: role.name,
       permission: moduleAccesses
-        .filter((access) => access.role_code === role.code)
-        .map((access) => ({
+        .filter(access => access.role_code === role.code)
+        .map(access => ({
           action: access.action_type,
           access: access.access_flag,
           code: access.module_code,
@@ -67,62 +60,48 @@ export class ModuleAccessRepository {
   }
 
   async getMenuListing(mainModIds: string[]) {
-    let mainModules: ModuleData[] = [];
-
-    if (mainModIds.length === 1 && mainModIds[0] === '-1') {
-      // Fetch ALL MAINMOD modules if "-1" is passed
-      mainModules = await this.moduleRepo.find({
-        where: { module_level: 'MAINMOD' },
-      });
-    } else {
-      // Fetch selected MAINMOD modules
-      mainModules = await this.moduleRepo.find({
-        where: { id: In(mainModIds), module_level: 'MAINMOD' },
-      });
-    }
+    const mainModules = mainModIds.length === 1 && mainModIds[0] === '-1'
+      ? await this.moduleRepo.find({ where: { module_level: 'MAINMOD' } })
+      : await this.moduleRepo.find({ where: { id: In(mainModIds), module_level: 'MAINMOD' } });
 
     if (!mainModules.length) return [];
 
-    const wbsCodes = mainModules.map((mod) => mod.wbs_code);
+    const wbsCodes = mainModules.map(mod => mod.wbs_code);
 
     const modules = await this.moduleRepo
       .createQueryBuilder('module')
       .where(
-        wbsCodes
-          .map((code) => `module.wbs_code LIKE :code${code}`)
-          .join(' OR '),
-        Object.fromEntries(wbsCodes.map((code) => [`code${code}`, `${code}%`])),
+        wbsCodes.map(code => `module.wbs_code LIKE :code${code}`).join(' OR '),
+        Object.fromEntries(wbsCodes.map(code => [`code${code}`, `${code}%`])),
       )
       .getMany();
 
     const moduleActions = await this.moduleActionRepo.find();
 
-    const buildHierarchy = (parentWbs: string) => {
-      return modules
-        .filter(
-          (mod) =>
-            mod.wbs_code.startsWith(parentWbs + '.') &&
-            mod.wbs_code.split('.').length === parentWbs.split('.').length + 1,
+    const buildHierarchy = (parentWbs: string): any[] =>
+      modules
+        .filter(mod =>
+          mod.wbs_code.startsWith(`${parentWbs}.`) &&
+          mod.wbs_code.split('.').length === parentWbs.split('.').length + 1,
         )
-        .map((mod) => ({
+        .map(mod => ({
           name: mod.name,
           code: mod.module_code,
           permission: moduleActions
-            .filter((action) => action.module_code === mod.module_code)
-            .map((action) => ({
+            .filter(action => action.module_code === mod.module_code)
+            .map(action => ({
               action: action.action_type,
               name: action.action_type,
             })),
           submod: buildHierarchy(mod.wbs_code),
         }));
-    };
 
-    return mainModules.map((mod) => ({
+    return mainModules.map(mod => ({
       name: mod.name,
       code: mod.module_code,
       permission: moduleActions
-        .filter((action) => action.module_code === mod.module_code)
-        .map((action) => ({
+        .filter(action => action.module_code === mod.module_code)
+        .map(action => ({
           action: action.action_type,
           name: action.action_type,
         })),
@@ -130,27 +109,29 @@ export class ModuleAccessRepository {
     }));
   }
 
-  async updateModuleAccess(moduleAccessData: any[]): Promise<boolean> {
+  async updateModuleAccess(accessList: {
+    role_code: string;
+    module_code: string;
+    action_type: string;
+    access_flag: number;
+    app_code: string;
+  }[]): Promise<boolean> {
     try {
-      for (const access of moduleAccessData) {
-        const { role_code, module_code, action_type, access_flag, app_code } =
-          access;
-
-        const existingEntry = await this.moduleAccessRepo.findOne({
-          where: { role_code, module_code, action_type, app_code },
+      for (const access of accessList) {
+        const existing = await this.moduleAccessRepo.findOne({
+          where: {
+            role_code: access.role_code,
+            module_code: access.module_code,
+            action_type: access.action_type,
+            app_code: access.app_code,
+          },
         });
 
-        if (existingEntry) {
-          existingEntry.access_flag = access_flag;
-          await this.moduleAccessRepo.save(existingEntry);
+        if (existing) {
+          existing.access_flag = access.access_flag;
+          await this.moduleAccessRepo.save(existing);
         } else {
-          await this.moduleAccessRepo.save({
-            role_code,
-            module_code,
-            action_type,
-            access_flag,
-            app_code,
-          });
+          await this.moduleAccessRepo.save(this.moduleAccessRepo.create(access));
         }
       }
       return true;
@@ -161,7 +142,12 @@ export class ModuleAccessRepository {
   }
 
   async createRole(
-    body: {
+    {
+      name,
+      description,
+      status = 'ACTIVE',
+      copyFromRoleId,
+    }: {
       name: string;
       description?: string;
       status?: 'ACTIVE' | 'INACTIVE';
@@ -169,59 +155,45 @@ export class ModuleAccessRepository {
     },
     loggedInUser: UserData,
   ) {
-    const { name, description, status, copyFromRoleId } = body;
-
-    const nameExists = await this.isRoleNameExists(name);
-    if (nameExists) {
+    if (await this.isRoleNameExists(name)) {
       throw new BadRequestException('Role name already exists.');
     }
-    if(copyFromRoleId){
-      const sourceRole = await this.roleRepo.findOne({
-        where: { id: copyFromRoleId },
-      });
-      if (!sourceRole) {
-        throw new BadRequestException('Source role not found');
-      }
+
+    const sourceRole = copyFromRoleId
+      ? await this.roleRepo.findOne({ where: { id: copyFromRoleId } })
+      : null;
+
+    if (copyFromRoleId && !sourceRole) {
+      throw new BadRequestException('Source role not found.');
     }
 
-    // 1. Create the role without the code (code will be updated after ID is generated)
     const newRole = this.roleRepo.create({
       name,
       description,
-      status: status || 'ACTIVE',
+      status,
       created_by: loggedInUser.id,
       created_date: new Date(),
     });
 
-    // 2. Save the role to get the generated ID
-    const savedRole = await this.roleRepo.save(newRole); // ID is now available
-
-    // 3. Generate the code using the saved ID
-    const generatedCode = `ROL${savedRole.id}`;
+    const savedRole = await this.roleRepo.save(newRole);
+    savedRole.code = `ROL${savedRole.id}`;
+    await this.roleRepo.save(savedRole);
 
-    // 4. Update the role with the generated code
-    savedRole.code = generatedCode;
-    await this.roleRepo.save(savedRole); // Update only the code
-
-    if (copyFromRoleId) {
-      const sourceRole = await this.roleRepo.findOne({
-        where: { id: copyFromRoleId },
-      });
-      if (!sourceRole) {
-        throw new BadRequestException('Source role not found');
-      }
+    if (sourceRole) {
       const sourcePermissions = await this.moduleAccessRepo.find({
         where: { role_code: sourceRole.code },
       });
-      const clonedPermissions = sourcePermissions.map((perm) =>
+
+      const clonedPermissions = sourcePermissions.map(perm =>
         this.moduleAccessRepo.create({
-          role_code: generatedCode,
+          role_code: savedRole.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);
     }
 
@@ -239,7 +211,12 @@ export class ModuleAccessRepository {
 
   async updateRole(
     roleId: number,
-    body: {
+    {
+      name,
+      description,
+      status = 'ACTIVE',
+      copyFromRoleId,
+    }: {
       name: string;
       description?: string;
       status?: 'ACTIVE' | 'INACTIVE';
@@ -247,39 +224,38 @@ export class ModuleAccessRepository {
     },
     loggedInUser: UserData,
   ) {
-    const { name, description, status, copyFromRoleId } = body;
-
-    const nameExists = await this.isRoleNameExists(name, roleId);
-    if (nameExists) {
+    if (await this.isRoleNameExists(name, roleId)) {
       throw new BadRequestException('Role name already exists.');
     }
 
     const role = await this.roleRepo.findOne({ where: { id: roleId } });
     if (!role) {
-      throw new BadRequestException('Source role not found');
+      throw new BadRequestException('Role not found');
     }
 
-    role.name = name;
-    role.description = description || '';
-    role.status = status || 'ACTIVE';
-    role.modified_date = new Date();
-    role.modified_by = loggedInUser.id;
+    Object.assign(role, {
+      name,
+      description: description || '',
+      status,
+      modified_by: loggedInUser.id,
+      modified_date: new Date(),
+    });
+
     await this.roleRepo.save(role);
 
     if (copyFromRoleId) {
-      await this.moduleAccessRepo.delete({ role_code: role.code });
-
-      const sourceRole = await this.roleRepo.findOne({
-        where: { id: copyFromRoleId },
-      });
+      const sourceRole = await this.roleRepo.findOne({ where: { id: copyFromRoleId } });
       if (!sourceRole) {
         throw new BadRequestException('Source role not found');
       }
 
+      await this.moduleAccessRepo.delete({ role_code: role.code });
+
       const sourcePermissions = await this.moduleAccessRepo.find({
         where: { role_code: sourceRole.code },
       });
-      const clonedPermissions = sourcePermissions.map((perm) =>
+
+      const clonedPermissions = sourcePermissions.map(perm =>
         this.moduleAccessRepo.create({
           role_code: role.code,
           module_code: perm.module_code,
@@ -288,6 +264,7 @@ export class ModuleAccessRepository {
           app_code: perm.app_code,
         }),
       );
+
       await this.moduleAccessRepo.save(clonedPermissions);
     }
 
@@ -303,10 +280,7 @@ export class ModuleAccessRepository {
     };
   }
 
-  async isRoleNameExists(
-    name: string,
-    excludeRoleId?: number,
-  ): Promise<boolean> {
+  private async isRoleNameExists(name: string, excludeRoleId?: number): Promise<boolean> {
     const query = this.roleRepo
       .createQueryBuilder('role')
       .where('role.name = :name', { name });

package/dist/resources/dev.properties.yaml

@@ -1,21 +0,0 @@
-DB_HOST: "13.234.25.234"
-DB_PORT: "3306"
-DB_USER: "root"
-DB_PASS: "Rezolut@123"
-DB_NAME: "core"
-MASTER_KEY: "0QZ2eRJv5oVILYnyBlC+FbSGVQiWKReh"
-MASTER_IV: "heuUQf5uPVtkotrFAOKUVw=="
-SECRET_KEY: "1hard_to_guess_secret7890a"
-CLIENT_ID: "324529881356-596sc8ksrb9lg01i7sktofqqqf0fv2ug.apps.googleusercontent.com"
-CLIENT_SECRET: "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"
-CALLBACK_URL: "http://localhost:3000/auth/google/callback"
-OTP_EXPIRY: "10"
-OTP_LENGTH: "6"
-VERIFY_OTP: "false"
-DEFAULT_OTP: "123456"
-AWS:
-  S3:
-    AWS_ACCESS_KEY_ID: "AKIAYYKIBDDSQF3KILGE"
-    AWS_SECRET_KEY: "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"
-    AWS_REGION: "ap-south-1"
-    BUCKET_NAME: "testether"

package/dist/resources/uat.properties.yaml

@@ -1,15 +0,0 @@
-DB_HOST: "13.234.25.234"
-DB_PORT: "3306"
-DB_USER: "root"
-DB_PASS: "Rezolut@123"
-DB_NAME: "ether_core"
-MASTER_KEY: "0QZ2eRJv5oVILYnyBlC+FbSGVQiWKReh"
-MASTER_IV: "heuUQf5uPVtkotrFAOKUVw=="
-SECRET_KEY: "1hard_to_guess_secret7890a"
-CLIENT_ID: "324529881356-596sc8ksrb9lg01i7sktofqqqf0fv2ug.apps.googleusercontent.com"
-CLIENT_SECRET: "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"
-CALLBACK_URL: "http://localhost:3000/auth/google/callback"
-OTP_EXPIRY: "10"
-OTP_LENGTH: "6"
-VERIFY_OTP: "false"
-DEFAULT_OTP: "123456"