rez_core 7.0.13 → 7.1.1

package/src/module/auth/dto/user.dto.ts

@@ -1,56 +1,56 @@
-export class UserData {
-
-  id: number;
-
-  status: string;
-
-  code: string;
-
-  created_by: number;
-
-  created_date: Date;
-
-  modified_by: number;
-
-  modified_date: Date;
-
-  enterprise_id: number;
-
-  level_id: string;
-
-  level_type: string;
-
-  first_name: string;
-
-  last_name: string;
-
-  password: string;
-
-  email_id: string;
-
-  mobile: string;
-
-  mobile_cc: string;
-
-  is_firstlogin: number;
-
-  is_defaultadmin: number;
-
-  invitation_status: string;
-
-  is_customer: number;
-
-  is_factory: number;
-
-  last_app_access_id: number;
-
-  last_level_type: string;
-
-  last_level_id: string;
-
-  date: Date;
-
-  profile_image: string;
-
-  appcode: string;
-}
+export class UserData {
+
+  id: number;
+
+  status: string;
+
+  code: string;
+
+  created_by: number;
+
+  created_date: Date;
+
+  modified_by: number;
+
+  modified_date: Date;
+
+  enterprise_id: number;
+
+  level_id: string;
+
+  level_type: string;
+
+  first_name: string;
+
+  last_name: string;
+
+  password: string;
+
+  email_id: string;
+
+  mobile: string;
+
+  mobile_cc: string;
+
+  is_firstlogin: number;
+
+  is_defaultadmin: number;
+
+  invitation_status: string;
+
+  is_customer: number;
+
+  is_factory: number;
+
+  last_app_access_id: number;
+
+  last_level_type: string;
+
+  last_level_id: string;
+
+  date: Date;
+
+  profile_image: string;
+
+  appcode: string;
+}

package/src/module/auth/guards/google-auth.guard.ts

@@ -1,9 +1,9 @@
-import { ExecutionContext, Injectable } from '@nestjs/common';
-import { AuthGuard } from '@nestjs/passport';
-
-@Injectable()
-export class GoogleAuthGuard extends AuthGuard('google') {
-  canActivate(context: ExecutionContext) {
-    return super.canActivate(context);
-  }
-}
+import { ExecutionContext, Injectable } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+
+@Injectable()
+export class GoogleAuthGuard extends AuthGuard('google') {
+  canActivate(context: ExecutionContext) {
+    return super.canActivate(context);
+  }
+}

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/services/auth.service.ts

