rez_core 2.1.3 → 2.1.6

package/package.json

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

package/src/config/database.config.ts

@@ -4,15 +4,12 @@ import { TypeOrmModuleOptions, TypeOrmOptionsFactory } from '@nestjs/typeorm';
 
 @Injectable()
 export class MySqlConfiguration implements TypeOrmOptionsFactory {
-
-  constructor(
-    private configService: ConfigService,
-  ){}
+  constructor(private configService: ConfigService) {}
 
   createTypeOrmOptions(): TypeOrmModuleOptions {
     return {
       type: 'mysql',
-      host:  this.configService.get('DB_HOST')|| '13.234.25.234',
+      host: this.configService.get('DB_HOST') || '13.234.25.234',
       port: parseInt(this.configService.get('DB_PORT') || '3306', 10),
       username: this.configService.get('DB_USER') || 'root',
       password: this.configService.get('DB_PASS') || 'Rezolut@123',
@@ -20,6 +17,7 @@ export class MySqlConfiguration implements TypeOrmOptionsFactory {
       entities: [__dirname + '/../module/**/*.entity.{ts,js}'],
       synchronize: true,
       autoLoadEntities: true,
+      poolSize: 5,
     };
   }
 }

package/src/dtos/response.dto.ts

@@ -0,0 +1,6 @@
+// dto/service-result.dto.ts
+export interface ServiceResult<T = any> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}

package/src/module/master/service/master.service.ts

@@ -469,10 +469,6 @@ export class MasterService {
 
       const existing = await qb.limit(1).getRawOne();
 
-      row.entity_type = entityType;
-      row.organization_id = loggedInUser.organization_id;
-      row.status = 'ACTIVE';
-      let errors = [];
       if (existing) {
         if (duplicateHandling === 'skip_duplicates') continue;
         if (duplicateHandling === 'overwrite_items') {
@@ -483,5 +479,11 @@ export class MasterService {
         await entityService.createEntity(row, loggedInUser);
       }
     }
+
+    // if (errors.length > 0) {
+    //   throw new Error(
+    //     `Validation errors found in the uploaded data: ${JSON.stringify(errors)}`,
+    //   );
+    // }
   }
 }

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

@@ -177,7 +177,7 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
     entityData: BaseEntity,
     loggedInUser: UserData | null,
     appcode?: string,
