rez_core 2.0.45 → 2.0.47

package/package.json

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

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

@@ -27,8 +27,6 @@ export class OrganizationController {
     const userId = req.user.userData?.id;
     const appcode = req.user.userData?.appcode;
 
-    console.log(userId, appcode, 'userId, appcode');
-
     return await this.orgService.getOrganizationHierarchy(userId, appcode);
   }
 }

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

@@ -35,7 +35,6 @@ export class SchoolRepository {
       .andWhere('urm.level_type = :levelType', { levelType: 'ORG' })
       .getRawMany();
 
-    console.log(hasOrgAccess);
     if (hasOrgAccess.length > 0) {
       // Return nested Org -> Brand -> School structure
       const schools = await this.dataSource
@@ -74,6 +73,7 @@ export class SchoolRepository {
             org_id,
             org_name,
             org_address,
+            type: 'Organization',
             brands: {},
           };
         }
@@ -81,6 +81,7 @@ export class SchoolRepository {
           result[org_id].brands[brand_id] = {
             brand_id,
             brand_name,
+            type: 'Brand',
             schools: [],
           };
         }
@@ -88,6 +89,7 @@ export class SchoolRepository {
           school_id,
           school_name,
           school_location,
+          type: 'School',
         });
       }
 
@@ -149,6 +151,7 @@ export class SchoolRepository {
           result[brand_id] = {
             brand_id,
             brand_name,
+            type: 'Brand',
             schools: [],
           };
         }
@@ -162,6 +165,7 @@ export class SchoolRepository {
             school_id,
             school_name,
             school_location,
+            type: 'School',
           });
         }
       }

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

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

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

@@ -9,34 +9,44 @@ import { UserData } from '../entity/user.entity';
 export class RoleRepository {
   constructor(
     @InjectRepository(Role)
-    private readonly roleRepo: Repository<Role>
+    private readonly roleRepo: Repository<Role>,
   ) {}
 
   async findByCode(code: string): Promise<Role | null> {
     return this.roleRepo.findOne({ where: { code } });
   }
 
-
   public async isRoleNameExists(
     name: string,
-    options?: { excludeRoleId?: number; organization_id?: number }
+    options?: { excludeRoleId?: number; organization_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 });
+      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;
   }
-  
+
+  async find(data): Promise<Role[] | null> {
+    return this.roleRepo.find({
+      where: {
+        ...(data.is_factory !== undefined && { is_factory: data.is_factory }),
+        ...(data.level_id !== undefined && { level_id: data.level_id }),
+        ...(data.level_type !== undefined && { level_type: data.level_type }),
+      },
+    });
+  }
 }

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

@@ -28,10 +28,14 @@ export class RoleService extends EntityServiceImpl {
     appcode?: string,
   ): Promise<BaseEntity> {
     let role = entityData as Role;
-    if(appcode){
-      role.appcode = appcode ;
+    if (appcode) {
+      role.appcode = appcode;
     }
-    if (await this.roleRepository.isRoleNameExists(role.name,{organization_id:entityData.organization_id})) {
+    if (
+      await this.roleRepository.isRoleNameExists(role.name, {
+        organization_id: entityData.organization_id,
+      })
+    ) {
       throw new BadRequestException('Role name already exists.');
     }
 
@@ -102,13 +106,16 @@ export class RoleService extends EntityServiceImpl {
     }
 
     if (
-      await this.roleRepository.isRoleNameExists(entityData.name, {excludeRoleId:entityData.id,organization_id:loggedInUser?.organization_id})
+      await this.roleRepository.isRoleNameExists(entityData.name, {
+        excludeRoleId: entityData.id,
+        organization_id: loggedInUser?.organization_id,
+      })
     ) {
       throw new BadRequestException('Role name already exists.');
     }
 
-  const {copy_from_role_id, ...persistableData} = role;
-  const updatedRole = await super.updateEntity(persistableData, loggedInUser);
+    const { copy_from_role_id, ...persistableData } = role;
+    const updatedRole = await super.updateEntity(persistableData, loggedInUser);
 
     if (role.copy_from_role_id) {
       const sourceRole = await this.getEntityData(
@@ -140,4 +147,12 @@ export class RoleService extends EntityServiceImpl {
     }
     return updatedRole;
   }
+
+  async getDefaultRole(data: {
+    is_factory?: boolean;
+    level_id?: number;
+    level_type?: string;
+  }): Promise<Role[] | null> {
+    return await this.roleRepository.find(data);
+  }
 }

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

@@ -13,36 +13,47 @@ export class UserSessionService {
     private readonly clockIDGenService: ClockIDGenService,
     private configService: ConfigService,
   ) {}
-  async createSession(user, appcode?: string) {
+  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 = {
+  
+    const payload: any = {
       userId: user.id,
       sessionToken,
-      appcode: appcode,
+      appcode,
       email_id: user.email_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; 
+    }
+  
     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);