@@ -1,56 +1,56 @@
-import { Injectable } from '@nestjs/common';
-import { JwtService } from '@nestjs/jwt';
-import { UserData } from 'src/module/auth/dto/user.dto';
-import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
-
-@Injectable()
-export class AuthService {
-  constructor(
-    private jwtService: JwtService,
-    private reflectionHelper: ReflectionHelper,
-  ) {}
-
-  // 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;
-
-    const userSessionRepo = this.reflectionHelper.getRepoService('UserSession');
-    let userSessions = await userSessionRepo.find({
-      where: {
-        session_key: sessionToken,
-        user_id: userId
-      }
-    });
-
-    for( let session of userSessions ) {
-      session.fcm_token = fcmtoken;
-      session.ip = ip;
-      session.browser = browser;
-      session.os = os;
-      await userSessionRepo.save(session);
-    }
-    return { message: 'FCM token updated successfully' };
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { UserData } from 'src/module/auth/dto/user.dto';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
+
+@Injectable()
+export class AuthService {
+  constructor(
+    private jwtService: JwtService,
+    private reflectionHelper: ReflectionHelper,
+  ) {}
+
+  // 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;
+
+    const userSessionRepo = this.reflectionHelper.getRepoService('UserSession');
+    let userSessions = await userSessionRepo.find({
+      where: {
+        session_key: sessionToken,
+        user_id: userId
+      }
+    });
+
+    for( let session of userSessions ) {
+      session.fcm_token = fcmtoken;
+      session.ip = ip;
+      session.browser = browser;
+      session.os = os;
+      await userSessionRepo.save(session);
+    }
+    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,65 +1,65 @@
-import { ExtractJwt, Strategy } from 'passport-jwt';
-import { PassportStrategy } from '@nestjs/passport';
-import { Injectable, UnauthorizedException } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { Redis } from 'ioredis';
-import { RedisService } from '@liaoliaots/nestjs-redis';
-
-@Injectable()
-export class JwtStrategy extends PassportStrategy(Strategy) {
-  private redis: Redis;
-
-  constructor(private readonly configService: ConfigService,
-    private readonly redisService: RedisService) {
-    super({
-      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
-      ignoreExpiration: false,
-      secretOrKey: configService.get('SECRET_KEY'),
-    });
-    // Use the named 'cache' connection for session validation
-    this.redis = this.redisService.getOrThrow('cache');
-  }
-
-  async validate(payload) {
-    const {
-      id,
-      sessionToken,
-      app_id,
-      email_id,
-      organization_id,
-      enterprise_id,
-      level_id,
-      level_type,
-      appcode,
-    } = payload;
-
-    const redisKey = `SESSION:${sessionToken}`;
-
-    const sessionData = await this.redis.get(redisKey);
-
-    if (!sessionData) {
-      throw new UnauthorizedException('Session expired or invalid');
-    }
-
-    const session = JSON.parse(sessionData);
-
-    if (session.is_session_loggedout === 1) {
-      throw new UnauthorizedException('Session logged out');
-    }
-
-
-    const userData = {
-      id: id,
-      sessionToken: sessionToken,
-      app_id: app_id,
-      email_id: email_id,
-      organization_id: organization_id,
-      enterprise_id: enterprise_id,
-      level_id: level_id,
-      level_type: level_type,
-      appcode: appcode,
-    };
-
-    return { userData };
-  }
-}
+import { ExtractJwt, Strategy } from 'passport-jwt';
+import { PassportStrategy } from '@nestjs/passport';
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { Redis } from 'ioredis';
+import { RedisService } from '@liaoliaots/nestjs-redis';
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+  private redis: Redis;
+
+  constructor(private readonly configService: ConfigService,
+    private readonly redisService: RedisService) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ignoreExpiration: false,
+      secretOrKey: configService.get('SECRET_KEY'),
+    });
+    // Use the named 'cache' connection for session validation
+    this.redis = this.redisService.getOrThrow('cache');
+  }
+
+  async validate(payload) {
+    const {
+      id,
+      sessionToken,
+      app_id,
+      email_id,
+      organization_id,
+      enterprise_id,
+      level_id,
+      level_type,
+      appcode,
+    } = payload;
+
+    const redisKey = `SESSION:${sessionToken}`;
+
+    const sessionData = await this.redis.get(redisKey);
+
+    if (!sessionData) {
+      throw new UnauthorizedException('Session expired or invalid');
+    }
+
+    const session = JSON.parse(sessionData);
+
+    if (session.is_session_loggedout === 1) {
+      throw new UnauthorizedException('Session logged out');
+    }
+
+
+    const userData = {
+      id: id,
+      sessionToken: sessionToken,
+      app_id: app_id,
+      email_id: email_id,
+      organization_id: organization_id,
+      enterprise_id: enterprise_id,
+      level_id: level_id,
+      level_type: level_type,
+      appcode: appcode,
+    };
+
+    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,38 +1,38 @@
-import {
-  Controller,
-  Get, HttpCode, HttpStatus,
-  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)
-  @HttpCode(HttpStatus.OK)
-  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)
-  @HttpCode(HttpStatus.OK)
-  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, HttpCode, HttpStatus,
+  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)
+  @HttpCode(HttpStatus.OK)
+  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)
+  @HttpCode(HttpStatus.OK)
+  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);
+  }
+}