rez_core 4.0.115 → 4.0.120

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

@@ -1,189 +1,189 @@
-import { BadRequestException, Inject, 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, STATUS_INACTIVE } from 'src/constant/global.constant';
-import { RoleRepository } from '../repository/role.repository';
-import { EntityManager, Repository } from 'typeorm';
-import { InjectRepository } from '@nestjs/typeorm';
-import { ModuleAccess } from '../../module/entity/module-access.entity';
-import { ServiceResult } from 'src/dtos/response';
-import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
-
-@Injectable()
-export class RoleService extends EntityServiceImpl {
-  constructor(
-    private readonly roleRepository: RoleRepository,
-    private readonly entityManager: EntityManager,
-    @InjectRepository(ModuleAccess)
-    private readonly moduleAccessRepo: Repository<ModuleAccess>,
-    @Inject('ListMasterService')
-    private readonly listMasterService: ListMasterService,
-  ) {
-    super();
-  }
-
-  async createEntity(
-    entityData: BaseEntity,
-    loggedInUser: UserData,
-  ): Promise<ServiceResult<BaseEntity>> {
-    const role = entityData as Role;
-
-    // if level_type and level_id are not provided, use loggedInUser's values
-    role.level_type = entityData.level_type || loggedInUser.level_type;
-    role.level_id = entityData.level_id || loggedInUser.level_id;
-    role.appcode = entityData.appcode || loggedInUser.appcode;
-
-    if (
-      await this.roleRepository.isRoleNameWithLevelExists(role.name, {
-        organization_id: loggedInUser?.organization_id || undefined,
-        level_type: entityData.level_type || loggedInUser?.level_type,
-        level_id:
-          parseInt(entityData.level_id) ||
-          parseInt(loggedInUser?.level_id || '', 10),
-      })
-    ) {
-      return { success: false, error: 'Role name already exists.' };
-    }
-
-    const sourceRole = role.copy_from_role_id
-      ? await this.getEntityData(
-          ENTITYTYPE_ROLE,
-          role.copy_from_role_id,
-          loggedInUser,
-        )
-      : null;
-
-    if (role.copy_from_role_id && !sourceRole) {
-      return { success: false, error: '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,
-          level_type: perm.level_type,
-          appcode: perm.appcode,
-        }),
-      );
-
-      await this.moduleAccessRepo.save(clonedPermissions);
-    }
-    return { success: true, data: savedRole };
-  }
-
-  async updateEntity(
-    entityData: BaseEntity,
-    loggedInUser: UserData,
-  ): Promise<ServiceResult<BaseEntity>> {
-    if (!entityData.name) {
-      return { success: false, error: 'Role name is required' };
-    }
-    const role = entityData as Role;
-
-    const resolveStatus = await this.listMasterService.getResolvedListCode(
-      STATUS_INACTIVE,
-      loggedInUser?.organization_id || 0,
-    );
-
-    if (entityData.status == resolveStatus.id) {
-      //get role by id
-      const existingRole = await this.getEntityData(
-        ENTITYTYPE_ROLE,
-        entityData.id,
-        loggedInUser,
-      );
-
-      if (!existingRole) {
-        return { success: false, error: 'Role not found' };
-      }
-
-      const associatedUsers = await this.entityManager.query(`SELECT map.*
-                                                              FROM sso_user_role_mapping map
-                                                                     JOIN sso_user usr ON map.user_id = usr.id
-                                                              WHERE usr.status = ${resolveStatus.id}
-                                                                and map.role_id = ${existingRole?.id}`);
-
-      if (associatedUsers.length > 0) {
-        return {
-          success: false,
-          error: 'Cannot deactivate role as it is associated with active users',
-        };
-      }
-
-      if (role.is_system === 1) {
-        return {
-          success: false,
-          error: 'Cannot deactivate system role',
-        };
-      }
-    }
-
-    if (
-      await this.roleRepository.isRoleNameExists(entityData.name, {
-        excludeRoleId: entityData.id,
-        organization_id: loggedInUser?.organization_id,
-      })
-    ) {
-      return {
-        success: false,
-        error: '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,
-        loggedInUser,
-      );
-
-      if (!sourceRole) {
-        return {
-          success: false,
-          error: '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,
-          appcode: perm.appcode,
-          level_type: perm.level_type,
-        }),
-      );
-
-      await this.moduleAccessRepo.save(clonedPermissions);
-    }
-    return { success: true, data: updatedRole };
-  }
-
-  async getDefaultRole(data: {
-    is_factory?: boolean;
-    level_id?: number;
-    level_type?: string;
-  }): Promise<Role[] | null> {
-    return await this.roleRepository.find(data);
-  }
-}
+import { BadRequestException, Inject, 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, STATUS_INACTIVE } from 'src/constant/global.constant';
+import { RoleRepository } from '../repository/role.repository';
+import { EntityManager, Repository } from 'typeorm';
+import { InjectRepository } from '@nestjs/typeorm';
+import { ModuleAccess } from '../../module/entity/module-access.entity';
+import { ServiceResult } from 'src/dtos/response';
+import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
+
+@Injectable()
+export class RoleService extends EntityServiceImpl {
+  constructor(
+    private readonly roleRepository: RoleRepository,
+    private readonly entityManager: EntityManager,
+    @InjectRepository(ModuleAccess)
+    private readonly moduleAccessRepo: Repository<ModuleAccess>,
+    @Inject('ListMasterService')
+    private readonly listMasterService: ListMasterService,
+  ) {
+    super();
+  }
+
+  async createEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData,
+  ): Promise<ServiceResult<BaseEntity>> {
+    const role = entityData as Role;
+
+    // if level_type and level_id are not provided, use loggedInUser's values
+    role.level_type = entityData.level_type || loggedInUser.level_type;
+    role.level_id = entityData.level_id || loggedInUser.level_id;
+    role.appcode = entityData.appcode || loggedInUser.appcode;
+
+    if (
+      await this.roleRepository.isRoleNameWithLevelExists(role.name, {
+        organization_id: loggedInUser?.organization_id || undefined,
+        level_type: entityData.level_type || loggedInUser?.level_type,
+        level_id:
+          parseInt(entityData.level_id) ||
+          parseInt(loggedInUser?.level_id || '', 10),
+      })
+    ) {
+      return { success: false, error: 'Role name already exists.' };
+    }
+
+    const sourceRole = role.copy_from_role_id
+      ? await this.getEntityData(
+          ENTITYTYPE_ROLE,
+          role.copy_from_role_id,
+          loggedInUser,
+        )
+      : null;
+
+    if (role.copy_from_role_id && !sourceRole) {
+      return { success: false, error: '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,
+          level_type: perm.level_type,
+          appcode: perm.appcode,
+        }),
+      );
+
+      await this.moduleAccessRepo.save(clonedPermissions);
+    }
+    return { success: true, data: savedRole };
+  }
+
+  async updateEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData,
+  ): Promise<ServiceResult<BaseEntity>> {
+    if (!entityData.name) {
+      return { success: false, error: 'Role name is required' };
+    }
+    const role = entityData as Role;
+
+    const resolveStatus = await this.listMasterService.getResolvedListCode(
+      STATUS_INACTIVE,
+      loggedInUser?.organization_id || 0,
+    );
+
+    if (entityData.status == resolveStatus.id) {
+      //get role by id
+      const existingRole = await this.getEntityData(
+        ENTITYTYPE_ROLE,
+        entityData.id,
+        loggedInUser,
+      );
+
+      if (!existingRole) {
+        return { success: false, error: 'Role not found' };
+      }
+
+      const associatedUsers = await this.entityManager.query(`SELECT map.*
+                                                              FROM sso_user_role_mapping map
+                                                                     JOIN sso_user usr ON map.user_id = usr.id
+                                                              WHERE usr.status = ${resolveStatus.id}
+                                                                and map.role_id = ${existingRole?.id}`);
+
+      if (associatedUsers.length > 0) {
+        return {
+          success: false,
+          error: 'Cannot deactivate role as it is associated with active users',
+        };
+      }
+
+      if (role.is_system === 1) {
+        return {
+          success: false,
+          error: 'Cannot deactivate system role',
+        };
+      }
+    }
+
+    if (
+      await this.roleRepository.isRoleNameExists(entityData.name, {
+        excludeRoleId: entityData.id,
+        organization_id: loggedInUser?.organization_id,
+      })
+    ) {
+      return {
+        success: false,
+        error: '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,
+        loggedInUser,
+      );
+
+      if (!sourceRole) {
+        return {
+          success: false,
+          error: '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,
+          appcode: perm.appcode,
+          level_type: perm.level_type,
+        }),
+      );
+
+      await this.moduleAccessRepo.save(clonedPermissions);
+    }
+    return { success: true, data: updatedRole };
+  }
+
+  async getDefaultRole(data: {
+    is_factory?: boolean;
+    level_id?: number;
+    level_type?: string;
+  }): Promise<Role[] | null> {
+    return await this.roleRepository.find(data);
+  }
+}

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