-  ): Promise<BaseEntity> {
+  ) {
     const entityMaster = await this.entityMasterService.getEntityData(
       entityData.entity_type,
     );

package/src/module/module/service/module-access.service.ts

@@ -4,7 +4,7 @@ import { RoleRepository } from 'src/module/user/repository/role.repository';
 import { RoleService } from '../../user/service/role.service';
 import { ENTITYTYPE_ROLE } from '../../../constant/global.constant';
 import { Role } from '../../user/entity/role.entity';
-import { EntityManager } from 'typeorm';
+import { DataSource, EntityManager } from 'typeorm';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { MenuRepository } from '../repository/menu.repository';
 
@@ -13,8 +13,8 @@ export class ModuleAccessService {
   constructor(
     private readonly moduleAccessRepository: ModuleAccessRepository,
     private readonly menuRepository: MenuRepository,
+    private readonly dataSource: DataSource,
   ) {}
-
   async getRoles({
     appcode,
     level_type,
@@ -24,12 +24,31 @@ export class ModuleAccessService {
     level_type?: string;
     level_id?: number;
   }) {
-    return this.moduleAccessRepository.getRoles({
-      appcode,
-      level_type,
-      level_id,
-    });
+    const query = this.dataSource
+      .createQueryBuilder()
+      .select('*')
+      .from('cr_role', 'role')
+      .where('role.appcode = :appcode', { appcode })
+      .andWhere('(role.is_factory IS NULL OR role.is_factory != 1)');
+  
+      
+    if (level_type) {
+      query.andWhere('role.level_type = :level_type', { level_type });
+    }
+  
+    if (level_id !== undefined) {
+      query.andWhere('role.level_id = :level_id', { level_id: String(level_id) });
+    }
+  
+    const roles = await query.getRawMany(); // use getRawMany since you're selecting from a raw table
+  
+    return roles.map((role) => ({
+      label: role.name,
+      value: role.id,
+    }));
   }
+  
+  
 
   async getModules({ appcode }: { appcode: string }) {
     return this.moduleAccessRepository.getModules({

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

@@ -120,9 +120,15 @@ export class LoginService {
       user.last_name = name.familyName;
 
       user.name = user.first_name + ' ' + user.last_name;
-      let savedUser = await this.userService.createEntity(user, null);
-
-      user = savedUser as UserData;
+      let savedUserResponse = await this.userService.createEntity(user, null);
+
+      if (savedUserResponse.success) {
+        user = savedUserResponse.data as UserData;
+      } else {
+        throw new BadRequestException(
+          savedUserResponse.error || 'Failed to create user',
+        );
+      }
     }
 
     // Create session (Same as JWT login flow)

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

@@ -13,12 +13,11 @@ import {
 import { CreateUserDto } from '../dto/create-user.dto';
 import { UserRoleMappingService } from './user-role-mapping.service';
 import { UserRoleMapping } from '../entity/user-role-mapping.entity';
-import { plainToInstance } from 'class-transformer';
 import { EntityManager } from 'typeorm';
 import { UpdateUserDto } from '../dto/update-user.dto';
 import { ConfigService } from '@nestjs/config';
 import { UserAppMappingService } from 'src/module/meta/service/user-app-mapping.service';
-import { Role } from '../entity/role.entity';
+import { ServiceResult } from 'src/dtos/response.dto';
 
 @Injectable()
 export class UserService extends EntityServiceImpl {
@@ -40,7 +39,7 @@ export class UserService extends EntityServiceImpl {
     entityData: BaseEntity,
     loggedInUser: UserData | null,
     manager?: EntityManager,
-  ): Promise<BaseEntity> {
+  ): Promise<ServiceResult<BaseEntity>> {
     let userData = entityData as CreateUserDto;
 
     let existingUser = await this.userRepository.findByEmailId(
@@ -48,7 +47,7 @@ export class UserService extends EntityServiceImpl {
       loggedInUser?.organization_id,
     );
     if (existingUser) {
-      throw new BadRequestException('User already exists');
+      return { success: false, error: 'User with this email already exists' };
     }
 
     existingUser = await this.userRepository.findByMobile(
@@ -56,33 +55,24 @@ export class UserService extends EntityServiceImpl {
       loggedInUser?.organization_id,
     );
     if (existingUser) {
-      throw new BadRequestException('User already exists');
+      return { success: false, error: 'User with this mobile already exists' };
     }
-    userData.name =
-      (userData.first_name ? userData.first_name : '') +
-      (userData.last_name ? userData.last_name : '');
-    let password;
-    if (userData.password) {
-      password = EncryptUtilService.encryptGCM(
-        userData.password,
-        this.masterKey,
-        this.masterIv,
-      );
-    } else {
-      password = EncryptUtilService.encryptGCM(
-        'Admin@123',
-        this.masterKey,
-        this.masterIv,
-      );
-    }
-    userData.password = password;
+
+    userData.name = (userData.first_name || '') + (userData.last_name || '');
+    userData.password = EncryptUtilService.encryptGCM(
+      userData.password || 'Admin@123',
+      this.masterKey,
+      this.masterIv,
+    );
     userData.is_firstlogin = 1;
     userData.roles = [];
     userData.invitation_status = 'SENT';
     userData.status = STATUS_ACTIVE;
+
     const savedData = await super.createEntity(userData, loggedInUser);
 
-    const insertPromises: any = [];
+    const insertPromises: Promise<UserRoleMapping | void | null | undefined>[] =
+      [];
 
     for (const entry of userData.access || []) {
       const { level_type, level_ids, app_code, role_id } = entry;
@@ -94,7 +84,7 @@ export class UserService extends EntityServiceImpl {
         !app_code ||
         !role_id
       ) {
-        throw new BadRequestException('Invalid access level entry');
+        return { success: false, error: 'Invalid access level entry' };
       }
 
       for (const levelId of level_ids) {
@@ -115,10 +105,10 @@ export class UserService extends EntityServiceImpl {
       }
     } catch (error) {
       console.error('Error adding access levels:', error);
-      throw new BadRequestException('Failed to add access levels');
+      return { success: false, error: 'Failed to add access levels' };
     }
 
-    return savedData;
+    return { success: true, data: savedData };
   }
 
   async getEntityData(
@@ -148,12 +138,13 @@ export class UserService extends EntityServiceImpl {
   async updateEntity(
     entityData: BaseEntity,
     loggedInUserData: UserData,
-  ): Promise<BaseEntity> {
+  ): Promise<ServiceResult<BaseEntity>> {
     const userDto = entityData as UpdateUserDto;
 
     const existingUser = await this.userRepository.findById(entityData.id);
+
     if (!existingUser) {
-      throw new BadRequestException('User not found');
+      return { success: false, error: 'User not found' };
     }
 
     if (userDto.password) {
@@ -164,9 +155,10 @@ export class UserService extends EntityServiceImpl {
       );
 
       if (decryptedPassword === userDto.password) {
-        throw new BadRequestException(
-          'New password cannot be the same as the current password',
-        );
+        return {
+          success: false,
+          error: 'New password cannot be the same as the current password',
+        };
       }
 
       userDto.password = EncryptUtilService.encryptGCM(
@@ -186,7 +178,6 @@ export class UserService extends EntityServiceImpl {
 
     // Handle updated access levels
     if (userDto.access && userDto.access.length > 0) {
-      // delete all the existing user role mapping
       await this.userRoleMappingService.deleteByUserId(existingUser.id);
 
       const insertPromises: any[] = [];
@@ -195,18 +186,17 @@ export class UserService extends EntityServiceImpl {
         const { level_type, level_ids, app_code, role_id } = entry;
 
         if (!level_type || !app_code || !role_id || !Array.isArray(level_ids)) {
-          throw new BadRequestException('Invalid access level entry');
+          return { success: false, error: 'Invalid access level entry' };
         }
 
         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.role_id = role_id;
           userRoleMapping.organization_id =
             loggedInUserData?.organization_id || 0;
+
           insertPromises.push(
             this.userRoleMappingService.assignUserRole(userRoleMapping),
           );
@@ -217,11 +207,11 @@ export class UserService extends EntityServiceImpl {
         await Promise.all(insertPromises);
       } catch (error) {
         console.error('Error updating access levels:', error);
-        throw new BadRequestException('Failed to update access levels');
+        return { success: false, error: 'Failed to update access levels' };
       }
     }
 
-    return savedData;
+    return { success: true, data: savedData };
   }
 
   async findByEmailId(