rez_core 6.5.50 → 6.5.52

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

@@ -8,7 +8,7 @@ export class RoleRepository {
   constructor(
     @InjectRepository(Role)
     private readonly roleRepo: Repository<Role>,
-  ) {}
+  ) { }
 
   async findByCode(code: string): Promise<Role | null> {
     return this.roleRepo.findOne({ where: { code } });
@@ -16,7 +16,7 @@ export class RoleRepository {
 
   public async isRoleNameExists(
     name: string,
-    options?: { excludeRoleId?: number; organization_id?: number },
+    options?: { excludeRoleId?: number; enterprise_id?: number },
   ): Promise<boolean> {
     const query = this.roleRepo
       .createQueryBuilder('role')
@@ -28,9 +28,9 @@ export class RoleRepository {
       });
     }
 
-    if (options?.organization_id !== undefined) {
-      query.andWhere('role.organization_id = :organization_id', {
-        organization_id: options.organization_id,
+    if (options?.enterprise_id !== undefined) {
+      query.andWhere('role.enterprise_id = :enterprise_id', {
+        enterprise_id: options.enterprise_id,
       });
     }
 
@@ -53,11 +53,12 @@ export class RoleRepository {
    * Confirm level_type and level_id correspond to existing org/school.
     */
 
+
   public async isRoleNameWithLevelExists(
     name: string,
     options?: {
       excludeRoleId?: number;
-      organization_id?: number;
+      enterprise_id?: number;
       level_type?: string;
       level_id?: number;
     },
@@ -72,12 +73,6 @@ export class RoleRepository {
       });
     }
 
-    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,
@@ -93,4 +88,29 @@ export class RoleRepository {
     const existingRole = await query.getOne();
     return !!existingRole;
   }
+
+  async findById(id: number) {
+    return this.roleRepo.findOne({ where: { id } });
+  }
+
+  async findMaxIdRecord() {
+    return await this.roleRepo.findOne({
+      order: { id: 'DESC' },
+      where: {},
+      select: ['id']
+    });
+  }
+
+  async saveRole(role: Role) {
+    let entity = this.roleRepo.create(role);
+    return await this.roleRepo.save(entity);
+  }
+
+  async updateRole(id: number, role: Role) {
+    return await this.roleRepo.update(id, role);
+  }
+
+  async findRoles(options: any): Promise<Role[]> {
+    return await this.roleRepo.find(options);
+  }
 }

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

@@ -9,7 +9,7 @@ export class UserRoleMappingRepository {
   constructor(
     @InjectRepository(UserRoleMapping)
     private readonly userRoleMappingRepository: Repository<UserRoleMapping>,
-  ) {}
+  ) { }
 
   async save(
     userRoleMapping: UserRoleMapping,
@@ -123,4 +123,8 @@ export class UserRoleMappingRepository {
       },
     });
   }
+
+  async find(options: any): Promise<UserRoleMapping[]> {
+    return await this.userRoleMappingRepository.find(options);
+  }
 }

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

@@ -1,4 +1,3 @@
-import { OrganizationData } from './../../enterprise/entity/organization.entity';
 import { Repository } from 'typeorm';
 import { UserData } from '../entity/user.entity';
 import { Injectable } from '@nestjs/common';
@@ -8,34 +7,46 @@ import { InjectRepository } from '@nestjs/typeorm';
 export class UserRepository {
   constructor(
     @InjectRepository(UserData) private userRepository: Repository<UserData>,
-  ) {}
+  ) { }
 
   async findById(userId: number): Promise<UserData | null> {
     return this.userRepository.findOne({ where: { id: userId } });
   }
