rez_core 1.0.57 → 1.0.59

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

@@ -1,22 +1,22 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
-
-@Entity({ name: 'cr_module_access' })
-export class ModuleAccess {
-  @PrimaryGeneratedColumn()
-  id: number;
-
-  @Column({type: 'varchar', length: 100, nullable: true})
-  module_code: string;
-
-  @Column({type: 'varchar', length: 100, nullable: true })
-  role_code: string;
-
-  @Column({type: 'int', nullable: true })
-  access_flag: number;
-
-  @Column({type: 'varchar', length: 100, nullable: true })
-  action_type: string;
-
-  @Column({type: 'varchar', length: 100, nullable: true})
-  app_code: string;
-}
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'cr_module_access' })
+export class ModuleAccess {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({type: 'varchar', length: 100, nullable: true})
+  module_code: string;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  role_code: string;
+
+  @Column({type: 'int', nullable: true })
+  access_flag: number;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  action_type: string;
+
+  @Column({type: 'varchar', length: 100, nullable: true})
+  app_code: string;
+}

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

@@ -1,19 +1,17 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
-
-@Entity({ name: 'module_action' })
-export class ModuleAction {
-  @PrimaryGeneratedColumn()
-  id: number;
-
-  @Column({type: 'int', nullable: true})
-  module_id: number;
-  
-  @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 })
-  action_type: string;
-}
+import { Column, Entity, PrimaryGeneratedColumn, Unique } from 'typeorm';
+
+@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: '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 })
+  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 });