rez_core 1.0.79 → 1.0.82

package/package.json

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

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

@@ -16,6 +16,7 @@ import { ExcelsheetData } from '../../../utils/dto/excelsheet-data.dto';
 import { EntityTableService } from './entity-table.service';
 import { EntityTableColumnService } from './entity-table-column.service';
 import { ENTITYTYPE_ENTITYMASTER } from '../../../constant/global.constant';
+import { EntityValidationService } from './entity-validation.service';
 
 @Injectable()
 export class EntityServiceImpl implements EntityService<BaseEntity> {
@@ -26,12 +27,15 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
   @Inject() protected readonly reflectionHelper: ReflectionHelper;
   @Inject() protected readonly entityListService: EntityListService;
   @Inject() protected readonly loggingService: LoggingService;
+  @Inject()
+protected readonly entityValidationService: EntityValidationService;
+
 
   async createEntity(
     entityData: BaseEntity,
     loggedInUser: UserData | null,
     manager?: EntityManager,
-  ): Promise<BaseEntity> {
+  ){
     if (!entityData.entity_type) {
       throw new BadRequestException(`EntityType is missing`);
     }
@@ -39,6 +43,16 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
       entityData.entity_type,
     );
 
+    const validationErrors = await this.entityValidationService.validateEntityData(entityData,entityMaster);
+    if (validationErrors.length > 0) {
+      
+     return {
+        success: false,
+        errors: validationErrors,
+      };
+     
+    }
+
     const repo = manager
       ? manager.getRepository(entityMaster.entity_data_class) // <-- Use transaction-safe repo
       : this.reflectionHelper.getRepoService(entityMaster.entity_data_class);

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

@@ -2,6 +2,7 @@ import { Injectable } from '@nestjs/common';
 import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
 import { AttributeMaster } from '../entity/attribute-master.entity';
 import { ReflectionHelper } from 'src/utils/service/reflection-helper.service';
+import { DataSource } from 'typeorm';
 
 interface ValidationError {
   field: string;
@@ -12,7 +13,8 @@ interface ValidationError {
 export class EntityValidationService {
   constructor(
     private readonly attributeMasterService: AttributeMasterService,
-    private readonly reflectionHelper: ReflectionHelper 
+    private readonly reflectionHelper: ReflectionHelper,
+    private dataSource: DataSource
   ) {}
 
   /**
@@ -27,11 +29,11 @@ export class EntityValidationService {
     attributeData
       .filter(attr => attr.required)
       .forEach(attr => {
-        const value = entityData[attr.code];
+        const value = entityData[attr.attribute_key];
         if (!this.hasValidValue(value)) {
           errors.push({
-            field: attr.code,
-            message: `Field "${attr.code}" is required.`,
+            field: attr.name,
+            message: `Field ${attr.name} is required.`,
           });
         }
       });
@@ -45,24 +47,37 @@ export class EntityValidationService {
   async validateUniqueFields(
     entityData: Record<string, any>,
     attributeData: AttributeMaster[],
-    entityType: string
+    entityType: string,
+    db_table_name: string
   ): Promise<ValidationError[]> {
     const errors: ValidationError[] = [];
   
-    const repo = this.reflectionHelper.getRepoService(entityData.entity_type);
-  
-    if (!repo) {
-      throw new Error(`Repository service not found for entityType: ${entityType}`);
-    }
-  
     for (const attr of attributeData.filter(a => a.is_unique)) {
-      const value = entityData[attr.code];
+      const value = entityData[attr.attribute_key];
+  
       if (this.hasValidValue(value)) {
-        const existing = await repo.findOne({ where: { [attr.code]: value } });
+        let qb = this.dataSource
+          .createQueryBuilder()
+          .select('*')
+          .from(db_table_name, db_table_name)
+          .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({
-            field: attr.code,
-            message: `Field "${attr.code}" must be unique. Value "${value}" already exists.`,
+            field: attr.name,
+            message: `Field ${attr.name} must be unique. Value ${value} already exists.`,
           });
         }
       }
@@ -71,17 +86,18 @@ export class EntityValidationService {
     return errors;
   }
   
-
+  
   /**
    * Validates both required and unique fields for a given entity type.
    */
   async validateEntityData(
-    entityData: Record<string, any>
+    entityData: Record<string, any>,
+    entityMaster
   ): Promise<ValidationError[]> {
     const attributes = await this.attributeMasterService.findAttributesByMappedEntityType(entityData.entity_type);
   
     const requiredErrors = this.validateRequiredFields(entityData, attributes);
-    const uniqueErrors = await this.validateUniqueFields(entityData, attributes, entityData.entity_type);
+    const uniqueErrors = await this.validateUniqueFields(entityData, attributes, entityData.entity_type,entityMaster.db_table_name);
   
     return [...requiredErrors, ...uniqueErrors];
   }

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,23 +9,32 @@ 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> {
+  async findById(userId: number ): Promise<UserData | null> {
     return this.userRepository.findOne({ where: { id: userId } });
   }
-
-  async findByMobile(mobile: string): Promise<UserData | null> {
-    if (mobile) {
-      return this.userRepository.findOne({ where: { mobile: mobile } });
+  async findByEmailId(email: string, organization_id?: number): Promise<UserData | null> {
+    if (!email) return null;
+  
+    const where: any = { email_id: email };
+    if (organization_id !== undefined) {
+      where.organization_id = organization_id;
+    }
+  
+    return this.userRepository.findOne({ where });
+  }
+  
+  async findByMobile(mobile: string, organization_id?: number): Promise<UserData | null> {
+    if (!mobile) return null;
+  
+    const where: any = { mobile: mobile };
+    if (organization_id !== undefined) {
+      where.organization_id = organization_id;
     }
-    return null;
+  
+    return this.userRepository.findOne({ where });
   }
+  
+  
 
   async saveUser(user: UserData): Promise<UserData> {
     return this.userRepository.save(user);

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

@@ -39,12 +39,16 @@ export class UserService extends EntityServiceImpl {
     let userData = entityData as CreateUserDto;
     let existingUser = await this.userRepository.findByEmailId(
       userData.email_id,
+      userData.organization_id
     );
     if (existingUser) {
       throw new BadRequestException('User already exists');
     }
 
-    existingUser = await this.userRepository.findByMobile(userData.mobile);
+    existingUser = await this.userRepository.findByMobile(
+      userData.mobile,
+      userData.organization_id
+    );
     if (existingUser) {
       throw new BadRequestException('User already exists');
     }
@@ -113,37 +117,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 findByEmailId(email_id: string,organization_id?: number): Promise<UserData | null> {
+    return await this.userRepository.findByEmailId(email_id,organization_id);
   }
 
-  async findByMobile(mobile: string) {
-    return await this.userRepository.findByMobile(mobile);
+  async findByMobile(mobile: string,organization_id: number): Promise<UserData | null> {
+    return await this.userRepository.findByMobile(mobile,organization_id);
   }
 }