rez_core 1.0.59 → 1.0.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "1.0.59",
+  "version": "1.0.61",
   "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/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;
+  }
 }