rez_core 1.0.60 → 1.0.61

package/package.json

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

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

@@ -8,9 +8,7 @@ import { UserData } from '../../user/entity/user.entity';
 @Controller('module-access')
 @UseGuards(JwtAuthGuard)
 export class ModuleAccessController {
-  constructor(private readonly moduleAccessService: ModuleAccessService,
-              @Inject('UserService') private readonly userService: UserService,
-              ) {}
+  constructor(private readonly moduleAccessService: ModuleAccessService) {}
 
   @Get('roles')
   async getRoles() {
@@ -39,39 +37,7 @@ export class ModuleAccessController {
     return this.moduleAccessService.updateModuleAccess(moduleAccessData);
   }
 
-  @Post('create-role')
-  async createRole(
-    @Body()
-    body: {
-      name: string;
-      description?: string;
-      status?: 'ACTIVE' | 'INACTIVE';
-      copyFromRoleId?: number;
-    },
-    @Req() req: Request & {user: any}
-  ) {
-
-    let requestedUser = req.user;
-    let loggedInUser = await this.userService.getEntityData(ENTITYTYPE_USER,requestedUser.id);
-    return this.moduleAccessService.createRole(body, loggedInUser as UserData);
-  }
-
-  @Post('update-role/:id')
-  async updateRole(
-    @Param('id') id: number,
-    @Body()
-    body: {
-      name?: string;
-      description?: string;
-      status?: 'ACTIVE' | 'INACTIVE';
-      copyFromRoleId?: number; // <-- ADD THIS
-    },
-    @Req() req: Request & {user: any}
-  ) {
-    let requestedUser = req.user;
-    let loggedInUser = await this.userService.getEntityData(ENTITYTYPE_USER,requestedUser.id);
-    return this.moduleAccessService.updateRole(id, body, loggedInUser as UserData);
-  }
+  
   
 
 }

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

@@ -19,7 +19,6 @@ export class ModuleAccessRepository {
     private readonly moduleAccessRepo: Repository<ModuleAccess>,
     @InjectRepository(ModuleAction)
     private readonly moduleActionRepo: Repository<ModuleAction>,
-    private readonly clockIDGenService: ClockIDGenService,
   ) {}
 
   async getRoles() {
@@ -141,155 +140,5 @@ export class ModuleAccessRepository {
     }
   }
 
-  async createRole(
-    {
-      name,
-      description,
-      status = 'ACTIVE',
-      copyFromRoleId,
-    }: {
-      name: string;
-      description?: string;
-      status?: 'ACTIVE' | 'INACTIVE';
-      copyFromRoleId?: number;
-    },
-    loggedInUser: UserData,
-  ) {
-    if (await this.isRoleNameExists(name)) {
-      throw new BadRequestException('Role name already exists.');
-    }
-
-    const sourceRole = copyFromRoleId
-      ? await this.roleRepo.findOne({ where: { id: copyFromRoleId } })
-      : null;
-
-    if (copyFromRoleId && !sourceRole) {
-      throw new BadRequestException('Source role not found.');
-    }
-
-    const newRole = this.roleRepo.create({
-      name,
-      description,
-      status,
-      created_by: loggedInUser.id,
-      created_date: new Date(),
-    });
-
-    const savedRole = await this.roleRepo.save(newRole);
-    savedRole.code = `ROL${savedRole.id}`;
-    await this.roleRepo.save(savedRole);
-
-    if (sourceRole) {
-      const sourcePermissions = await this.moduleAccessRepo.find({
-        where: { role_code: sourceRole.code },
-      });
-
-      const clonedPermissions = sourcePermissions.map(perm =>
-        this.moduleAccessRepo.create({
-          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);
-    }
-
-    return {
-      success: true,
-      msg: 'Role created successfully',
-      role: {
-        id: savedRole.id,
-        name: savedRole.name,
-        status: savedRole.status,
-        code: savedRole.code,
-      },
-    };
-  }
-
-  async updateRole(
-    roleId: number,
-    {
-      name,
-      description,
-      status = 'ACTIVE',
-      copyFromRoleId,
-    }: {
-      name: string;
-      description?: string;
-      status?: 'ACTIVE' | 'INACTIVE';
-      copyFromRoleId?: number;
-    },
-    loggedInUser: UserData,
-  ) {
-    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('Role not found');
-    }
 
-    Object.assign(role, {
-      name,
-      description: description || '',
-      status,
-      modified_by: loggedInUser.id,
-      modified_date: new Date(),
-    });
-
-    await this.roleRepo.save(role);
-
-    if (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 =>
-        this.moduleAccessRepo.create({
-          role_code: role.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 updated successfully',
-      role: {
-        id: role.id,
-        name: role.name,
-        status: role.status,
-        code: role.code,
-      },
-    };
-  }
-
-  private async isRoleNameExists(name: string, excludeRoleId?: number): Promise<boolean> {
-    const query = this.roleRepo
-      .createQueryBuilder('role')
-      .where('role.name = :name', { name });
-
-    if (excludeRoleId) {
-      query.andWhere('role.id != :excludeRoleId', { excludeRoleId });
-    }
-
-    const existingRole = await query.getOne();
-    return !!existingRole;
-  }
 }

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

@@ -11,8 +11,6 @@ import { UserData } from 'src/module/user/entity/user.entity';
 export class ModuleAccessService {
   constructor(
     private readonly moduleAccessRepository: ModuleAccessRepository,
-    @Inject('RoleService') private readonly roleService: RoleService,
-    private readonly entityManager: EntityManager,
   ) {}
 
   async getRoles() {
@@ -48,64 +46,5 @@ export class ModuleAccessService {
     }
   }
 
-  async createRole(
-    body: {
-      name: string;
-      description?: string;
-      status?: 'ACTIVE' | 'INACTIVE';
-      copyFromRoleId?: number;
-    },
-    loggedInUser: UserData,
-  ) {
-    return this.moduleAccessRepository.createRole(body, loggedInUser);
-  }
-
-  async updateRole(
-    id: number,
-    body: {
-      name?: string;
-      description?: string;
-      status?: 'ACTIVE' | 'INACTIVE';
-      copyFromRoleId?: number;
-    },
-    loggedInUser: UserData,
-  ) {
-    if (!body.name) {
-      throw new BadRequestException('Role name is required');
-    }
-
-    if (body.status === 'INACTIVE') {
-      //get role by id
-      const entityData = await this.roleService.getEntityData(
-        ENTITYTYPE_ROLE,
-        id,
-      );
-
-      const associatedUsers = await this.entityManager.query(`SELECT 	map.* 
-      FROM 	cr_user_role_mapping map 
-		  JOIN cr_user usr ON map.user_id = usr.id
-      WHERE usr.status = 'ACTIVE' and map.role_id = ${entityData?.id}`);
-
-      if (associatedUsers.length > 0) {
-        throw new BadRequestException(
-          'Cannot deactivate role as it is associated with active users',
-        );
-      }
-
-      if (!entityData) {
-        throw new BadRequestException('Role not found');
-      }
-      const role = entityData as Role;
-      if (role.is_system === 1) {
-        throw new BadRequestException('Cannot deactivate system role');
-      }
-    }
-
-    return this.moduleAccessRepository.updateRole(id, {
-      name: body.name,
-      description: body.description,
-      status: body.status,
-      copyFromRoleId: body.copyFromRoleId,
-    }, loggedInUser);
-  }
+  
 }

package/src/module/user/controller/role.controller.ts

@@ -0,0 +1,55 @@
+import { Body, Controller, Inject, Param, Post, Req, UseGuards } from '@nestjs/common';
+import { UserService } from '../service/user.service';
+import { ENTITYTYPE_USER } from 'src/constant/global.constant';
+import { RoleService } from '../service/role.service';
+import { UserData } from '../entity/user.entity';
+import { request } from 'express';
+import { AuthGuard } from '@nestjs/passport';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+@Controller('role')
+@UseGuards(JwtAuthGuard)
+export class RoleController {
+  constructor(
+    @Inject('UserService') private readonly userService: UserService,
+    @Inject('RoleService') private readonly roleService: RoleService,
+  ) {}
+
+  @Post('create')
+  async createRole(
+    @Body()
+    body: {
+      name: string;
+      description?: string;
+      status?: 'ACTIVE' | 'INACTIVE';
+      copyFromRoleId?: number;
+    },
+    @Req() request: Request & { user: any },
+  ) {
+    let requestedUser = request.user;
+    let loggedInUser = await this.userService.getEntityData(
+      ENTITYTYPE_USER,
+      requestedUser.id,
+    );
+    return this.roleService.createRole(body, loggedInUser as UserData);
+  }
+
+  @Post('update/:id')
+  async updateRole(
+    @Param('id') id: number,
+    @Body()
+    body: {
+      name?: string;
+      description?: string;
+      status?: 'ACTIVE' | 'INACTIVE';
+      copyFromRoleId?: number; // <-- ADD THIS
+    },
+    @Req() req: Request & { user: any },
+  ) {
+    let requestedUser = req.user;
+    let loggedInUser = await this.userService.getEntityData(
+      ENTITYTYPE_USER,
+      requestedUser.id,
+    );
+    return this.roleService.updateRole(id, body, loggedInUser as UserData);
+  }
+}

package/src/module/user/repository/role.repository.ts

@@ -1,16 +1,172 @@
-import { Injectable } from '@nestjs/common';
+import { BadRequestException, Injectable } from '@nestjs/common';
 import { Repository } from 'typeorm';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Role } from '../entity/role.entity';
+import { ModuleAccess } from 'src/module/module/entity/module-access.entity';
+import { UserData } from '../entity/user.entity';
 
 @Injectable()
 export class RoleRepository {
   constructor(
     @InjectRepository(Role)
     private readonly roleRepo: Repository<Role>,
+    @InjectRepository(ModuleAccess)
+        private readonly moduleAccessRepo: Repository<ModuleAccess>
   ) {}
 
   async findByCode(code: string): Promise<Role | null> {
     return this.roleRepo.findOne({ where: { code } });
   }
+
+  async createRole(
+    {
+      name,
+      description,
+      status = 'ACTIVE',
+      copyFromRoleId,
+    }: {
+      name: string;
+      description?: string;
+      status?: 'ACTIVE' | 'INACTIVE';
+      copyFromRoleId?: number;
+    },
+    loggedInUser: UserData,
+  ) {
+    if (await this.isRoleNameExists(name)) {
+      throw new BadRequestException('Role name already exists.');
+    }
+
+    const sourceRole = copyFromRoleId
+      ? await this.roleRepo.findOne({ where: { id: copyFromRoleId } })
+      : null;
+
+    if (copyFromRoleId && !sourceRole) {
+      throw new BadRequestException('Source role not found.');
+    }
+
+    const newRole = this.roleRepo.create({
+      name,
+      description,
+      status,
+      created_by: loggedInUser.id,
+      created_date: new Date(),
+    });
+
+    const savedRole = await this.roleRepo.save(newRole);
+    savedRole.code = `ROL${savedRole.id}`;
+    await this.roleRepo.save(savedRole);
+
+    if (sourceRole) {
+      const sourcePermissions = await this.moduleAccessRepo.find({
+        where: { role_code: sourceRole.code },
+      });
+
+      const clonedPermissions = sourcePermissions.map(perm =>
+        this.moduleAccessRepo.create({
+          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);
+    }
+
+    return {
+      success: true,
+      msg: 'Role created successfully',
+      role: {
+        id: savedRole.id,
+        name: savedRole.name,
+        status: savedRole.status,
+        code: savedRole.code,
+      },
+    };
+  }
+
+  async updateRole(
+    roleId: number,
+    {
+      name,
+      description,
+      status = 'ACTIVE',
+      copyFromRoleId,
+    }: {
+      name: string;
+      description?: string;
+      status?: 'ACTIVE' | 'INACTIVE';
+      copyFromRoleId?: number;
+    },
+    loggedInUser: UserData,
+  ) {
+    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('Role not found');
+    }
+
+    Object.assign(role, {
+      name,
+      description: description || '',
+      status,
+      modified_by: loggedInUser.id,
+      modified_date: new Date(),
+    });
+
+    await this.roleRepo.save(role);
+
+    if (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 =>
+        this.moduleAccessRepo.create({
+          role_code: role.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 updated successfully',
+      role: {
+        id: role.id,
+        name: role.name,
+        status: role.status,
+        code: role.code,
+      },
+    };
+  }
+
+  private async isRoleNameExists(name: string, excludeRoleId?: number): Promise<boolean> {
+    const query = this.roleRepo
+      .createQueryBuilder('role')
+      .where('role.name = :name', { name });
+
+    if (excludeRoleId) {
+      query.andWhere('role.id != :excludeRoleId', { excludeRoleId });
+    }
+
+    const existingRole = await query.getOne();
+    return !!existingRole;
+  }
 }

package/src/module/user/service/role.service.ts

@@ -1,12 +1,19 @@
-import { Injectable } from '@nestjs/common';
+import { BadRequestException, Injectable } from '@nestjs/common';
 import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
 import { BaseEntity } from '../../meta/entity/base-entity.entity';
 import { UserData } from '../entity/user.entity';
 import { Role } from '../entity/role.entity';
+import { ENTITYTYPE_ROLE } from 'src/constant/global.constant';
+import { RoleRepository } from '../repository/role.repository';
+import { EntityManager } from 'typeorm';
 
 @Injectable()
 export class RoleService extends EntityServiceImpl {
-  constructor() {
+  constructor(
+    private readonly roleRepository: RoleRepository,
+    private readonly entityManager: EntityManager,
+    
+  ) {
     super();
   }
 
@@ -18,4 +25,65 @@ export class RoleService extends EntityServiceImpl {
 
     return await super.createEntity(role, loggedInUser);
   }
+
+  async createRole(
+    body: {
+      name: string;
+      description?: string;
+      status?: 'ACTIVE' | 'INACTIVE';
+      copyFromRoleId?: number;
+    },
+    loggedInUser: UserData,
+  ) {
+    return this.roleRepository.createRole(body, loggedInUser);
+  }
+
+  async updateRole(
+    id: number,
+    body: {
+      name?: string;
+      description?: string;
+      status?: 'ACTIVE' | 'INACTIVE';
+      copyFromRoleId?: number;
+    },
+    loggedInUser: UserData,
+  ) {
+    if (!body.name) {
+      throw new BadRequestException('Role name is required');
+    }
+
+    if (body.status === 'INACTIVE') {
+      //get role by id
+      const entityData = await super.getEntityData(
+        ENTITYTYPE_ROLE,
+        id,
+      );
+
+      const associatedUsers = await this.entityManager.query(`SELECT 	map.* 
+      FROM 	cr_user_role_mapping map 
+		  JOIN cr_user usr ON map.user_id = usr.id
+      WHERE usr.status = 'ACTIVE' and map.role_id = ${entityData?.id}`);
+
+      if (associatedUsers.length > 0) {
+        throw new BadRequestException(
+          'Cannot deactivate role as it is associated with active users',
+        );
+      }
+
+      if (!entityData) {
+        throw new BadRequestException('Role not found');
+      }
+      const role = entityData as Role;
+      if (role.is_system === 1) {
+        throw new BadRequestException('Cannot deactivate system role');
+      }
+    }
+
+    return this.roleRepository.updateRole(id, {
+      name: body.name,
+      description: body.description,
+      status: body.status,
+      copyFromRoleId: body.copyFromRoleId,
+    }, loggedInUser);
+  }
 }

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

@@ -19,10 +19,12 @@ import { UserRoleMapping } from './entity/user-role-mapping.entity';
 import { UserRoleMappingRepository } from './repository/user-role-mapping.repository';
 import { UserRoleMappingService } from './service/user-role-mapping.service';
 import { RoleRepository } from './repository/role.repository';
+import { ModuleAccess } from '../module/entity/module-access.entity';
+import { RoleController } from './controller/role.controller';
 
 @Module({
   imports: [
-    TypeOrmModule.forFeature([UserData, UserSession, Role, UserRoleMapping]),
+    TypeOrmModule.forFeature([UserData, UserSession, Role, UserRoleMapping,ModuleAccess]),
     EntityModule,
     UtilsModule,
     AuthModule,
@@ -47,6 +49,6 @@ import { RoleRepository } from './repository/role.repository';
     RoleRepository,
     LoginService,
   ],
-  controllers: [LoginController, UserController],
+  controllers: [LoginController, UserController,RoleController],
 })
 export class UserModule {}