rez_core 2.0.47 → 2.0.49

package/package.json

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

package/src/module/auth/strategies/jwt.strategy.ts

@@ -26,7 +26,7 @@ export class JwtStrategy extends PassportStrategy(Strategy) {
       organization_id,
       enterprise_id,
       level_id,
-      level_type
+      level_type,
     } = payload;
 
     // Check if session exists and is valid
@@ -50,7 +50,7 @@ export class JwtStrategy extends PassportStrategy(Strategy) {
       organization_id: organization_id,
       enterprise_id: enterprise_id,
       level_id: level_id,
-      level_type: level_type, 
+      level_type: level_type,
     };
 
     return { userData };

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

@@ -12,10 +12,15 @@ import { LoginService } from '../service/login.service';
 import { GoogleAuthGuard } from '../../../module/auth/guards/google-auth.guard';
 import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
 import { Request, Response } from 'express';
+import { JwtAuthService } from 'src/module/auth/services/jwt.service';
+import { UserSessionService } from '../service/user-session.service';
 
 @Controller('auth')
 export class LoginController {
-  constructor(private loginService: LoginService) {}
+  constructor(
+    private loginService: LoginService,
+    private userSessionService: UserSessionService,
+  ) {}
 
   @Post('login')
   async login(@Body() body, @Res() res: Response) {
@@ -51,4 +56,30 @@ export class LoginController {
     // Call LoginService to validate user, create session, and return JWT
     return this.loginService.loginWithGoogle(email, name);
   }
+
+  @UseGuards(JwtAuthGuard)
+  @Post('switch')
+  async switchCurrentLevel(
+    @Req() req: Request & { user: any },
+    @Body()
+    data: {
+      level_id: string;
+      level_type: string;
+      appcode: string;
+    },
+  ): Promise<any> {
+    const userId = req.user.userData.id;
+
+    const currentUserLevelType = req.user.userData.level_type;
+    const currentUserLevelId = req.user.userData.level_id;
+    const currentUserOrganization_id = req.user.userData.organization_id;
+
+    return await this.userSessionService.switchCurrentLevelService(
+      userId,
+      currentUserLevelType,
+      currentUserLevelId,
+      currentUserOrganization_id,
+      data,
+    );
+  }
 }

package/src/module/user/dto/create-user.dto.ts

@@ -57,4 +57,6 @@ export class CreateUserDto extends BaseEntity {
   is_customer: number;
   appcode: string;
   is_factory: number;
+
+  access: any[];
 }

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

@@ -2,8 +2,6 @@ import { BadRequestException, Injectable } from '@nestjs/common';
 import { Repository } from 'typeorm';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Role } from '../entity/role.entity';
-import { ModuleAccess } from 'src/module/module/entity/module-access.entity';
-import { UserData } from '../entity/user.entity';
 
 @Injectable()
 export class RoleRepository {
@@ -49,4 +47,50 @@ export class RoleRepository {
       },
     });
   }
+
+  /*
+    Ensure role_code is unique within the same level_type and level_id.
+   * Confirm level_type and level_id correspond to existing org/school.
+    */
+
+  public async isRoleNameWithLevelExists(
+    name: string,
+    options?: {
+      excludeRoleId?: number;
+      organization_id?: number;
+      level_type?: string;
+      level_id?: number;
+    },
+  ): Promise<boolean> {
+    const query = this.roleRepo
+      .createQueryBuilder('role')
+      .where('role.name = :name', { name });
+
+    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,
+      });
+    }
+
+    if (options?.level_type) {
+      query.andWhere('role.level_type = :level_type', {
+        level_type: options.level_type,
+      });
+    }
+
+    if (options?.level_id !== undefined) {
+      query.andWhere('role.level_id = :level_id', {
+        level_id: options.level_id,
+      });
+    }
+
+    const existingRole = await query.getOne();
+    return !!existingRole;
+  }
 }

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

@@ -16,6 +16,14 @@ export class UserRoleMappingRepository {
     return await this.userRoleMappingRepository.save(userRoleMapping);
   }
 