+
   async findByEmailId(
     email: string,
-    organization_id?: number,
+    enterprise_id?: number,
+    getLastApp?: boolean,
   ): Promise<UserData | null> {
     if (!email) return null;
 
     const where: any = { email_id: email };
-    if (organization_id !== undefined) {
-      where.organization_id = organization_id;
+
+    if (enterprise_id !== undefined) {
+      where.enterprise_id = enterprise_id;
     }
-    return this.userRepository.findOne({ where });
+
+    const options: any = { where };
+
+    if (getLastApp) {
+      options.relations = {
+        last_app: true,
+      };
+    }
+
+    return this.userRepository.findOne(options);
   }
 
   async findByMobile(
     mobile: string,
-    organization_id?: number,
+    enterprise_id?: number,
     appCode?: string,
   ): Promise<UserData | null> {
     if (!mobile) return null;
 
     const where: any = { mobile };
-    if (organization_id !== undefined) {
-      where.organization_id = organization_id;
+    if (enterprise_id !== undefined) {
+      where.enterprise_id = enterprise_id;
     }
     if (appCode !== undefined) {
       where.appcode = appCode;
@@ -47,4 +58,20 @@ export class UserRepository {
   async saveUser(user: UserData): Promise<UserData> {
     return this.userRepository.save(user);
   }
+
+  async updateUser(id: number, user: UserData) {
+    return await this.userRepository.update(id, user);
+  }
+
+  async find(options: any): Promise<UserData[]> {
+    return await this.userRepository.find(options);
+  }
+
+  async findMaxIdRecord() {
+    return await this.userRepository.findOne({
+      order: { id: 'DESC' },
+      select: ['id'],
+      where:{}
+    });
+  }
 }

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

@@ -8,7 +8,7 @@ export class UserSessionRepository {
   constructor(
     @InjectRepository(UserSession)
     private userSessionRepo: Repository<UserSession>,
-  ) {}
+  ) { }
 
   async findBySessionKey(sessionKey: string): Promise<UserSession | null> {
     return this.userSessionRepo.findOne({ where: { session_key: sessionKey } });
@@ -24,6 +24,10 @@ export class UserSessionRepository {
     return this.userSessionRepo.save(session);
   }
 
+  async fetchUserFcmToken(user_id: number) {
+    return await this.userSessionRepo.findOne({ where: { user_id }, select: ['fcm_token'], order: { login_time: 'DESC' } });
+  }
+
   async logoutSession(sessionKey: string): Promise<void> {
     await this.userSessionRepo.update(
       { session_key: sessionKey },

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

@@ -2,8 +2,6 @@ import { BadRequestException, Inject, Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { InjectRepository } from '@nestjs/typeorm';
 import { INVITATION_STATUS_ACCEPTED, STATUS_ACTIVE } from 'src/constant/global.constant';
-import { OrganizationRepository } from 'src/module/enterprise/repository/organization.repository';
-import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
 import { Repository } from 'typeorm';
 import { EncryptUtilService } from '../../../utils/service/encryptUtil.service';
 import { UserRoleMapping } from '../entity/user-role-mapping.entity';
@@ -11,6 +9,8 @@ import { UserSessionService } from './user-session.service';
 import { UserService } from './user.service';
 import { JwtAuthService } from 'src/module/auth/services/jwt.service';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
+import { EnterpriseRepository } from 'src/module/enterprise/repository/enterprise.repository';
+import { StatusConstant } from '../../../constant/status.constant';
 
 @Injectable()
 export class LoginService {
@@ -20,9 +20,7 @@ export class LoginService {
     private configService: ConfigService,
     @InjectRepository(UserRoleMapping)
     private readonly userRoleMappingRepository: Repository<UserRoleMapping>,
-    private readonly organizationRepository: OrganizationRepository,
-    @Inject('ListMasterService')
-    private readonly listMasterService: ListMasterService,
+    private readonly enterpriseRepository: EnterpriseRepository,
     private readonly jwtAuthService: JwtAuthService,
     private readonly reflectionHelper: ReflectionHelper,
   ) {
@@ -39,53 +37,49 @@ export class LoginService {
   }): Promise<any> {
     const { email_id, password, is_otp = false, subdomain } = data;
 
-    let organization;
+    let enterprise;
 
     if (subdomain) {
-      organization =
-        await this.organizationRepository.findOrganizationBySubdomain(
+      enterprise =
+        await this.enterpriseRepository.findEnterpriseBySubdomain(
           subdomain,
         );
 
-      if (!organization) {
+      if (!enterprise) {
         return {
           success: false,
-          message: 'Organization not found.',
+          message: 'Enterprise not found.',
         };
       }
     }
 
-    // 🔹 Step 2: Find the user by email + organization check
+    // 🔹 Step 2: Find the user by email + enterprise check
     const user = await this.userService.findByEmailId(
       email_id,
-      organization?.id,
+      enterprise?.id,
+      true
     );
 
-    if (!user || (organization && user.organization_id !== organization.id)) {
+    if (!user || (enterprise && user.enterprise_id !== enterprise.id)) {
       return {
         success: false,
-        message: 'User not found in organization.',
+        message: 'User not found in Enterprise.',
       };
     }
 
     // 🔹 Step 3: Verify org status
-    const userOrgData = await this.organizationRepository.findOrganizationById(
-      user.organization_id,
-    );
-
-    const resolveStatus = await this.listMasterService.getResolvedListCode(
-      STATUS_ACTIVE,
-      user?.organization_id || 0,
+    const userOrgData = await this.enterpriseRepository.findById(
+      user.enterprise_id,
     );
 
     if (
-      user.status != resolveStatus.id ||
-      userOrgData?.status != resolveStatus.id
+      user.status != StatusConstant.ACTIVE ||
+      userOrgData?.status != StatusConstant.ACTIVE
     ) {
       return {
         success: false,
         message:
-          'Your account or organization is inactive. Please contact admin.',
+          'Your account or Enterprise is inactive. Please contact admin.',
       };
     }
 
@@ -107,20 +101,23 @@ export class LoginService {
     }
 
     // 🔹 Step 5: App access check
-    let appcode = user.last_app_access;
+    let app_id = user.last_app_access_id;
 
-    if (!user.last_app_access || user.last_app_access == '') {
-      await this.userService.setDefaultLastAccess(user.id, appcode);
+    if (!user.last_app_access_id) {
+      await this.userService.setDefaultLastAccess(user.id, app_id);
     }
 
     const whereCondition: any = { user_id: user.id };
 
-    if (appcode && appcode !== '') {
-      whereCondition.appcode = appcode;
+    if (app_id) {
+      whereCondition.app_id = app_id;
     }
 
     const roleMappings = await this.userRoleMappingRepository.find({
       where: whereCondition,
+      relations: {
+        app: true
+      }
     });
 
     if (!roleMappings.length) {
@@ -137,33 +134,29 @@ export class LoginService {
       user.id,
       defaultAccess.level_type,
       defaultAccess.level_id,
-      defaultAccess.appcode,
+      defaultAccess.app_id,
     );
 
     const token = await this.userSessionService.createSession(
       user,
-      defaultAccess.appcode,
+      defaultAccess.app_id,
       defaultAccess,
+      defaultAccess.appcode
     );
 
     // 🔹 Step 7: Update first login + invitation status
-    const resolvedInvitationStatus =
-      await this.listMasterService.getResolvedListCode(
-        INVITATION_STATUS_ACCEPTED,
-        user?.organization_id || 0,
-      );
 
     if (user.is_firstlogin === 1) {
-      user.invitation_status = resolvedInvitationStatus.id;
+      user.invitation_status = INVITATION_STATUS_ACCEPTED;
       user.is_firstlogin = 0;
       const { password, ...userWithoutPassword } = user;
-      await this.userService.updateEntity(userWithoutPassword, user);
+      await this.userService.updateUser(user.id, userWithoutPassword, user);
     }
 
     // 🔹 Step 8: Return response
 
-    const org = await this.organizationRepository.findOrganizationById(
-      user.organization_id,
+    const org = await this.enterpriseRepository.findById(
+      user.enterprise_id,
     );
     let slug: string;
     if (org) {
@@ -171,23 +164,24 @@ export class LoginService {
     } else {
       return {
         success: false,
-        message: 'Organization not found for the user.',
+        message: 'Enterprise not found for the user.',
       };
     }
 
     return {
       success: true,
       accessToken: token,
-      appcode: defaultAccess.appcode,
+      app_id: defaultAccess.app_id,
       level_type: defaultAccess.level_type,
       level_id: defaultAccess.level_id,
       slug: slug,
+      appcode: defaultAccess.appcode
     };
   }
 
   async formLogin(body: any): Promise<any> {
     if (body) {
-      const { entity_type, entity_id } = body;
+      const { entity_id } = body;
 
       const leadRepo = this.reflectionHelper.getRepoService('CRMLead');
       const entityData = await leadRepo.findOne({
@@ -197,12 +191,12 @@ export class LoginService {
       if (entityData) {
         const level_id = entityData.level_id;
         const level_type = entityData.level_type;
-        const organization_id = entityData.organization_id;
+        const enterprise_id = entityData.enterprise_id;
 
         const token = this.jwtAuthService.generateJwt({
           level_id: level_id,
           level_type: level_type,
-          organization_id: organization_id,
+          enterprise_id: enterprise_id,
         });
 
         return {
@@ -216,7 +210,7 @@ export class LoginService {
   private async getDefaultAccess(
     user: any,
     roleMappings: any[],
-  ): Promise<{ level_type: string; level_id: string; appcode: string }> {
+  ): Promise<{ level_type: string; level_id: string; app_id: number; appcode?:string }> {
     const orgAccess = roleMappings.find((r) => r.level_type === 'ORG');
     const brnAccesses = roleMappings.filter((r) => r.level_type === 'BRN');
     const schAccesses = roleMappings.filter((r) => r.level_type === 'SCH');
@@ -224,7 +218,7 @@ export class LoginService {
     let validURM;
 
     validURM = roleMappings.some(
-      (r) => r.level_type == 'ORG' && r.level_id == user.organization_id,
+      (r) => r.level_type == 'ORG' && r.level_id == user.enterprise_id,
     );
 
     if (!validURM) {
@@ -239,7 +233,8 @@ export class LoginService {
       return {
         level_type: user.last_level_type,
         level_id: user.last_level_id,
-        appcode: user.last_app_access,
+        app_id: user.last_app_access_id,
+        appcode: user.last_app.code
       };
     }
 
@@ -247,7 +242,8 @@ export class LoginService {
       return {
         level_type: 'ORG',
         level_id: orgAccess.level_id,
-        appcode: orgAccess.appcode,
+        app_id: orgAccess.app_id,
+        appcode: orgAccess.app.code
       };
     }
 
@@ -269,7 +265,7 @@ export class LoginService {
         return {
           level_type: 'SCH',
           level_id: rows.id,
-          appcode: brnAccesses[0].appcode,
+          app_id: brnAccesses[0].app_id,
         };
       } else {
         throw new BadRequestException(
@@ -282,7 +278,7 @@ export class LoginService {
       return {
         level_type: 'SCH',
         level_id: schAccesses[0].level_id,
-        appcode: schAccesses[0].appcode,
+        app_id: schAccesses[0].app_id,
       };
     }