rez_core 1.0.62 → 1.0.64

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

@@ -9,155 +9,15 @@ import { UserData } from '../entity/user.entity';
 export class RoleRepository {
   constructor(
     @InjectRepository(Role)
-    private readonly roleRepo: Repository<Role>,
-    @InjectRepository(ModuleAccess)
-        private readonly moduleAccessRepo: Repository<ModuleAccess>
+    private readonly roleRepo: Repository<Role>
   ) {}
 
   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> {
+  public async isRoleNameExists(name: string, excludeRoleId?: number): Promise<boolean> {
     const query = this.roleRepo
       .createQueryBuilder('role')
       .where('role.name = :name', { name });

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

@@ -1,33 +1,33 @@
-import { Repository } from 'typeorm';
-import { UserSession } from '../entity/user-session.entity';
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-
-@Injectable()
-export class UserSessionRepository {
-  constructor(
-    @InjectRepository(UserSession)
-    private userSessionRepo: Repository<UserSession>,
-  ) {}
-
-  async findBySessionKey(sessionKey: string): Promise<UserSession | null> {
-    return this.userSessionRepo.findOne({ where: { session_key: sessionKey } });
-  }
-
-  async findActiveSessionByUserId(userId: number): Promise<UserSession | null> {
-    return this.userSessionRepo.findOne({
-      where: { user_id: userId, is_session_loggedout: 0 },
-    });
-  }
-
-  async saveSession(session: UserSession): Promise<UserSession> {
-    return this.userSessionRepo.save(session);
-  }
-
-  async logoutSession(sessionKey: string): Promise<void> {
-    await this.userSessionRepo.update(
-      { session_key: sessionKey },
-      { is_session_loggedout: 1, logout_time: new Date() },
-    );
-  }
-}
+import { Repository } from 'typeorm';
+import { UserSession } from '../entity/user-session.entity';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+@Injectable()
+export class UserSessionRepository {
+  constructor(
+    @InjectRepository(UserSession)
+    private userSessionRepo: Repository<UserSession>,
+  ) {}
+
+  async findBySessionKey(sessionKey: string): Promise<UserSession | null> {
+    return this.userSessionRepo.findOne({ where: { session_key: sessionKey } });
+  }
+
+  async findActiveSessionByUserId(userId: number): Promise<UserSession | null> {
+    return this.userSessionRepo.findOne({
+      where: { user_id: userId, is_session_loggedout: 0 },
+    });
+  }
+
+  async saveSession(session: UserSession): Promise<UserSession> {
+    return this.userSessionRepo.save(session);
+  }
+
+  async logoutSession(sessionKey: string): Promise<void> {
+    await this.userSessionRepo.update(
+      { session_key: sessionKey },
+      { is_session_loggedout: 1, logout_time: new Date() },
+    );
+  }
+}

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

@@ -5,14 +5,18 @@ 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';
+import { EntityManager, Repository } from 'typeorm';
+import { InjectRepository } from '@nestjs/typeorm';
+import { ModuleAccess } from '../../module/entity/module-access.entity';
+import { instanceToPlain } from 'class-transformer';
 
 @Injectable()
 export class RoleService extends EntityServiceImpl {
   constructor(
     private readonly roleRepository: RoleRepository,
     private readonly entityManager: EntityManager,
-    
+    @InjectRepository(ModuleAccess)
+    private readonly moduleAccessRepo: Repository<ModuleAccess>,
   ) {
     super();
   }
@@ -23,46 +27,64 @@ export class RoleService extends EntityServiceImpl {
   ): Promise<BaseEntity> {
     let role = entityData as Role;
 
-    return await super.createEntity(role, loggedInUser);
-  }
+    if (await this.roleRepository.isRoleNameExists(role.name)) {
+      throw new BadRequestException('Role name already exists.');
+    }
 
-  async createRole(
-    body: {
-      name: string;
-      description?: string;
-      status?: 'ACTIVE' | 'INACTIVE';
-      copyFromRoleId?: number;
-    },
-    loggedInUser: UserData,
-  ) {
-    return this.roleRepository.createRole(body, loggedInUser);
+    const sourceRole = role.copy_from_role_id
+      ? await this.getEntityData(ENTITYTYPE_ROLE, role.copy_from_role_id)
+      : null;
+
+    if (role.copy_from_role_id && !sourceRole) {
+      throw new BadRequestException('Source role not found.');
+    }
+
+    const savedRole = await super.createEntity(role, loggedInUser);
+    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 savedRole;
   }
 
-  async updateRole(
-    id: number,
-    body: {
-      name?: string;
-      description?: string;
-      status?: 'ACTIVE' | 'INACTIVE';
-      copyFromRoleId?: number;
-    },
-    loggedInUser: UserData,
-  ) {
-    if (!body.name) {
+  async updateEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData | null,
+  ): Promise<BaseEntity> {
+    if (!entityData.name) {
       throw new BadRequestException('Role name is required');
     }
+    const role = entityData as Role;
 
-    if (body.status === 'INACTIVE') {
+    if (entityData.status === 'INACTIVE') {
       //get role by id
-      const entityData = await super.getEntityData(
+      const existingRole = await this.getEntityData(
         ENTITYTYPE_ROLE,
-        id,
+        entityData.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 (!existingRole) {
+        throw new BadRequestException('Role not found');
+      }
+
+      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 = ${existingRole?.id}`);
 
       if (associatedUsers.length > 0) {
         throw new BadRequestException(
@@ -70,20 +92,48 @@ export class RoleService extends EntityServiceImpl {
         );
       }
 
-      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);
+    if (
+      await this.roleRepository.isRoleNameExists(entityData.name, entityData.id)
+    ) {
+      throw new BadRequestException('Role name already exists.');
+    }
+
+  const {copy_from_role_id, ...persistableData} = role;
+  const updatedRole = await super.updateEntity(persistableData, loggedInUser);
+
+    if (role.copy_from_role_id) {
+      const sourceRole = await this.getEntityData(
+        ENTITYTYPE_ROLE,
+        role.copy_from_role_id,
+      );
+
+      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 updatedRole;
   }
 }

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

@@ -20,11 +20,16 @@ import { UserRoleMappingRepository } from './repository/user-role-mapping.reposi
 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,ModuleAccess]),
+    TypeOrmModule.forFeature([
+      UserData,
+      UserSession,
+      Role,
+      UserRoleMapping,
+      ModuleAccess,
+    ]),
     EntityModule,
     UtilsModule,
     AuthModule,
@@ -49,6 +54,6 @@ import { RoleController } from './controller/role.controller';
     RoleRepository,
     LoginService,
   ],
-  controllers: [LoginController, UserController,RoleController],
+  controllers: [LoginController, UserController],
 })
 export class UserModule {}

package/src/utils/service/encryptUtil.service.ts

@@ -1,97 +1,97 @@
-import { Injectable, InternalServerErrorException } from '@nestjs/common';
-import * as crypto from 'crypto';
-
-const CryptoJS = require('crypto-js');
-const encryptionType = 'aes-256-cbc';
-
-@Injectable()
-export class EncryptUtilService {
-  constructor() {}
-
-  static encryptGCM(data: any, Datakey: string, Dataiv: string) {
-    try {
-      const cipher = crypto.createCipheriv('aes-256-gcm', Datakey, Dataiv);
-      let encrypted = Buffer.concat([
-        cipher.update(data, 'utf8'),
-        cipher.final(),
-      ]);
-      const tag = cipher.getAuthTag();
-      return Buffer.concat([encrypted, tag]).toString('base64');
-    } catch (error) {
-      throw new InternalServerErrorException('Encryption process failed');
-    }
-  }
-
-  static decryptGCM(data: any, Datakey: any, Dataiv: any) {
-    try {
-      data = Buffer.from(data, 'base64');
-      const decipher = crypto.createDecipheriv('aes-256-gcm', Datakey, Dataiv);
-      const tag = data.slice(data.length - 16);
-      decipher.setAuthTag(tag);
-      data = data.slice(0, data.length - 16);
-      let decrypted = decipher.update(data, 'utf8') + decipher.final('utf8');
-      return decrypted;
-    } catch (error) {
-      throw new InternalServerErrorException('Encryption process failed');
-    }
-  }
-
-  static encryptCBC(data: any, Datakey: any, Dataiv: any) {
-    let encryptedRequest;
-    try {
-      let cipher = CryptoJS.AES.encrypt(data, Datakey, {
-        iv: Dataiv,
-        mode: CryptoJS.mode.CBC,
-      });
-      encryptedRequest = cipher.toString();
-    } catch (error) {
-      console.log(error);
-      throw new InternalServerErrorException('Encryption process failed');
-    }
-    return encryptedRequest;
-  }
-
-  static decryptCBC(data: any, Datakey: any, Dataiv: any) {
-    let decryptRequest;
-    try {
-      let cipher = CryptoJS.AES.decrypt(data, Datakey, {
-        iv: Dataiv,
-        mode: CryptoJS.mode.CBC,
-      });
-      decryptRequest = cipher.toString(CryptoJS.enc.Utf8);
-    } catch (error) {
-      throw new InternalServerErrorException('Encryption process failed');
-    }
-    return decryptRequest;
-  }
-
-  static encryptRequest(data: any, Datakey: any, Dataiv: any, type?: any) {
-    try {
-      switch (type) {
-        case 'GCM':
-          return this.encryptGCM(data, Datakey, Dataiv);
-        case 'CBC':
-          return this.encryptCBC(data, Datakey, Dataiv);
-        default:
-          return this.encryptCBC(data, Datakey, Dataiv);
-      }
-    } catch (error) {
-      throw new InternalServerErrorException('Encryption process failed');
-    }
-  }
-
-  static decryptRequest(data: any, Datakey: any, Dataiv: any, type?: any) {
-    try {
-      switch (type) {
-        case 'GCM':
-          return this.decryptGCM(data, Datakey, Dataiv);
-        case 'CBC':
-          return this.decryptCBC(data, Datakey, Dataiv);
-        default:
-          return this.decryptCBC(data, Datakey, Dataiv);
-      }
-    } catch (error) {
-      throw new InternalServerErrorException('Encryption process failed');
-    }
-  }
-}
+import { Injectable, InternalServerErrorException } from '@nestjs/common';
+import * as crypto from 'crypto';
+
+const CryptoJS = require('crypto-js');
+const encryptionType = 'aes-256-cbc';
+
+@Injectable()
+export class EncryptUtilService {
+  constructor() {}
+
+  static encryptGCM(data: any, Datakey: string, Dataiv: string) {
+    try {
+      const cipher = crypto.createCipheriv('aes-256-gcm', Datakey, Dataiv);
+      let encrypted = Buffer.concat([
+        cipher.update(data, 'utf8'),
+        cipher.final(),
+      ]);
+      const tag = cipher.getAuthTag();
+      return Buffer.concat([encrypted, tag]).toString('base64');
+    } catch (error) {
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+  }
+
+  static decryptGCM(data: any, Datakey: any, Dataiv: any) {
+    try {
+      data = Buffer.from(data, 'base64');
+      const decipher = crypto.createDecipheriv('aes-256-gcm', Datakey, Dataiv);
+      const tag = data.slice(data.length - 16);
+      decipher.setAuthTag(tag);
+      data = data.slice(0, data.length - 16);
+      let decrypted = decipher.update(data, 'utf8') + decipher.final('utf8');
+      return decrypted;
+    } catch (error) {
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+  }
+
+  static encryptCBC(data: any, Datakey: any, Dataiv: any) {
+    let encryptedRequest;
+    try {
+      let cipher = CryptoJS.AES.encrypt(data, Datakey, {
+        iv: Dataiv,
+        mode: CryptoJS.mode.CBC,
+      });
+      encryptedRequest = cipher.toString();
+    } catch (error) {
+      console.log(error);
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+    return encryptedRequest;
+  }
+
+  static decryptCBC(data: any, Datakey: any, Dataiv: any) {
+    let decryptRequest;
+    try {
+      let cipher = CryptoJS.AES.decrypt(data, Datakey, {
+        iv: Dataiv,
+        mode: CryptoJS.mode.CBC,
+      });
+      decryptRequest = cipher.toString(CryptoJS.enc.Utf8);
+    } catch (error) {
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+    return decryptRequest;
+  }
+
+  static encryptRequest(data: any, Datakey: any, Dataiv: any, type?: any) {
+    try {
+      switch (type) {
+        case 'GCM':
+          return this.encryptGCM(data, Datakey, Dataiv);
+        case 'CBC':
+          return this.encryptCBC(data, Datakey, Dataiv);
+        default:
+          return this.encryptCBC(data, Datakey, Dataiv);
+      }
+    } catch (error) {
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+  }
+
+  static decryptRequest(data: any, Datakey: any, Dataiv: any, type?: any) {
+    try {
+      switch (type) {
+        case 'GCM':
+          return this.decryptGCM(data, Datakey, Dataiv);
+        case 'CBC':
+          return this.decryptCBC(data, Datakey, Dataiv);
+        default:
+          return this.decryptCBC(data, Datakey, Dataiv);
+      }
+    } catch (error) {
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+  }
+}

package/src/utils/service/excelUtil.service.ts

@@ -1,15 +1,15 @@
-import * as xlsx from 'xlsx';
-
-export class ExcelUtil {
-  static readExcel(fileBuffer: Buffer): Record<string, any[]> {
-    const workbook = xlsx.read(fileBuffer, { type: 'buffer' });
-    const data: Record<string, any[]> = {};
-
-    workbook.SheetNames.forEach((sheetName) => {
-      const sheet = workbook.Sheets[sheetName];
-      data[sheetName] = xlsx.utils.sheet_to_json(sheet);
-    });
-
-    return data;
-  }
-}
+import * as xlsx from 'xlsx';
+
+export class ExcelUtil {
+  static readExcel(fileBuffer: Buffer): Record<string, any[]> {
+    const workbook = xlsx.read(fileBuffer, { type: 'buffer' });
+    const data: Record<string, any[]> = {};
+
+    workbook.SheetNames.forEach((sheetName) => {
+      const sheet = workbook.Sheets[sheetName];
+      data[sheetName] = xlsx.utils.sheet_to_json(sheet);
+    });
+
+    return data;
+  }
+}