rez_core 5.0.58 → 5.0.59

package/src/module/auth/guards/jwt.guard.ts

@@ -1,22 +1,22 @@
-import { ExecutionContext, Injectable } from '@nestjs/common';
-import { AuthGuard } from '@nestjs/passport';
-import { Reflector } from '@nestjs/core';
-import { Observable } from 'rxjs';
-
-@Injectable()
-export class JwtAuthGuard extends AuthGuard('jwt') {
-  constructor(private reflector: Reflector) {
-    super();
-  }
-
-  canActivate(
-    context: ExecutionContext,
-  ): Promise<boolean> | boolean | Observable<boolean> {
-    const isPublic = this.reflector.getAllAndOverride('isPublic', [
-      context.getHandler(),
-      context.getClass(),
-    ]);
-    if (isPublic) return true;
-    return super.canActivate(context);
-  }
-}
+import { ExecutionContext, Injectable } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+import { Reflector } from '@nestjs/core';
+import { Observable } from 'rxjs';
+
+@Injectable()
+export class JwtAuthGuard extends AuthGuard('jwt') {
+  constructor(private reflector: Reflector) {
+    super();
+  }
+
+  canActivate(
+    context: ExecutionContext,
+  ): Promise<boolean> | boolean | Observable<boolean> {
+    const isPublic = this.reflector.getAllAndOverride('isPublic', [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+    if (isPublic) return true;
+    return super.canActivate(context);
+  }
+}

package/src/module/auth/guards/role.guard.ts

@@ -1,68 +1,68 @@
-import {
-  CanActivate,
-  ExecutionContext,
-  ForbiddenException,
-  Injectable,
-  UnauthorizedException,
-} from '@nestjs/common';
-import { Reflector } from '@nestjs/core';
-import { UserData } from '../../user/entity/user.entity';
-import { InjectEntityManager } from '@nestjs/typeorm';
-import { EntityManager } from 'typeorm';
-
-@Injectable()
-export class RolesGuard implements CanActivate {
-  constructor(
-    private reflector: Reflector,
-    @InjectEntityManager() private entityManager: EntityManager,
-  ) {}
-
-  async canActivate(context: ExecutionContext) {
-    const request = context
-      .switchToHttp()
-      .getRequest<Request & { user: any }>();
-    const object = request.user;
-
-    const users: UserData = await this.entityManager.query(
-      `SELECT * FROM sso_user WHERE id = ${object.userId} LIMIT 1`,
-    );
-
-    const user = users[0];
-    if (!user || !user['role_id']) {
-      throw new UnauthorizedException('User not authorized');
-    }
-
-    const requiredModule = this.reflector.get<string>(
-      'moduleCode',
-      context.getHandler(),
-    );
-    const requiredActions = this.reflector.get<string>(
-      'actions',
-      context.getHandler(),
-    );
-
-    const roleAccess = await this.entityManager.query(
-      `SELECT *
-             FROM sso_module_access
-             WHERE role_id = ${user['role_id']}
-               AND module_code = '${requiredModule}'`,
-    );
-
-    if (!roleAccess || roleAccess.length === 0) {
-      throw new ForbiddenException(
-        'Access denied: No permissions found for this module',
-      );
-    }
-
-    const hasAccess = roleAccess.some(
-      (access) =>
-        requiredActions.includes(access.action_type) &&
-        access.access_flag === 1,
-    );
-
-    if (!hasAccess) {
-      throw new ForbiddenException('Access denied: Insufficient permissions.');
-    }
-    return true;
-  }
-}
+import {
+  CanActivate,
+  ExecutionContext,
+  ForbiddenException,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { UserData } from '../../user/entity/user.entity';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
+
+@Injectable()
+export class RolesGuard implements CanActivate {
+  constructor(
+    private reflector: Reflector,
+    @InjectEntityManager() private entityManager: EntityManager,
+  ) {}
+
+  async canActivate(context: ExecutionContext) {
+    const request = context
+      .switchToHttp()
+      .getRequest<Request & { user: any }>();
+    const object = request.user;
+
+    const users: UserData = await this.entityManager.query(
+      `SELECT * FROM sso_user WHERE id = ${object.userId} LIMIT 1`,
+    );
+
+    const user = users[0];
+    if (!user || !user['role_id']) {
+      throw new UnauthorizedException('User not authorized');
+    }
+
+    const requiredModule = this.reflector.get<string>(
+      'moduleCode',
+      context.getHandler(),
+    );
+    const requiredActions = this.reflector.get<string>(
+      'actions',
+      context.getHandler(),
+    );
+
+    const roleAccess = await this.entityManager.query(
+      `SELECT *
+             FROM sso_module_access
+             WHERE role_id = ${user['role_id']}
+               AND module_code = '${requiredModule}'`,
+    );
+
+    if (!roleAccess || roleAccess.length === 0) {
+      throw new ForbiddenException(
+        'Access denied: No permissions found for this module',
+      );
+    }
+
+    const hasAccess = roleAccess.some(
+      (access) =>
+        requiredActions.includes(access.action_type) &&
+        access.access_flag === 1,
+    );
+
+    if (!hasAccess) {
+      throw new ForbiddenException('Access denied: Insufficient permissions.');
+    }
+    return true;
+  }
+}

package/src/module/auth/services/auth.service.ts

@@ -1,50 +1,50 @@
-import { BadRequestException, Inject, Injectable } from '@nestjs/common';
-import { UserService } from '../../user/service/user.service';
-import { JwtService } from '@nestjs/jwt';
-import { UserData } from '../../user/entity/user.entity';
-import { DataSource } from 'typeorm';
-
-@Injectable()
-export class AuthService {
-  constructor(
-    private jwtService: JwtService,
-    private dataSource: DataSource,
-  ) {}
-
-  // async validateUser(email: string, password: string): Promise<UserData> {
-  //   const user = await this.userService.findByEmailId(email);
-  //   if (!user) {
-  //     throw new BadRequestException('User not found');
-  //   }
-  //   const isMatch: boolean = password === user.password;
-  //   if (!isMatch) {
-  //     throw new BadRequestException('Password does not match');
-  //   }
-  //   return user;
-  // }
-
-  async login(user: UserData) {
-    const payload = { email: user.email_id, id: user.id };
-    return { access_token: this.jwtService.sign(payload) };
-  }
-
-  async fcmtoken(
-    fcmtoken: string,
-    loggedInUser: any,
-    ip: string,
-    browser: string,
-    os: string,
-  ) {
-    const { id: userId, sessionToken } = loggedInUser;
-
-    // Update the sso_user table
-    await this.dataSource.query(
-      `UPDATE sso_user_session
-       SET fcm_token = $1, ip = $2, browser = $3, os = $4
-       WHERE session_key = $5 AND user_id = $6 `,
-      [fcmtoken, ip, browser, os, sessionToken, userId],
-    );
-
-    return { message: 'FCM token updated successfully' };
-  }
-}
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import { UserService } from '../../user/service/user.service';
+import { JwtService } from '@nestjs/jwt';
+import { UserData } from '../../user/entity/user.entity';
+import { DataSource } from 'typeorm';
+
+@Injectable()
+export class AuthService {
+  constructor(
+    private jwtService: JwtService,
+    private dataSource: DataSource,
+  ) {}
+
+  // async validateUser(email: string, password: string): Promise<UserData> {
+  //   const user = await this.userService.findByEmailId(email);
+  //   if (!user) {
+  //     throw new BadRequestException('User not found');
+  //   }
+  //   const isMatch: boolean = password === user.password;
+  //   if (!isMatch) {
+  //     throw new BadRequestException('Password does not match');
+  //   }
+  //   return user;
+  // }
+
+  async login(user: UserData) {
+    const payload = { email: user.email_id, id: user.id };
+    return { access_token: this.jwtService.sign(payload) };
+  }
+
+  async fcmtoken(
+    fcmtoken: string,
+    loggedInUser: any,
+    ip: string,
+    browser: string,
+    os: string,
+  ) {
+    const { id: userId, sessionToken } = loggedInUser;
+
+    // Update the sso_user table
+    await this.dataSource.query(
+      `UPDATE sso_user_session
+       SET fcm_token = $1, ip = $2, browser = $3, os = $4
+       WHERE session_key = $5 AND user_id = $6 `,
+      [fcmtoken, ip, browser, os, sessionToken, userId],
+    );
+
+    return { message: 'FCM token updated successfully' };
+  }
+}

package/src/module/auth/services/jwt.service.ts

@@ -1,11 +1,11 @@
-import { Injectable } from '@nestjs/common';
-import { JwtService } from '@nestjs/jwt';
-
-@Injectable()
-export class JwtAuthService {
-  constructor(private readonly jwtService: JwtService) {}
-
-  generateJwt(payload: any): string {
-    return this.jwtService.sign(payload);
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+
+@Injectable()
+export class JwtAuthService {
+  constructor(private readonly jwtService: JwtService) {}
+
+  generateJwt(payload: any): string {
+    return this.jwtService.sign(payload);
+  }
+}

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

@@ -1,54 +1,54 @@
-import { Injectable } from '@nestjs/common';
-import { PassportStrategy } from '@nestjs/passport';
-import { Strategy, VerifyCallback } from 'passport-google-oauth20';
-import { ConfigService } from '@nestjs/config';
-
-@Injectable()
-export class GoogleStrategy extends PassportStrategy(Strategy, 'google') {
-  constructor(private configService: ConfigService) {
-    super({
-      clientID: configService.get<string>('CLIENT_ID')!,
-      clientSecret: configService.get<string>('CLIENT_SECRET')!,
-      callbackURL: configService.get<string>('CALLBACK_URL')!,
-      scope: [
-        'openid',
-        'email',
-        'profile',
-      ],
-      accessType: 'offline', // good: gets refresh_token on first consent
-      includeGrantedScopes: true, // optional, keeps prior grants
-      // ⛔️ don't rely on 'prompt' here; add via authorizationParams()
-    });
-  }
-
-  // ✅ Guarantees account chooser every time
-  authorizationParams(): Record<string, string> {
-    return {
-      prompt: 'select_account', // or 'consent select_account' if you want re-consent too
-      // login_hint: 'user@domain.com',    // optional
-      // hd: 'your-domain.com',            // optional: restrict to a Google Workspace domain
-    };
-  }
-
-  async validate(
-    accessToken: string,
-    refreshToken: string,
-    profile: any,
-    done: VerifyCallback,
-  ) {
-    const email = profile.emails?.[0]?.value ?? null;
-    const name = {
-      givenName: profile.name?.givenName ?? '',
-      familyName: profile.name?.familyName ?? '',
-      displayName: profile.displayName ?? '',
-    };
-
-    return done(null, {
-      email,
-      name,
-      accessToken,
-      refreshToken,
-      provider: 'google',
-    });
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { Strategy, VerifyCallback } from 'passport-google-oauth20';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class GoogleStrategy extends PassportStrategy(Strategy, 'google') {
+  constructor(private configService: ConfigService) {
+    super({
+      clientID: configService.get<string>('CLIENT_ID')!,
+      clientSecret: configService.get<string>('CLIENT_SECRET')!,
+      callbackURL: configService.get<string>('CALLBACK_URL')!,
+      scope: [
+        'openid',
+        'email',
+        'profile',
+      ],
+      accessType: 'offline', // good: gets refresh_token on first consent
+      includeGrantedScopes: true, // optional, keeps prior grants
+      // ⛔️ don't rely on 'prompt' here; add via authorizationParams()
+    });
+  }
+
+  // ✅ Guarantees account chooser every time
+  authorizationParams(): Record<string, string> {
+    return {
+      prompt: 'select_account', // or 'consent select_account' if you want re-consent too
+      // login_hint: 'user@domain.com',    // optional
+      // hd: 'your-domain.com',            // optional: restrict to a Google Workspace domain
+    };
+  }
+
+  async validate(
+    accessToken: string,
+    refreshToken: string,
+    profile: any,
+    done: VerifyCallback,
+  ) {
+    const email = profile.emails?.[0]?.value ?? null;
+    const name = {
+      givenName: profile.name?.givenName ?? '',
+      familyName: profile.name?.familyName ?? '',
+      displayName: profile.displayName ?? '',
+    };
+
+    return done(null, {
+      email,
+      name,
+      accessToken,
+      refreshToken,
+      provider: 'google',
+    });
+  }
+}

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

@@ -1,58 +1,58 @@
-import { ExtractJwt, Strategy } from 'passport-jwt';
-import { PassportStrategy } from '@nestjs/passport';
-import { Injectable, UnauthorizedException } from '@nestjs/common';
-import { secretKey } from '../../../constant/global.constant';
-import { InjectRepository } from '@nestjs/typeorm';
-import { UserSession } from 'src/module/user/entity/user-session.entity';
-import { BaseEntity, Repository } from 'typeorm';
-import { ConfigService } from '@nestjs/config';
-
-@Injectable()
-export class JwtStrategy extends PassportStrategy(Strategy) {
-  constructor(private readonly configService: ConfigService) {
-    super({
-      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
-      ignoreExpiration: false,
-      secretOrKey: configService.get('SECRET_KEY'),
-    });
-  }
-
-  async validate(payload) {
-    const {
-      id,
-      sessionToken,
-      appcode,
-      email_id,
-      organization_id,
-      enterprise_id,
-      level_id,
-      level_type,
-    } = payload;
-
-    // Check if session exists and is valid
-    // const userSession = await this.userSessionRepository.findOne({
-    //   where: { session_key: sessionToken },
-    // });
-
-    // if (
-    //   !userSession ||
-    //   userSession.is_session_loggedout ||
-    //   new Date(userSession.expiry_date) < new Date()
-    // ) {
-    //   throw new UnauthorizedException('Invalid or expired session');
-    // }
-
-    const userData = {
-      id: id,
-      sessionToken: sessionToken,
-      appcode: appcode,
-      email_id: email_id,
-      organization_id: organization_id,
-      enterprise_id: enterprise_id,
-      level_id: level_id,
-      level_type: level_type,
-    };
-
-    return { userData };
-  }
-}
+import { ExtractJwt, Strategy } from 'passport-jwt';
+import { PassportStrategy } from '@nestjs/passport';
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { secretKey } from '../../../constant/global.constant';
+import { InjectRepository } from '@nestjs/typeorm';
+import { UserSession } from 'src/module/user/entity/user-session.entity';
+import { BaseEntity, Repository } from 'typeorm';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+  constructor(private readonly configService: ConfigService) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ignoreExpiration: false,
+      secretOrKey: configService.get('SECRET_KEY'),
+    });
+  }
+
+  async validate(payload) {
+    const {
+      id,
+      sessionToken,
+      appcode,
+      email_id,
+      organization_id,
+      enterprise_id,
+      level_id,
+      level_type,
+    } = payload;
+
+    // Check if session exists and is valid
+    // const userSession = await this.userSessionRepository.findOne({
+    //   where: { session_key: sessionToken },
+    // });
+
+    // if (
+    //   !userSession ||
+    //   userSession.is_session_loggedout ||
+    //   new Date(userSession.expiry_date) < new Date()
+    // ) {
+    //   throw new UnauthorizedException('Invalid or expired session');
+    // }
+
+    const userData = {
+      id: id,
+      sessionToken: sessionToken,
+      appcode: appcode,
+      email_id: email_id,
+      organization_id: organization_id,
+      enterprise_id: enterprise_id,
+      level_id: level_id,
+      level_type: level_type,
+    };
+
+    return { userData };
+  }
+}

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

@@ -1,13 +1,13 @@
-import { PassportStrategy } from '@nestjs/passport';
-import { AuthService } from '../services/auth.service';
-import { Injectable } from '@nestjs/common';
-import { Strategy } from 'passport-jwt';
-
-@Injectable()
-export class LocalStrategy extends PassportStrategy(Strategy) {
-  constructor(private authService: AuthService) {
-    super({
-      usernameField: 'email',
-    });
-  }
-}
+import { PassportStrategy } from '@nestjs/passport';
+import { AuthService } from '../services/auth.service';
+import { Injectable } from '@nestjs/common';
+import { Strategy } from 'passport-jwt';
+
+@Injectable()
+export class LocalStrategy extends PassportStrategy(Strategy) {
+  constructor(private authService: AuthService) {
+    super({
+      usernameField: 'email',
+    });
+  }
+}

package/src/module/dashboard/controller/dashboard.controller.ts

@@ -1,36 +1,36 @@
-import {
-  Controller,
-  Get,
-  Param,
-  ParseIntPipe,
-  Query,
-  Req,
-  UseGuards,
-} from '@nestjs/common';
-import { DashboardService } from '../service/dashboard.service';
-import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
-
-@Controller('dashboard')
-export class DashboardController {
-  constructor(private readonly dashboardService: DashboardService) {}
-
-  @Get('page-data/:pageId')
-  @UseGuards(JwtAuthGuard)
-  async getDashboard(
-    @Param('pageId', ParseIntPipe) pageId: number,
-    @Req() req: any,
-  ) {
-    const loggedInUser = req.user.userData;
-    return this.dashboardService.getDashboardPage(pageId, loggedInUser);
-  }
-
-  @Get('pages')
-  @UseGuards(JwtAuthGuard)
-  async getPages(
-    @Query('mapped_entity_type') mapped_entity_type: string,
-    @Req() req: any,
-  ) {
-    const loggedInUser = req.user.userData;
-    return this.dashboardService.getPages(mapped_entity_type, loggedInUser);
-  }
-}
+import {
+  Controller,
+  Get,
+  Param,
+  ParseIntPipe,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { DashboardService } from '../service/dashboard.service';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+
+@Controller('dashboard')
+export class DashboardController {
+  constructor(private readonly dashboardService: DashboardService) {}
+
+  @Get('page-data/:pageId')
+  @UseGuards(JwtAuthGuard)
+  async getDashboard(
+    @Param('pageId', ParseIntPipe) pageId: number,
+    @Req() req: any,
+  ) {
+    const loggedInUser = req.user.userData;
+    return this.dashboardService.getDashboardPage(pageId, loggedInUser);
+  }
+
+  @Get('pages')
+  @UseGuards(JwtAuthGuard)
+  async getPages(
+    @Query('mapped_entity_type') mapped_entity_type: string,
+    @Req() req: any,
+  ) {
+    const loggedInUser = req.user.userData;
+    return this.dashboardService.getPages(mapped_entity_type, loggedInUser);
+  }
+}