@@ -1,98 +1,98 @@
-import { level } from 'winston';
-import { Injectable } from '@nestjs/common';
-import { UserRoleMappingRepository } from '../repository/user-role-mapping.repository';
-import { UserRoleMapping } from '../entity/user-role-mapping.entity';
-
-@Injectable()
-export class UserRoleMappingService {
-  constructor(
-    private readonly userRoleMappingRepository: UserRoleMappingRepository,
-  ) {}
-
-  async assignUserRole(userRoleMapping: UserRoleMapping) {
-    const existing = await this.userRoleMappingRepository.findByUserIdAndRoleId(
-      userRoleMapping.user_id,
-      userRoleMapping.role_id,
-      userRoleMapping.appcode,
-      userRoleMapping.level_id,
-      userRoleMapping.level_type,
-    );
-
-    if (!existing) {
-      return await this.userRoleMappingRepository.save(userRoleMapping);
-    }
-  }
-
-  async updateAssignedRole(userRoleMapping: UserRoleMapping) {
-    // 1. If ID is provided, try to fetch existing mapping by ID
-    if (userRoleMapping.id) {
-      const existing = await this.userRoleMappingRepository.findByUSRId(
-        userRoleMapping.id,
-      );
-      if (existing) {
-        existing.appcode = userRoleMapping.appcode;
-        existing.level_id = userRoleMapping.level_id;
-        existing.level_type = userRoleMapping.level_type;
-        existing.role_id = userRoleMapping.role_id;
-
-        return await this.userRoleMappingRepository.save(existing);
-      }
-    }
-
-    // 2. Check if a similar mapping already exists (same user-role-level-app)
-    const duplicate =
-      await this.userRoleMappingRepository.findByUserIdAndRoleId(
-        userRoleMapping.user_id,
-        userRoleMapping.role_id,
-        userRoleMapping.appcode,
-        userRoleMapping.level_id,
-        userRoleMapping.level_type,
-      );
-
-    if (duplicate) {
-      return duplicate; // or null, depending on how you want to handle it
-    }
-
-    return await this.userRoleMappingRepository.save(userRoleMapping);
-  }
-
-  async findByUserId(userId: number): Promise<UserRoleMapping[] | null> {
-    return await this.userRoleMappingRepository.findByUserId(userId);
-  }
-
-  async deleteByUserId(
-    userId: number,
-    levelType?: string,
-    levelId?,
-  ): Promise<void> {
-    await this.userRoleMappingRepository.deleteByUserId(
-      userId,
-      levelType,
-      levelId,
-    );
-  }
-
-  async getUserByIdAndAppCode(
-    userId: number,
-    appCode: string,
-  ): Promise<UserRoleMapping | null> {
-    return await this.userRoleMappingRepository.findByUserIdAndAppCode(
-      userId,
-      appCode,
-    );
-  }
-
-  async getUserByIdAppCodeAndLevel(
-    userId: number,
-    appCode: string,
-    levelType: string,
-    levelId: string,
-  ): Promise<UserRoleMapping | null> {
-    return await this.userRoleMappingRepository.findByUserIdAndAppCodeAndLevel(
-      userId,
-      appCode,
-      levelType,
-      levelId,
-    );
-  }
-}
+import { level } from 'winston';
+import { Injectable } from '@nestjs/common';
+import { UserRoleMappingRepository } from '../repository/user-role-mapping.repository';
+import { UserRoleMapping } from '../entity/user-role-mapping.entity';
+
+@Injectable()
+export class UserRoleMappingService {
+  constructor(
+    private readonly userRoleMappingRepository: UserRoleMappingRepository,
+  ) {}
+
+  async assignUserRole(userRoleMapping: UserRoleMapping) {
+    const existing = await this.userRoleMappingRepository.findByUserIdAndRoleId(
+      userRoleMapping.user_id,
+      userRoleMapping.role_id,
+      userRoleMapping.appcode,
+      userRoleMapping.level_id,
+      userRoleMapping.level_type,
+    );
+
+    if (!existing) {
+      return await this.userRoleMappingRepository.save(userRoleMapping);
+    }
+  }
+
+  async updateAssignedRole(userRoleMapping: UserRoleMapping) {
+    // 1. If ID is provided, try to fetch existing mapping by ID
+    if (userRoleMapping.id) {
+      const existing = await this.userRoleMappingRepository.findByUSRId(
+        userRoleMapping.id,
+      );
+      if (existing) {
+        existing.appcode = userRoleMapping.appcode;
+        existing.level_id = userRoleMapping.level_id;
+        existing.level_type = userRoleMapping.level_type;
+        existing.role_id = userRoleMapping.role_id;
+
+        return await this.userRoleMappingRepository.save(existing);
+      }
+    }
+
+    // 2. Check if a similar mapping already exists (same user-role-level-app)
+    const duplicate =
+      await this.userRoleMappingRepository.findByUserIdAndRoleId(
+        userRoleMapping.user_id,
+        userRoleMapping.role_id,
+        userRoleMapping.appcode,
+        userRoleMapping.level_id,
+        userRoleMapping.level_type,
+      );
+
+    if (duplicate) {
+      return duplicate; // or null, depending on how you want to handle it
+    }
+
+    return await this.userRoleMappingRepository.save(userRoleMapping);
+  }
+
+  async findByUserId(userId: number): Promise<UserRoleMapping[] | null> {
+    return await this.userRoleMappingRepository.findByUserId(userId);
+  }
+
+  async deleteByUserId(
+    userId: number,
+    levelType?: string,
+    levelId?,
+  ): Promise<void> {
+    await this.userRoleMappingRepository.deleteByUserId(
+      userId,
+      levelType,
+      levelId,
+    );
+  }
+
+  async getUserByIdAndAppCode(
+    userId: number,
+    appCode: string,
+  ): Promise<UserRoleMapping | null> {
+    return await this.userRoleMappingRepository.findByUserIdAndAppCode(
+      userId,
+      appCode,
+    );
+  }
+
+  async getUserByIdAppCodeAndLevel(
+    userId: number,
+    appCode: string,
+    levelType: string,
+    levelId: string,
+  ): Promise<UserRoleMapping | null> {
+    return await this.userRoleMappingRepository.findByUserIdAndAppCodeAndLevel(
+      userId,
+      appCode,
+      levelType,
+      levelId,
+    );
+  }
+}