rez_core 7.0.0 → 7.0.1

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

@@ -1,130 +0,0 @@
-import { level } from 'winston';
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { UserRoleMapping } from '../entity/user-role-mapping.entity';
-import { Repository } from 'typeorm';
-
-@Injectable()
-export class UserRoleMappingRepository {
-  constructor(
-    @InjectRepository(UserRoleMapping)
-    private readonly userRoleMappingRepository: Repository<UserRoleMapping>,
-  ) { }
-
-  async save(
-    userRoleMapping: UserRoleMapping,
-  ): Promise<UserRoleMapping | null> {
-    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 },
-    });
-  }
-
-  async getDefaultForUser(userId: number): Promise<UserRoleMapping | null> {
-    return await this.userRoleMappingRepository.findOne({
-      where: { user_id: userId, is_default: 1 },
-    });
-  }
-
-  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,
-        appcode,
-        level_id,
-        level_type,
-      },
-    });
-  }
-
-  async findByUSRId(usrId: number): Promise<UserRoleMapping | null> {
-    if (usrId) {
-      return null;
-    }
-
-    return await this.userRoleMappingRepository.findOne({
-      where: {
-        id: usrId,
-      },
-    });
-  }
-
-  async delete(userId: number, roleId: number) {
-    await this.userRoleMappingRepository.delete({
-      user_id: userId,
-      role_id: roleId,
-    });
-  }
-
-  async deleteByUserId(userId: number, levelType?: string, levelId?: string) {
-    if (levelType && levelId) {
-      await this.userRoleMappingRepository.delete({
-        user_id: userId,
-        level_type: levelType,
-        level_id: levelId,
-      });
-      return;
-    }
-    await this.userRoleMappingRepository.delete({ user_id: userId });
-  }
-
-  async findDistinctAppcodeByUserId(
-    userId: number,
-  ): Promise<{ appcode: string[] }> {
-    const result = await this.userRoleMappingRepository
-      .createQueryBuilder('urm')
-      .select('DISTINCT urm.appcode', 'appcode')
-      .where('urm.user_id = :userId', { userId })
-      .getRawMany();
-
-    const appcodeArray = result.map((row) => row.appcode);
-
-    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,
-      },
-    });
-  }
-
-  async find(options: any): Promise<UserRoleMapping[]> {
-    return await this.userRoleMappingRepository.find(options);
-  }
-}

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

@@ -1,77 +0,0 @@
-import { Repository } from 'typeorm';
-import { UserData } from '../entity/user.entity';
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-
-@Injectable()
-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,
-    enterprise_id?: number,
-    getLastApp?: boolean,
-  ): Promise<UserData | null> {
-    if (!email) return null;
-
-    const where: any = { email_id: email };
-
-    if (enterprise_id !== undefined) {
-      where.enterprise_id = enterprise_id;
-    }
-
-    const options: any = { where };
-
-    if (getLastApp) {
-      options.relations = {
-        last_app: true,
-      };
-    }
-
-    return this.userRepository.findOne(options);
-  }
-
-  async findByMobile(
-    mobile: string,
-    enterprise_id?: number,
-    appCode?: string,
-  ): Promise<UserData | null> {
-    if (!mobile) return null;
-
-    const where: any = { mobile };
-    if (enterprise_id !== undefined) {
-      where.enterprise_id = enterprise_id;
-    }
-    if (appCode !== undefined) {
-      where.appcode = appCode;
-    }
-
-    return this.userRepository.findOne({ where });
-  }
-
-  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

@@ -1,37 +0,0 @@
-import { Repository } from 'typeorm';
-import { UserSession } from '../entity/user-session.entity';
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-
-@Injectable()
-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 } });
-  }
-
-  async findActiveSessionByUserId(userId: number): Promise<UserSession | null> {
-    return this.userSessionRepo.findOne({
-      where: { user_id: userId, is_session_loggedout: 0 },
-    });
-  }
-
-  async saveSession(session: UserSession): Promise<UserSession> {
-    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 },
-      { is_session_loggedout: 1, logout_time: new Date() },
-    );
-  }
-}

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

