rez_core 2.0.47 → 2.0.49

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

@@ -42,9 +42,7 @@ export class UserService extends EntityServiceImpl {
     manager?: EntityManager,
   ): Promise<BaseEntity> {
     let userData = entityData as CreateUserDto;
-    // if (appcode) {
-    //   userData.appcode = appcode;
-    // }
+
     let existingUser = await this.userRepository.findByEmailId(
       userData.email_id,
       loggedInUser?.organization_id,
@@ -83,62 +81,43 @@ export class UserService extends EntityServiceImpl {
     userData.invitation_status = 'SENT';
     userData.status = STATUS_ACTIVE;
     const savedData = await super.createEntity(userData, loggedInUser);
-    userData.roles.push('1');
-    userData.roles.push('2');
-    if (userData.roles) {
-      let roles = userData.roles;
-      await this.userRoleMappingService.deleteByUserId(userData.id);
-      for (const role in roles) {
-        let userRoleMapping = new UserRoleMapping(
-          savedData.id,
-          Number(roles[role]),
-        );
 
-        await this.userRoleMappingService.assignUserRole(userRoleMapping);
-      }
-    }
+    const insertPromises: any = [];
 
-    //Assign user app mapping as per user
+    for (const entry of userData.access || []) {
+      const { level_type, level_ids, app_code, role_id } = entry;
 
-    const appcodedata = ['CRM', 'ERP'];
+      if (
+        !level_type ||
+        !Array.isArray(level_ids) ||
+        !level_ids.length ||
+        !app_code ||
+        !role_id
+      ) {
+        throw new BadRequestException('Invalid access level entry');
+      }
 
-    if (savedData.id) {
-      for (const app of appcodedata) {
-        await this.userAppMappingService.assignUserAppMapping(
-          savedData.id,
-          app,
+      for (const levelId of level_ids) {
+        const userRoleMapping = new UserRoleMapping(savedData.id, role_id);
+        userRoleMapping.level_type = level_type;
+        userRoleMapping.level_id = String(levelId);
+        userRoleMapping.appcode = app_code;
+        userRoleMapping.organization_id = loggedInUser?.organization_id || 0;
+        insertPromises.push(
+          this.userRoleMappingService.assignUserRole(userRoleMapping),
         );
       }
     }
 
-    // let role = new Role();
-    // role.organization_id = savedData.organization_id;
-    // role.enterprise_id = savedData.enterprise_id;
-    // role.is_system = 1;
-    // role.status = 'ACTIVE';
-    // role.name = 'School Admin';
-
-    // let defaultadminERP: string | undefined = 'ADMIN';
-    // let defaultadminCRM: string | undefined = 'ADMIN_CRM';
-
-    // if (defaultadminERP && defaultadminCRM) {
-    //   let defaultAdminRoleERP = await this.roleService.findByCode(
-    //     ENTITYTYPE_ROLE,
-    //     defaultadminERP,
-    //   );
-    //   let defaultAdminRoleCRM = await this.roleService.findByCode(
-    //     ENTITYTYPE_ROLE,
-    //     defaultadminCRM,
-    //   );
-    //   if (defaultAdminRoleERP) {
-    //     role.copy_from_role_id = defaultAdminRoleERP.id;
-    //     let savedRoleERP = await this.roleService.createEntity(role, null);
-    //   }
-    //   if (defaultAdminRoleCRM) {
-    //     role.copy_from_role_id = defaultAdminRoleCRM.id;
-    //     let savedRoleCRM = await this.roleService.createEntity(role, null);
-    //   }
-    // }
+    try {
+      if (insertPromises.length > 0) {
+        await Promise.all(insertPromises);
+      }
+      console.log('Access levels added successfully');
+    } catch (error) {
+      console.error('Error adding access levels:', error);
+      throw new BadRequestException('Failed to add access levels');
+    }
 
     return savedData;
   }
@@ -173,14 +152,11 @@ export class UserService extends EntityServiceImpl {
   ): Promise<BaseEntity> {
     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 decryptedPassword = EncryptUtilService.decryptGCM(
         existingUser.password,
@@ -194,25 +170,59 @@ export class UserService extends EntityServiceImpl {
         );
       }
 
-      // Encrypt new password
-      const encryptedPassword = EncryptUtilService.encryptGCM(
+      userDto.password = EncryptUtilService.encryptGCM(
         userDto.password,
         this.masterKey,
         this.masterIv,
       );
-      userDto.password = encryptedPassword;
     }
 
-    const userData = plainToInstance(UserData, userDto);
+    const updatedUserData = { ...userDto } as any;
+    delete updatedUserData.access;
+
+    const savedData = await super.updateEntity(
+      updatedUserData,
+      loggedInUserData,
+    );
 
-    const savedData = await super.updateEntity(userData, loggedInUserData);
+    // Handle updated access levels
+    if (userDto.access && userDto.access.length > 0) {
+      const insertPromises: any[] = [];
+
+      for (const entry of userDto.access) {
+        const { id, level_type, level_ids, app_code, role_id } = entry;
+
+        if (
+          !level_type ||
+          typeof level_ids !== 'number' ||
+          !app_code ||
+          !role_id
+        ) {
+          throw new BadRequestException('Invalid access level entry');
+        }
+
+        const userRoleMapping = new UserRoleMapping(savedData.id, role_id);
+        if (id) {
+          userRoleMapping.id = id; // Use the existing ID if provided
+        }
+
+        userRoleMapping.role_id = role_id;
+        userRoleMapping.appcode = app_code;
+        userRoleMapping.level_id = String(level_ids); // level_ids is now a number
+        userRoleMapping.level_type = level_type;
+        userRoleMapping.organization_id = loggedInUserData.organization_id || 0;
+
+        insertPromises.push(
+          this.userRoleMappingService.updateAssignedRole(userRoleMapping),
+        );
+      }
 
-    // Update roles if provided
-    if (userDto.roles) {
-      await this.userRoleMappingService.deleteByUserId(savedData.id); // prevent duplicates
-      for (const role of userDto.roles) {
-        const userRoleMapping = new UserRoleMapping(savedData.id, Number(role));
-        await this.userRoleMappingService.assignUserRole(userRoleMapping);
+      try {
+        await Promise.all(insertPromises);
+        console.log('Access levels updated successfully');
+      } catch (error) {
+        console.error('Error updating access levels:', error);
+        throw new BadRequestException('Failed to update access levels');
       }
     }