rez_core 2.0.46 → 2.0.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.0.46",
+  "version": "2.0.48",
   "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/enterprise/entity/brand.entity.ts

@@ -1,5 +1,8 @@
 import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
-import { Entity } from 'typeorm';
+import { Column, Entity } from 'typeorm';
 
 @Entity({ name: 'cr_brand' })
-export class BrandData extends BaseEntity {}
+export class BrandData extends BaseEntity {
+  @Column({ name: 'type', nullable: true })
+  type: string;
+}

package/src/module/enterprise/entity/organization.entity.ts

@@ -80,4 +80,7 @@ export class OrganizationData {
 
   @Column({ name: 'is_brand', type: 'boolean', nullable: true })
   is_brand: boolean;
+
+  @Column({ name: 'type', nullable: true })
+  type: string;
 }

package/src/module/enterprise/entity/school.entity.ts

@@ -11,4 +11,7 @@ export class SchoolData extends BaseEntity {
 
   @Column({ name: 'location', nullable: true })
   location: string;
+
+  @Column({ name: 'type', nullable: true })
+  type: string;
 }

package/src/module/enterprise/repository/school.repository.ts

@@ -73,6 +73,7 @@ export class SchoolRepository {
             org_id,
             org_name,
             org_address,
+            type: 'Organization',
             brands: {},
           };
         }
@@ -80,6 +81,7 @@ export class SchoolRepository {
           result[org_id].brands[brand_id] = {
             brand_id,
             brand_name,
+            type: 'Brand',
             schools: [],
           };
         }
@@ -87,6 +89,7 @@ export class SchoolRepository {
           school_id,
           school_name,
           school_location,
+          type: 'School',
         });
       }
 
@@ -148,6 +151,7 @@ export class SchoolRepository {
           result[brand_id] = {
             brand_id,
             brand_name,
+            type: 'Brand',
             schools: [],
           };
         }
@@ -161,6 +165,7 @@ export class SchoolRepository {
             school_id,
             school_name,
             school_location,
+            type: 'School',
           });
         }
       }

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) {
@@ -30,7 +35,7 @@ export class LoginController {
     @Req() request: Request & { user: any },
     @Res() response: Response,
   ) {
-    let requestUser: any = request.user;
+    let requestUser: any = request.user.userData;
     response
       .status(HttpStatus.OK)
       .json(await this.loginService.logout(requestUser.sessionToken));
@@ -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/login.service.ts

@@ -5,6 +5,11 @@ import { UserSessionService } from './user-session.service';
 import { UserService } from './user.service';
 import { ConfigService } from '@nestjs/config';
 import { UserAppMappingService } from 'src/module/meta/service/user-app-mapping.service';
+import { UserRoleMappingRepository } from '../repository/user-role-mapping.repository';
+import { InjectRepository } from '@nestjs/typeorm';
+import { UserRoleMapping } from '../entity/user-role-mapping.entity';
+import { Repository } from 'typeorm';
+import { Role } from '../entity/role.entity';
 
 @Injectable()
 export class LoginService {
@@ -12,7 +17,10 @@ export class LoginService {
     @Inject('UserService') private readonly userService: UserService,
     private userSessionService: UserSessionService,
     private configService: ConfigService,
-    private readonly userAppMappingService: UserAppMappingService,
+    @InjectRepository(UserRoleMapping)
+       private readonly userRoleMappingRepository: Repository<UserRoleMapping>,
+          @InjectRepository(Role)
+           private readonly roleRepo: Repository<Role>,
   ) {}
 
   masterKey: string = this.configService.get('MASTER_KEY') || '';
@@ -20,27 +28,15 @@ export class LoginService {
 
   async login(email: string, password: string, appcode: string) {
     const user = await this.userService.findByEmailId(email);
-
+  
     if (!user) {
       return {
         success: false,
-        message: 'Your Email ID not registered.',
+        message: 'Your Email ID is not registered.',
         type: 'email',
       };
     }
-
-    const userAppMapping = await this.userAppMappingService.getUserAppMappings(
-      user.id,
-      appcode,
-    );
-
-    if (!userAppMapping) {
-      // If user is not mapped to the app, throw an error
-      throw new BadRequestException(
-        `User with email ${email} is not mapped to the app ${appcode}.`,
-      );
-    }
-
+  
     if (user.status !== 'ACTIVE') {
       return {
         success: false,
@@ -48,13 +44,9 @@ export class LoginService {
         type: 'email',
       };
     }
-
-    const encryptedPassword = EncryptUtilService.encryptGCM(
-      password,
-      this.masterKey,
-      this.masterIv,
-    );
-
+  
+    const encryptedPassword = EncryptUtilService.encryptGCM(password, this.masterKey, this.masterIv);
+  
     if (encryptedPassword !== user.password) {
       return {
         success: false,
@@ -62,23 +54,50 @@ export class LoginService {
         type: 'password',
       };
     }
-
-    const token = await this.userSessionService.createSession(user, appcode);
-
+  
+    // ✅ Get user-role mappings for this app
+    const roleMappings = await this.userRoleMappingRepository.find({
+      where: {
+        user_id: user.id,
+        appcode: appcode,
+      },
+    });
+  
+    if (!roleMappings.length) {
+      throw new BadRequestException('User does not have any access mapped for this app.');
+    }
+  
+    // ✅ Pick default access based on priority
+    const priority = { org: 1, sch: 2, brn: 3 };
+    const defaultAccess = roleMappings.sort(
+      (a, b) => priority[a.level_type] - priority[b.level_type],
+    )[0];
+  
+    // ✅ Manually fetch role_code from cr_role table
+    const role = await this.roleRepo.findOne({
+      where: { id: defaultAccess.role_id },
+    });
+  
+    const token = await this.userSessionService.createSession(user, appcode, {
+      level_type: defaultAccess.level_type,
+      level_id: defaultAccess.level_id,
+      role_id: defaultAccess.role_id,
+      role_code: role?.code || null, // fallback if role not found
+    });
+  
     if (user.is_firstlogin === 1) {
       user.invitation_status = 'ACCEPTED';
       user.is_firstlogin = 0;
-
       const { password, ...userWithoutPassword } = user;
-
       await this.userService.updateEntity(userWithoutPassword, user);
     }
-
+  
     return {
       success: true,
       accessToken: token,
     };
   }
+  
 
   async loginWithGoogle(email: string, name) {
     let user = await this.userService.findByEmailId(email);

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,
+    );
+  }
 }