rez_core 3.1.199 → 3.1.200

package/src/module/auth/auth.module.ts

@@ -1,49 +1,49 @@
-import { Module } from '@nestjs/common';
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import { JwtModule } from '@nestjs/jwt';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { JwtStrategy } from './strategies/jwt.strategy';
-import { JwtAuthService } from './services/jwt.service';
-import { JwtAuthGuard } from './guards/jwt.guard';
-import { secretKey } from '../../constant/global.constant';
-import { PassportModule } from '@nestjs/passport';
-import { UserSession } from '../user/entity/user-session.entity';
-import { GoogleStrategy } from './strategies/google.strategy';
-import { RolesGuard } from './guards/role.guard';
-import { AuthService } from './services/auth.service';
-import { AuthController } from './controller/auth.controller';
-import { UserModule } from '../user/user.module';
-
-@Module({
-  imports: [
-    ConfigModule, // ✅ Ensure ConfigModule is imported
-    PassportModule.register({ defaultStrategy: 'jwt' }),
-    JwtModule.registerAsync({
-      imports: [ConfigModule],
-      inject: [ConfigService],
-      useFactory: async (configService: ConfigService) => {
-        const expiryInHours = parseFloat(
-          configService.get('TOKEN_EXPIRY') || '1',
-        );
-        const expiryInSeconds = expiryInHours * 60 * 60;
-
-        return {
-          secret: configService.get('SECRET_KEY'),
-          signOptions: { expiresIn: expiryInSeconds },
-        };
-      },
-    }),
-    TypeOrmModule.forFeature([UserSession]),
-  ],
-  controllers: [AuthController],
-  providers: [
-    JwtAuthService,
-    JwtStrategy,
-    JwtAuthGuard,
-    GoogleStrategy,
-    RolesGuard,
-    AuthService,
-  ],
-  exports: [JwtAuthService, JwtAuthGuard, RolesGuard, AuthService],
-})
-export class AuthModule {}
+import { Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { JwtModule } from '@nestjs/jwt';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { JwtStrategy } from './strategies/jwt.strategy';
+import { JwtAuthService } from './services/jwt.service';
+import { JwtAuthGuard } from './guards/jwt.guard';
+import { secretKey } from '../../constant/global.constant';
+import { PassportModule } from '@nestjs/passport';
+import { UserSession } from '../user/entity/user-session.entity';
+import { GoogleStrategy } from './strategies/google.strategy';
+import { RolesGuard } from './guards/role.guard';
+import { AuthService } from './services/auth.service';
+import { AuthController } from './controller/auth.controller';
+import { UserModule } from '../user/user.module';
+
+@Module({
+  imports: [
+    ConfigModule, // ✅ Ensure ConfigModule is imported
+    PassportModule.register({ defaultStrategy: 'jwt' }),
+    JwtModule.registerAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: async (configService: ConfigService) => {
+        const expiryInHours = parseFloat(
+          configService.get('TOKEN_EXPIRY') || '1',
+        );
+        const expiryInSeconds = expiryInHours * 60 * 60;
+
+        return {
+          secret: configService.get('SECRET_KEY'),
+          signOptions: { expiresIn: expiryInSeconds },
+        };
+      },
+    }),
+    TypeOrmModule.forFeature([UserSession]),
+  ],
+  controllers: [AuthController],
+  providers: [
+    JwtAuthService,
+    JwtStrategy,
+    JwtAuthGuard,
+    GoogleStrategy,
+    RolesGuard,
+    AuthService,
+  ],
+  exports: [JwtAuthService, JwtAuthGuard, RolesGuard, AuthService],
+})
+export class AuthModule {}

package/src/module/auth/controller/auth.controller.ts

@@ -1,28 +1,28 @@
-import { Body, Controller, Post, Req, UseGuards } from '@nestjs/common';
-import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
-import { AuthService } from '../services/auth.service';
-import { UAParser } from 'ua-parser-js';
-
-@Controller('auth')
-export class AuthController {
-  constructor(private readonly authService: AuthService) {}
-
-  @Post('fcmtoken')
-  @UseGuards(JwtAuthGuard)
-  async getDashboard(@Req() req: any, @Body('fcmtoken') fcmtoken: string) {
-    const loggedInUser = req.user.userData;
-
-    const ip =
-      (req.headers['x-forwarded-for'] as string)?.split(',')[0].trim() ||
-      req.socket.remoteAddress ||
-      req.ip ||
-      '';
-
-    const userAgent = req.headers['user-agent'] || '';
-    const parser = new UAParser(userAgent);
-    const browser = parser.getBrowser().name || 'Unknown';
-    const os = parser.getOS().name || 'Unknown';
-
-    return this.authService.fcmtoken(fcmtoken, loggedInUser, ip, browser, os);
-  }
-}
+import { Body, Controller, Post, Req, UseGuards } from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { AuthService } from '../services/auth.service';
+import { UAParser } from 'ua-parser-js';
+
+@Controller('auth')
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Post('fcmtoken')
+  @UseGuards(JwtAuthGuard)
+  async getDashboard(@Req() req: any, @Body('fcmtoken') fcmtoken: string) {
+    const loggedInUser = req.user.userData;
+
+    const ip =
+      (req.headers['x-forwarded-for'] as string)?.split(',')[0].trim() ||
+      req.socket.remoteAddress ||
+      req.ip ||
+      '';
+
+    const userAgent = req.headers['user-agent'] || '';
+    const parser = new UAParser(userAgent);
+    const browser = parser.getBrowser().name || 'Unknown';
+    const os = parser.getOS().name || 'Unknown';
+
+    return this.authService.fcmtoken(fcmtoken, loggedInUser, ip, browser, os);
+  }
+}

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/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, organization_id } = loggedInUser;
-
-    // Update the sso_user table
-    await this.dataSource.query(
-      `UPDATE sso_user
-       SET fcm_token = ?, ip = ?, browser = ?, os = ?
-       WHERE id = ? AND organization_id = ?`,
-      [fcmtoken, ip, browser, os, userId, organization_id],
-    );
-
-    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, organization_id } = loggedInUser;
+
+    // Update the sso_user table
+    await this.dataSource.query(
+      `UPDATE sso_user
+       SET fcm_token = ?, ip = ?, browser = ?, os = ?
+       WHERE id = ? AND organization_id = ?`,
+      [fcmtoken, ip, browser, os, userId, organization_id],
+    );
+
+    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',
+    });
+  }
+}