@@ -1,322 +0,0 @@
-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 { Repository } from 'typeorm';
-import { EncryptUtilService } from '../../../utils/service/encryptUtil.service';
-import { UserRoleMapping } from '../entity/user-role-mapping.entity';
-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 {
-  constructor(
-    @Inject('UserService') private readonly userService: UserService,
-    private userSessionService: UserSessionService,
-    private configService: ConfigService,
-    @InjectRepository(UserRoleMapping)
-    private readonly userRoleMappingRepository: Repository<UserRoleMapping>,
-    private readonly enterpriseRepository: EnterpriseRepository,
-    private readonly jwtAuthService: JwtAuthService,
-    private readonly reflectionHelper: ReflectionHelper,
-  ) {
-  }
-
-  masterKey: string = this.configService.get('MASTER_KEY') || '';
-  masterIv: string = this.configService.get('MASTER_IV') || '';
-
-  async login(data: {
-    email_id: string;
-    password?: string;
-    is_otp?: boolean;
-    subdomain?: string;
-  }): Promise<any> {
-    const { email_id, password, is_otp = false, subdomain } = data;
-
-    let enterprise;
-
-    if (subdomain) {
-      enterprise =
-        await this.enterpriseRepository.findEnterpriseBySubdomain(
-          subdomain,
-        );
-
-      if (!enterprise) {
-        return {
-          success: false,
-          message: 'Enterprise not found.',
-        };
-      }
-    }
-
-    // 🔹 Step 2: Find the user by email + enterprise check
-    const user = await this.userService.findByEmailId(
-      email_id,
-      enterprise?.id,
-      true
-    );
-
-    if (!user || (enterprise && user.enterprise_id !== enterprise.id)) {
-      return {
-        success: false,
-        message: 'User not found in Enterprise.',
-      };
-    }
-
-    // 🔹 Step 3: Verify org status
-    const userOrgData = await this.enterpriseRepository.findById(
-      user.enterprise_id,
-    );
-
-    if (
-      user.status != StatusConstant.ACTIVE ||
-      userOrgData?.status != StatusConstant.ACTIVE
-    ) {
-      return {
-        success: false,
-        message:
-          'Your account or Enterprise is inactive. Please contact admin.',
-      };
-    }
-
-    // 🔹 Step 4: Verify password if not OTP
-    if (!is_otp) {
-      const encryptedPassword = EncryptUtilService.encryptGCM(
-        password,
-        this.masterKey,
-        this.masterIv,
-      );
-
-      if (encryptedPassword !== user.password) {
-        return {
-          success: false,
-          message: 'Oops! Your password is incorrect.',
-          type: 'password',
-        };
-      }
-    }
-
-    // 🔹 Step 5: App access check
-    let app_id = user.last_app_access_id;
-
-    if (!user.last_app_access_id) {
-      await this.userService.setDefaultLastAccess(user.id, app_id);
-    }
-
-    const whereCondition: any = { user_id: user.id };
-
-    if (app_id) {
-      whereCondition.app_id = app_id;
-    }
-
-    const roleMappings = await this.userRoleMappingRepository.find({
-      where: whereCondition,
-      relations: {
-        app: true
-      }
-    });
-
-    if (!roleMappings.length) {
-      return {
-        success: false,
-        message: 'You do not have access to this application.',
-      };
-    }
-
-    // 🔹 Step 6: Resolve default access
-    const defaultAccess = await this.getDefaultAccess(user, roleMappings);
-
-    await this.userService.setLastLevelTypeAndId(
-      user.id,
-      defaultAccess.level_type,
-      defaultAccess.level_id,
-      defaultAccess.app_id,
-    );
-
-    const token = await this.userSessionService.createSession(
-      user,
-      defaultAccess.app_id,
-      defaultAccess,
-      defaultAccess.appcode
-    );
-
-    // 🔹 Step 7: Update first login + invitation status
-
-    if (user.is_firstlogin === 1) {
-      user.invitation_status = INVITATION_STATUS_ACCEPTED;
-      user.is_firstlogin = 0;
-      const { password, ...userWithoutPassword } = user;
-      await this.userService.updateUser(user.id, userWithoutPassword, user);
-    }
-
-    // 🔹 Step 8: Return response
-
-    const org = await this.enterpriseRepository.findById(
-      user.enterprise_id,
-    );
-    let slug: string;
-    if (org) {
-      slug = org.slug;
-    } else {
-      return {
-        success: false,
-        message: 'Enterprise not found for the user.',
-      };
-    }
-
-    return {
-      success: true,
-      accessToken: token,
-      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_id } = body;
-
-      const leadRepo = this.reflectionHelper.getRepoService('CRMLead');
-      const entityData = await leadRepo.findOne({
-        where: { id: entity_id },
-      });
-
-      if (entityData) {
-        const level_id = entityData.level_id;
-        const level_type = entityData.level_type;
-        const enterprise_id = entityData.enterprise_id;
-
-        const token = this.jwtAuthService.generateJwt({
-          level_id: level_id,
-          level_type: level_type,
-          enterprise_id: enterprise_id,
-        });
-
-        return {
-          success: true,
-          accessToken: token,
-        };
-      }
-    }
-  }
-
-  private async getDefaultAccess(
-    user: any,
-    roleMappings: any[],
-  ): 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');
-
-    let validURM;
-
-    validURM = roleMappings.some(
-      (r) => r.level_type == 'ORG' && r.level_id == user.enterprise_id,
-    );
-
-    if (!validURM) {
-      validURM = roleMappings.some(
-        (r) =>
-          r.level_type === user.last_level_type &&
-          r.level_id === user.last_level_id,
-      );
-    }
-
-    if (user.last_level_type && user.last_level_id && validURM) {
-      return {
-        level_type: user.last_level_type,
-        level_id: user.last_level_id,
-        app_id: user.last_app_access_id,
-        appcode: user.last_app.code
-      };
-    }
-
-    if (orgAccess) {
-      return {
-        level_type: 'ORG',
-        level_id: orgAccess.level_id,
-        app_id: orgAccess.app_id,
-        appcode: orgAccess.app.code
-      };
-    }
-
-    if (brnAccesses.length) {
-      const brandId = brnAccesses[0].level_id;
-
-      const schoolRepo = this.reflectionHelper.getRepoService('SSOSchool');
-
-      const rows = await schoolRepo.findOne({
-        where: {
-          brand_id: brandId,
-        },
-        order: {
-          id: 'ASC',
-        },
-      });
-
-      if (rows.length) {
-        return {
-          level_type: 'SCH',
-          level_id: rows.id,
-          app_id: brnAccesses[0].app_id,
-        };
-      } else {
-        throw new BadRequestException(
-          'User has BRN access but no schools found under that brand.',
-        );
-      }
-    }
-
-    if (schAccesses.length) {
-      return {
-        level_type: 'SCH',
-        level_id: schAccesses[0].level_id,
-        app_id: schAccesses[0].app_id,
-      };
-    }
-
-    throw new BadRequestException(
-      'User does not have ORG, BRN, or SCH access for this app.',
-    );
-  }
-
-  async loginWithGoogle(data: {
-    email: string;
-    subdomain?: string;
-    fcm_token?: string;
-    ip?: string;
-    browser?: string;
-    os?: string;
-  }) {
-    const { email } = data;
-    const user = await this.userService.findByEmailId(email);
-
-    if (!user) {
-      return new BadRequestException('User not found');
-    }
-
-    // Create session (Same as JWT login flow)
-    return await this.login({
-      email_id: email,
-      is_otp: true,
-    });
-  }
-
-  async logout(sessionKey: string) {
-    const userSession =
-      await this.userSessionService.findBySessionKey(sessionKey);
-    if (userSession) {
-      userSession.is_session_loggedout = 1;
-      userSession.logout_time = new Date();
-      await this.userSessionService.updateSession(userSession);
-      return { message: 'Logged out successfully' };
-    }
-  }
-}