+  async update(
+    id: number,
+    userRoleMapping: UserRoleMapping,
+  ): Promise<UserRoleMapping | null> {
+    await this.userRoleMappingRepository.update(id, userRoleMapping);
+    return await this.userRoleMappingRepository.findOneBy({ id });
+  }
+
   async findByUserId(userId: number): Promise<UserRoleMapping[] | null> {
     return await this.userRoleMappingRepository.find({
       where: { user_id: userId },
@@ -31,9 +39,30 @@ export class UserRoleMappingRepository {
   async findByUserIdAndRoleId(
     userId: number,
     roleId: number,
+    appcode?: string,
+    level_id?: string,
+    level_type?: string,
   ): Promise<UserRoleMapping | null> {
     return await this.userRoleMappingRepository.findOne({
-      where: { user_id: userId, role_id: roleId },
+      where: {
+        user_id: userId,
+        role_id: roleId,
+        appcode,
+        level_id,
+        level_type,
+      },
+    });
+  }
+
+  async findByUSRId(usrId: number): Promise<UserRoleMapping | null> {
+    if (usrId) {
+      return null;
+    }
+
+    return await this.userRoleMappingRepository.findOne({
+      where: {
+        id: usrId,
+      },
     });
   }
 
@@ -61,4 +90,28 @@ export class UserRoleMappingRepository {
 
     return { appcode: appcodeArray };
   }
+  async findByUserIdAndAppCode(
+    userId: number,
+    appCode: string,
+  ): Promise<UserRoleMapping | null> {
+    return await this.userRoleMappingRepository.findOne({
+      where: { user_id: userId, appcode: appCode },
+    });
+  }
+
+  async findByUserIdAndAppCodeAndLevel(
+    userId: number,
+    appCode: string,
+    levelType: string,
+    levelId: string,
+  ): Promise<UserRoleMapping | null> {
+    return await this.userRoleMappingRepository.findOne({
+      where: {
+        user_id: userId,
+        appcode: appCode,
+        level_type: levelType,
+        level_id: levelId,
+      },
+    });
+  }
 }

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

@@ -8,7 +8,6 @@ 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 { instanceToPlain } from 'class-transformer';
 
 @Injectable()
 export class RoleService extends EntityServiceImpl {
@@ -28,15 +27,20 @@ export class RoleService extends EntityServiceImpl {
     appcode?: string,
   ): Promise<BaseEntity> {
     let role = entityData as Role;
-    if (appcode) {
-      role.appcode = appcode;
+
+    if (loggedInUser?.level_type && loggedInUser?.level_id) {
+      role.level_type = loggedInUser.level_type;
+      role.level_id = loggedInUser.level_id;
     }
+
     if (
-      await this.roleRepository.isRoleNameExists(role.name, {
-        organization_id: entityData.organization_id,
+      await this.roleRepository.isRoleNameWithLevelExists(role.name, {
+        organization_id: loggedInUser?.organization_id || undefined,
+        level_type: loggedInUser?.level_type,
+        level_id: parseInt(loggedInUser?.level_id || '', 10),
       })
     ) {
-      throw new BadRequestException('Role name already exists.');
+      throw new BadRequestException('Role code already exists.');
     }
 
     const sourceRole = role.copy_from_role_id

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

@@ -12,6 +12,9 @@ export class UserRoleMappingService {
     const existing = await this.userRoleMappingRepository.findByUserIdAndRoleId(
       userRoleMapping.user_id,
       userRoleMapping.role_id,
+      userRoleMapping.appcode,
+      userRoleMapping.level_id,
+      userRoleMapping.level_type,
     );
 
     if (!existing) {
@@ -19,6 +22,39 @@ export class UserRoleMappingService {
     }
   }
 
+  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);
   }
@@ -26,4 +62,28 @@ export class UserRoleMappingService {
   async deleteByUserId(userId: number) {
     await this.userRoleMappingRepository.deleteByUserId(userId);
   }
+
+  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,
+    );
+  }
 }

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

@@ -1,9 +1,11 @@
 import { UserSession } from '../entity/user-session.entity';
 import { ClockIDGenService } from '../../../utils/service/clockIDGenUtil.service';
-import { Injectable } from '@nestjs/common';
+import { BadRequestException, Injectable } from '@nestjs/common';
 import { UserSessionRepository } from '../repository/userSession.repository';
 import { JwtAuthService } from 'src/module/auth/services/jwt.service';
 import { ConfigService } from '@nestjs/config';
+import { UserRoleMappingService } from './user-role-mapping.service';
+import { DataSource } from 'typeorm';
 
 @Injectable()
 export class UserSessionService {
@@ -12,48 +14,51 @@ export class UserSessionService {
     private readonly jwtAuthService: JwtAuthService,
     private readonly clockIDGenService: ClockIDGenService,
     private configService: ConfigService,
+    private readonly userRoleMappingService: UserRoleMappingService,
+    private readonly dataSource: DataSource, // Assuming dataSource is injected for TypeORM operations
   ) {}
   async createSession(user, appcode?: string, accessInfo?: any) {
     const sessionToken = this.clockIDGenService.idGenerator('SES');
-  
+
     const userSession: any = new UserSession();
     userSession.user_id = user.id;
     userSession.session_key = sessionToken;
     userSession.is_session_loggedout = 0;
     userSession.login_time = new Date();
-  
+
     const expiryTokenInHours = this.configService.get('TOKEN_EXPIRY') || 1;
     userSession.expiry_date = new Date(
       Date.now() + expiryTokenInHours * 60 * 60 * 1000,
     );
-  
+
     await this.userSessionRepository.saveSession(userSession);
-  
+
     const payload: any = {
       userId: user.id,
       sessionToken,
       appcode,
       email_id: user.email_id,
+      level_type: user.level_type,
+      level_id: user.level_id,
       organization_id: user.organization_id,
       enterprise_id: user.enterprise_id,
     };
-  
+
     // ✅ Add role access details
     if (accessInfo) {
       payload.level_type = accessInfo.level_type;
       payload.level_id = accessInfo.level_id;
       payload.role_id = accessInfo.role_id;
-      payload.role_code = accessInfo.role_code; 
+      payload.role_code = accessInfo.role_code;
     }
-  
+
     const accessToken = this.jwtAuthService.generateJwt(payload);
-  
+
     userSession.access_token = accessToken;
     await this.userSessionRepository.saveSession(userSession);
-  
+
     return accessToken;
   }
-  
 
   async findBySessionKey(sessionKey: string): Promise<UserSession | null> {
     return await this.userSessionRepository.findBySessionKey(sessionKey);
@@ -62,4 +67,128 @@ export class UserSessionService {
   async updateSession(userSession: UserSession) {
     await this.userSessionRepository.saveSession(userSession);
   }
+
+  async switchCurrentLevelService(
+    userId: number,
+    currentUserLevelType: string,
+    currentUserLevelId: string,
+    currentUserOrgId: number,
+    data: any,
+  ): Promise<{ success: boolean; access_token: string; appcode: string }> {
+    let payload;
+
+    // Step 1: App-level access check
+    // if (data.appcode) {
+    //   console.log('in appcode check', data.appcode);
+
+    //   const userApp = await this.userRoleMappingService.getUserByIdAndAppCode(
+    //     userId,
+    //     data.appcode,
+    //   );
+
+    //   if (!userApp) {
+    //     throw new BadRequestException(
+    //       'User does not have access to this appcode',
+    //     );
+    //   }
+
+    payload = {
+      id: userId,
+      level_id: currentUserLevelId,
+      level_type: currentUserLevelType,
+      appcode: data.appcode,
+    };
+    // }
+
+    // Step 2: Level switch logic
+    // if (data.level_id && data.level_type) {
+    // console.log(
+    //   'in level_id and level_type check',
+    //   data.level_id,
+    //   data.level_type,
+    // );
+
+    // console.log(
+    //   'Current User Level Type:',
+    //   currentUserLevelType,
+    //   'Current User Level ID:',
+    //   currentUserLevelId,
+    // );
+
+    // const hasAccess = await this.dataSource.query(
+    //   'SELECT * FROM cr_user_role_mapping WHERE user_id = ? AND level_type = ? AND level_id = ? AND appcode = ?',
+    //   [userId, data.level_type, data.level_id, data.appcode || null],
+    // );
+
+    // console.log('Has Access:', hasAccess);
+
+    // // check if hasAccess is non-empty
+    // if (hasAccess.length) {
+    //   payload = {
+    //     id: userId,
+    //     level_id: data.level_id,
+    //     level_type: data.level_type,
+    //     appcode: data.appcode || null,
+    //   };
+    // }
+    // } else if (currentUserLevelType === 'ORG') {
+    //   const school = await this.dataSource.query(
+    //     'SELECT * FROM cr_school WHERE id = ?',
+    //     [data.level_id],
+    //   );
+
+    //   console.log('Current User Org ID:', currentUserOrgId);
+    //   console.log('Data Level Type:', data.level_type);
+    //   console.log('School:', school);
+
+    //   if (!school.length || currentUserOrgId !== school[0].organization_id) {
+    //     throw new BadRequestException(
+    //       'You do not have access to this school',
+    //     );
+    //   }
+
+    //   payload = {
+    //     id: userId,
+    //     level_id: data.level_id,
+    //     level_type: data.level_type,
+    //     appcode: data.appcode || null,
+    //   };
+    // } else if (currentUserLevelType === 'BRN') {
+    //   console.log('Current User Level Type is BRN');
+
+    //   const school = await this.dataSource.query(
+    //     'SELECT * FROM cr_school WHERE id = ?',
+    //     [data.level_id],
+    //   );
+
+    //   console.log('school:', school);
+
+    //   if (!school.length || school[0].brand_id !== currentUserLevelId) {
+    //     throw new BadRequestException(
+    //       'You do not have access to this school',
+    //     );
+    //   }
+
+    //   payload = {
+    //     id: userId,
+    //     level_id: data.level_id,
+    //     level_type: data.level_type,
+    //     appcode: data.appcode || null,
+    //   };
+    // }
+    // else {
+    //   throw new BadRequestException('You do not have access to this level');
+    // }
+    // }
+
+    // if (!payload) {
+    //   throw new BadRequestException('Invalid request parameters');
+    // }
+
+    return {
+      success: true,
+      access_token: this.jwtAuthService.generateJwt(payload),
+      appcode: data.appcode,
+    };
+  }
 }