rez_core 1.0.80 → 1.0.83

package/package.json

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

package/src/module/meta/service/entity-list.service.ts

@@ -97,7 +97,7 @@ export class EntityListService {
     entityTab.tab_value = 'ALL';
     entityTab.tab_value_count = all;
     tabs.push(entityTab);
-    return tabs;
+    return tabs.reverse();
   }
 
   private getQuery(source: string, groupByColumn: string | null) {

package/src/module/meta/service/entity-validation.service.ts

@@ -56,13 +56,23 @@ export class EntityValidationService {
       const value = entityData[attr.attribute_key];
   
       if (this.hasValidValue(value)) {
-        const existing = await this.dataSource
+        let qb = this.dataSource
           .createQueryBuilder()
-          .select("*")
+          .select('*')
           .from(db_table_name, db_table_name)
-          .where(`${db_table_name}.${attr.attribute_key} = :value`, { value })
-          .limit(1)
-          .getRawOne();
+          .where(`${db_table_name}.${attr.attribute_key} = :value`, { value });
+  
+        // Add AND condition for organization_id if present
+        const orgId = entityData.organization_id;
+
+        if (orgId !== undefined && orgId !== null) {
+          qb = qb.andWhere(`${db_table_name}.organization_id = :organization_id`, {
+            organization_id: orgId,
+          });
+        }
+
+  
+        const existing = await qb.limit(1).getRawOne();
   
         if (existing) {
           errors.push({
@@ -76,6 +86,7 @@ export class EntityValidationService {
     return errors;
   }
   
+  
   /**
    * Validates both required and unique fields for a given entity type.
    */

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

@@ -17,16 +17,26 @@ export class RoleRepository {
   }
 
 
-  public async isRoleNameExists(name: string, excludeRoleId?: number): Promise<boolean> {
+  public async isRoleNameExists(
+    name: string,
+    options?: { excludeRoleId?: number; organization_id?: number }
+  ): Promise<boolean> {
     const query = this.roleRepo
       .createQueryBuilder('role')
       .where('role.name = :name', { name });
-
-    if (excludeRoleId) {
-      query.andWhere('role.id != :excludeRoleId', { excludeRoleId });
+  
+    if (options?.excludeRoleId) {
+      query.andWhere('role.id != :excludeRoleId', { excludeRoleId: options.excludeRoleId });
     }
-
+  
+    if (options?.organization_id !== undefined) {
+      query.andWhere('role.organization_id = :organization_id', {
+        organization_id: options.organization_id,
+      });
+    }
+  
     const existingRole = await query.getOne();
     return !!existingRole;
   }
+  
 }

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

@@ -9,22 +9,23 @@ export class UserRepository {
     @InjectRepository(UserData) private userRepository: Repository<UserData>,
   ) {}
 
-  async findByEmailId(email: string): Promise<UserData | null> {
-    if (email) {
-      return this.userRepository.findOne({ where: { email_id: email } });
-    }
-    return null;
-  }
-
   async findById(userId: number): Promise<UserData | null> {
     return this.userRepository.findOne({ where: { id: userId } });
   }
+  async findByEmailId(email: string): Promise<UserData | null> {
+    if (!email) return null;
+
+    const where: any = { email_id: email };
+
+    return this.userRepository.findOne({ where });
+  }
 
   async findByMobile(mobile: string): Promise<UserData | null> {
-    if (mobile) {
-      return this.userRepository.findOne({ where: { mobile: mobile } });
-    }
-    return null;
+    if (!mobile) return null;
+
+    const where: any = { mobile: mobile };
+
+    return this.userRepository.findOne({ where });
   }
 
   async saveUser(user: UserData): Promise<UserData> {

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

@@ -27,7 +27,7 @@ export class RoleService extends EntityServiceImpl {
   ): Promise<BaseEntity> {
     let role = entityData as Role;
 
-    if (await this.roleRepository.isRoleNameExists(role.name)) {
+    if (await this.roleRepository.isRoleNameExists(role.name,{organization_id:entityData.organization_id})) {
       throw new BadRequestException('Role name already exists.');
     }
 
@@ -98,7 +98,7 @@ export class RoleService extends EntityServiceImpl {
     }
 
     if (
-      await this.roleRepository.isRoleNameExists(entityData.name, entityData.id)
+      await this.roleRepository.isRoleNameExists(entityData.name, {excludeRoleId:entityData.id})
     ) {
       throw new BadRequestException('Role name already exists.');
     }

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

@@ -38,13 +38,15 @@ export class UserService extends EntityServiceImpl {
   ): Promise<BaseEntity> {
     let userData = entityData as CreateUserDto;
     let existingUser = await this.userRepository.findByEmailId(
-      userData.email_id,
+      userData.email_id
     );
     if (existingUser) {
       throw new BadRequestException('User already exists');
     }
 
-    existingUser = await this.userRepository.findByMobile(userData.mobile);
+    existingUser = await this.userRepository.findByMobile(
+      userData.mobile
+    );
     if (existingUser) {
       throw new BadRequestException('User already exists');
     }
@@ -113,37 +115,63 @@ export class UserService extends EntityServiceImpl {
     entityData: BaseEntity,
     loggedInUserData: UserData,
   ): Promise<BaseEntity> {
-    let userDto = entityData as UpdateUserDto;
-
+    const userDto = entityData as UpdateUserDto;
+  
+    // Fetch the current user data from DB to get the existing encrypted password
+    const existingUser = await this.userRepository.findById(entityData.id);
+  
+    if (!existingUser) {
+      throw new BadRequestException('User not found');
+    }
+  
+    // If password is being updated, check if it's the same as existing one
     if (userDto.password) {
-      const password = EncryptUtilService.encryptGCM(
+      const decryptedPassword = EncryptUtilService.decryptGCM(
+        existingUser.password,
+        this.masterKey,
+        this.masterIv,
+      );
+  
+      if (decryptedPassword === userDto.password) {
+        throw new BadRequestException(
+          'New password cannot be the same as the current password',
+        );
+      }
+  
+      // Encrypt new password
+      const encryptedPassword = EncryptUtilService.encryptGCM(
         userDto.password,
         this.masterKey,
         this.masterIv,
       );
-      userDto.password = password;
+      userDto.password = encryptedPassword;
     }
-
-    let userData = plainToInstance(UserData, userDto);
-    let savedData = await super.updateEntity(userData, loggedInUserData);
+  
+    const userData = plainToInstance(UserData, userDto);
+  
+    const savedData = await super.updateEntity(userData, loggedInUserData);
+  
+    // Update roles if provided
     if (userDto.roles) {
-      let roles = userDto.roles;
-      for (const role in roles) {
-        let userRoleMapping = new UserRoleMapping(
+      await this.userRoleMappingService.deleteByUserId(savedData.id); // prevent duplicates
+      for (const role of userDto.roles) {
+        const userRoleMapping = new UserRoleMapping(
           savedData.id,
-          Number(roles[role]),
+          Number(role),
         );
         await this.userRoleMappingService.assignUserRole(userRoleMapping);
       }
     }
+  
     return savedData;
   }
+  
 
   async findByEmailId(email_id: string): Promise<UserData | null> {
     return await this.userRepository.findByEmailId(email_id);
   }
 
-  async findByMobile(mobile: string) {
+  async findByMobile(mobile: string): Promise<UserData | null> {
     return await this.userRepository.findByMobile(mobile);
   }
 }