rez_core 6.6.6 → 7.0.1

package/src/module/notification/controller/otp.controller.ts

@@ -1,117 +0,0 @@
-import {
-  BadRequestException,
-  Body,
-  Controller,
-  Get,
-  HttpCode,
-  HttpStatus,
-  Post,
-  Query,
-  Req,
-} from '@nestjs/common';
-import { OtpService } from '../service/otp.service';
-import { ConfigService } from '@nestjs/config';
-import { EmailService } from '../service/email.service';
-import { UAParser } from 'ua-parser-js';
-import { Request } from 'express';
-
-@Controller('otp')
-export class OtpController {
-  constructor(
-    private readonly otpService: OtpService,
-    private readonly emailService: EmailService,
-    private configService: ConfigService,
-  ) {}
-
-  otpExpiry = this.configService.get('OTP_EXPIRY') || '2';
-  otpLength = this.configService.get('OTP_LENGTH') || '6';
-
-  @Post('generate')
-  @HttpCode(HttpStatus.OK)
-  async generateOtp(@Body() request: any) {
-    const identifier = request.identifier;
-    const service = request.service;
-
-    if (!identifier || !service) {
-      throw new BadRequestException('Missing identifier or service!');
-    }
-    const otp = await this.otpService.generate(
-      identifier,
-      service,
-      parseInt(this.otpExpiry),
-      parseInt(this.otpLength),
-    );
-    return { otp_id: otp.otp_id, success: true };
-  }
-
-  @Post('verify')
-  @HttpCode(HttpStatus.OK)
-  async verifyOtp(
-    @Body()
-    data: {
-      otp: string;
-      otp_id: string;
-      identifier: string;
-      subdomain: string;
-      fcm_token: string;
-    },
-    @Req() req: Request,
-  ) {
-    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 await this.otpService.verifyOtp({
-      ...data,
-      ip,
-      browser,
-      os,
-    });
-  }
-
-  @Post('send-mail')
-  @HttpCode(HttpStatus.OK)
-  async sendMail(
-    @Body()
-    body: {
-      to: string;
-      cc?: string;
-      bcc?: string;
-      subject: string;
-      message: string;
-      templateCode: string;
-      payload: any;
-    },
-  ) {
-    return await this.emailService.sendEmailWithDynamicTemplate(
-      body.to,
-      body.subject,
-      body.templateCode,
-      body.cc ? body.cc.split(',') : [],
-      body.bcc ? body.bcc.split(',') : [],
-      body.message,
-      body.payload,
-      {
-        title: 'Project Kickoff Meeting',
-        description: 'Discuss goals and deliverables',
-        startsAt: '2025-08-30T10:00:00+05:30',
-        durationMinutes: 60,
-        meetingUrl: 'https://meet.google.com/xyz-1234-abc',
-        location: 'Google Meet',
-        organizerName: 'Darshil',
-        organizerEmail: 'sample@sample',
-        attendees: [
-          { name: 'John Doe', email: 'john@example.com' },
-          { name: 'Jane Smith', email: 'jane@example.com' },
-        ],
-      },
-    );
-  }
-}

package/src/module/notification/repository/notification.repository.ts

@@ -1,33 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository, EntityManager } from 'typeorm';
-import { NotificationData } from '../entity/notification.entity';
-
-@Injectable()
-export class NotificationRepository {
-  constructor(
-    @InjectRepository(NotificationData)
-    private readonly notificationRepo: Repository<NotificationData>,
-  ) {}
-
-  async getAllNotifications(
-    userId: number,
-    levelId: number,
-    levelType: string,
-    isReadFilter?,
-  ) {
-    const qb = this.notificationRepo
-      .createQueryBuilder('n')
-      .where('n.user_id = :userId', { userId })
-      .andWhere('n.level_id = :levelId', { levelId })
-      .andWhere('n.level_type = :levelType', { levelType });
-
-    if (isReadFilter !== undefined) {
-      qb.andWhere('n.is_read = :isRead', { isRead: isReadFilter });
-    }
-
-    qb.orderBy('n.created_date', 'DESC');
-
-    return await qb.getMany();
-  }
-}

package/src/module/notification/service/otp.service.ts

@@ -1,133 +0,0 @@
-import { DataSource } from 'typeorm';
-import { BadRequestException, Injectable } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { ClockIDGenService } from '../../../utils/service/clockIDGenUtil.service';
-import { Otp } from '../entity/otp.entity';
-import { OtpRepository } from '../repository/otp.repository';
-import { LoginService } from './../../user/service/login.service';
-import { EmailService } from './email.service';
-
-@Injectable()
-export class OtpService {
-  constructor(
-    private readonly otpRepository: OtpRepository,
-    private readonly idGen: ClockIDGenService,
-    private configService: ConfigService,
-    private readonly loginService: LoginService,
-    private readonly emailService: EmailService,
-    private readonly dataSource: DataSource,
-  ) {}
-
-  VERIFY_OTP = this.configService.get('VERIFY_OTP') || 'true';
-  DEFAULT_OTP = this.configService.get('DEFAULT_OTP') || '123456';
-
-  async generate(
-    identifier: string,
-    service: string,
-    expiresIn: number = 5,
-    otpLength: number = 6,
-  ) {
-    const otp = new Otp();
-    otp.created_date = new Date();
-    otp.otp_id = this.idGen.idGenerator();
-    otp.identifier = identifier;
-    otp.otp =
-      'true' === this.VERIFY_OTP
-        ? this.generateOtp(otpLength)
-        : this.DEFAULT_OTP;
-    otp.service = service;
-    otp.verified = 0;
-    otp.expiration_date = new Date(Date.now() + expiresIn * 60 * 1000);
-
-    const userData = await this.dataSource
-      .getRepository('sso_user')
-      .findOne({ where: { email_id: identifier } });
-
-    const data = {
-      name: userData?.name || '',
-      otp: otp.otp,
-    };
-
-    await this.emailService.sendEmail(identifier, 'OTP Verification', data);
-
-    return await this.otpRepository.save(otp);
-  }
-
-  async verifyOtp(data: {
-    otp: string;
-    otp_id: string;
-    identifier: string;
-    subdomain: string;
-    fcm_token: string;
-    browser?: string;
-    ip?: string;
-    os?: string;
-  }) {
-    const { otp, otp_id, identifier, subdomain, fcm_token, browser, ip, os } =
-      data;
-    const verifyOTPResponse = { isValid: false };
-
-    // Find OTP entity by ID
-    const otpEntity = await this.findByOtpId(otp_id);
-    if (!otpEntity) {
-      // throw new BadRequestException('OTP not found!');
-      return {
-        sucess: false,
-        message: 'OTP not found!',
-      };
-    }
-
-    // Validate the identifier against the OTP entity
-    if (otpEntity.identifier !== identifier) {
-      return {
-        sucess: false,
-        message: 'Invalid OTP identifier!',
-      };
-    }
-
-    // OTP validation logic
-    const isOtpValid =
-      (otpEntity.otp === otp ||
-        (this.DEFAULT_OTP && this.DEFAULT_OTP === otp)) &&
-      new Date() <= otpEntity.expiration_date &&
-      otpEntity.verified === 0;
-
-    if (isOtpValid) {
-      otpEntity.verified = 1;
-
-      // Save the updated OTP status
-      const updatedOtp = await this.otpRepository.update(
-        otpEntity.id,
-        otpEntity,
-      );
-      if (updatedOtp) {
-        verifyOTPResponse.isValid = true;
-      }
-    }
-
-    if (!verifyOTPResponse.isValid) {
-      // throw new BadRequestException('Invalid OTP!');
-      return {
-        sucess: false,
-        message: 'Invalid OTP!',
-      };
-    }
-
-    // Proceed to login
-    return this.loginService.login({
-      email_id: identifier,
-      is_otp: true,
-      subdomain,
-    });
-  }
-
-  async findByOtpId(otpId: string) {
-    return await this.otpRepository.findByOtpId(otpId);
-  }
-
-  private generateOtp(length: number): string {
-    const min = 10 ** (length - 1);
-    const max = 10 ** length - 1;
-    return Math.floor(min + Math.random() * (max - min + 1)).toString();
-  }
-}

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

@@ -1,199 +0,0 @@
-import {
-  BadRequestException,
-  Body,
-  Controller,
-  Get,
-  HttpStatus,
-  Post,
-  Req,
-  Res,
-  UseGuards,
-} from '@nestjs/common';
-import { LoginService } from '../service/login.service';
-import { GoogleAuthGuard } from '../../../module/auth/guards/google-auth.guard';
-import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
-import { Request, Response } from 'express';
-import { UserSessionService } from '../service/user-session.service';
-import { ConfigService } from '@nestjs/config';
-import { IntegrationService } from '../../integration/service/integration.service';
-
-@Controller('auth')
-export class LoginController {
-  constructor(
-    private loginService: LoginService,
-    private userSessionService: UserSessionService,
-    private configService: ConfigService,
-    private integrationService: IntegrationService,
-  ) {}
-
-  @Post('login')
-  async login(@Body() body, @Res() res: Response) {
-    const { email_id, password, subdomain } = body;
-
-    const result = await this.loginService.login({
-      email_id,
-      password,
-      is_otp: false, // default since you had it before
-      subdomain,
-    });
-
-    return res.status(HttpStatus.OK).json(result);
-  }
-
-  @Post('form-login')
-  async formLogin(@Body() body, @Res() res: Response) {
-    const result = await this.loginService.formLogin(body);
-    return res.status(HttpStatus.OK).json(result);
-  }
-
-  @UseGuards(JwtAuthGuard)
-  @Post('logout')
-  async logout(
-    @Req() request: Request & { user: any },
-    @Res() response: Response,
-  ) {
-    const requestUser: any = request.user.userData;
-    response
-      .status(HttpStatus.OK)
-      .json(await this.loginService.logout(requestUser.sessionToken));
-  }
-
-  @Get('google')
-  @UseGuards(GoogleAuthGuard)
-  async googleLogin() {
-    // Passport automatically redirects to Google
-  }
-
-  @Get('google/callback')
-  @UseGuards(GoogleAuthGuard)
-  async googleAuthRedirect(@Req() req: any, @Res() res: Response) {
-    const {
-      email,
-      name,
-      accessToken: googleAccessToken,
-      refreshToken: googleRefreshToken,
-    } = req.user;
-    const { state } = req.query;
-
-    // Check if this is a Gmail configuration request
-    if (
-      state &&
-      typeof state === 'string' &&
-      state.startsWith('gmail_config:')
-    ) {
-      try {
-        // Extract the actual state from the prefixed state
-        const actualState = state.replace('gmail_config:', '');
-
-        // Forward to communication service for Gmail config handling using already exchanged tokens
-        const result = await this.integrationService.handleGmailTokensCallback(
-          email,
-          googleAccessToken,
-          googleRefreshToken,
-          actualState,
-          name,
-        );
-
-        return res.send(
-          `<html><body><script>
-    window.opener.postMessage({ type: 'CONFIG_SUCCESS' }, '*');
-    window.close();
-  </script> <p>Configuration successful. You can close this window.</p> </body></html>`,
-        );
-      } catch (error) {
-        return res.send(`
-         <html>
-        <body>
-          <script>
-            if (window.opener) {
-              window.opener.postMessage({ 
-                type: "CONFIG_FAILED", 
-                error: "${error.message || 'Something went wrong'}" 
-              }, "*");
-            }
-            window.close();
-          </script>
-          <p>Configuration failed. Please close this window.</p>
-        </body>
-      </html>
-        `);
-      }
-    }
-
-    // Original login flow
-    const data = await this.loginService.loginWithGoogle({
-      email,
-    });
-
-    if (!('accessToken' in data) || !data.accessToken)
-      return res.redirect(
-        `${this.configService.get('BASE_URL')}/auth?email=${email}&error='User not found'`,
-      );
-
-    const profile = this.configService.get('PROFILE');
-    const { accessToken, appcode } = data;
-    if (profile && profile === 'dev') {
-      return res.redirect(
-        `${this.configService.get('DOMAIN_URL')}/auth?token=${accessToken}&appcode=${appcode}`,
-      );
-    } else {
-      if (data.slug) {
-        return res.redirect(
-          `https://${data.slug}.${this.configService.get('DOMAIN_URL')}/auth?token=${accessToken}&appcode=${appcode}`,
-        );
-      }
-    }
-
-    return res.redirect(
-      `${this.configService.get('DOMAIN_URL')}/auth?token=${accessToken}&appcode=${appcode}`,
-    );
-  }
-
-  @UseGuards(JwtAuthGuard)
-  @Post('switch')
-  async switchCurrentLevel(
-    @Req() req: Request & { user: any },
-    @Body()
-    data: {
-      level_id: string;
-      level_type: string;
-      appcode: string;
-    },
-  ): Promise<any> {
-    const currentUser = req.user.userData;
-    const currentAppcode = currentUser.appcode;
-
-    // If appcode is changing, validate the new level_id/level_type
-    if (data.appcode !== currentAppcode) {
-      const isValidAccess = await this.userSessionService.checkIfUserHasMapping(
-        currentUser.id,
-        data.appcode,
-        data.level_type,
-        data.level_id,
-      );
-
-      if (!isValidAccess) {
-        // If not valid, fetch the default one
-        const userMapping =
-          await this.userSessionService.getUserRoleMappingForApp(
-            currentUser.id,
-            data.appcode,
-          );
-
-        if (!userMapping) {
-          throw new BadRequestException(
-            `No mapping found for user in app ${data.appcode}`,
-          );
-        }
-
-        data.level_type = userMapping.level_type;
-        data.level_id = userMapping.level_id;
-      }
-    }
-
-    return await this.userSessionService.switchCurrentLevelService(
-      currentUser,
-      data,
-    );
-  }
-}

package/src/module/user/controller/user.controller.ts

@@ -1,40 +0,0 @@
-import {
-  Body,
-  Controller,
-  HttpCode,
-  HttpStatus,
-  Inject,
-  Post,
-  Res,
-  ValidationPipe,
-} from '@nestjs/common';
-import { UserService } from '../service/user.service';
-import { CreateUserDto } from '../dto/create-user.dto';
-import { Response } from 'express';
-
-@Controller()
-export class UserController {
-  constructor(
-    @Inject('UserService') private readonly userService: UserService,
-  ) {}
-
-  @Post('user/signup')
-  async signup(
-    @Body(new ValidationPipe()) createUserDto: CreateUserDto,
-    @Res() res: Response,
-  ) {
-    const result = await this.userService.createEntity(createUserDto, null);
-    res.status(HttpStatus.OK).json(result);
-  }
-
-  @Post('check-email')
-  @HttpCode(HttpStatus.OK)
-  async checkEmail(@Body() body, @Res() res: Response) {
-    const { email_id, subdomain } = body;
-    const result = await this.userService.checkEmailExists({
-      email_id,
-      subdomain,
-    });
-    return res.status(HttpStatus.OK).json(result);
-  }
-}

package/src/module/user/dto/create-user.dto.ts

@@ -1,62 +0,0 @@
-import { IsNotEmpty, IsString, Matches } from 'class-validator';
-import { BaseEntity } from '../../meta/entity/base-entity.entity';
-import { ENTITYTYPE_USER } from '../../../constant/global.constant';
-import { Expose } from 'class-transformer';
-
-export class CreateUserDto extends BaseEntity {
-  constructor() {
-    super();
-    this.entity_type = ENTITYTYPE_USER;
-  }
-
-  @IsString()
-  @IsNotEmpty()
-  @Matches(/^[A-Za-z][A-Za-z]*$/, { message: 'enter valid first name' })
-  @Expose()
-  first_name: string;
-
-  @IsString()
-  @IsNotEmpty()
-  @Matches(/^[A-Za-z][A-Za-z]*$/, { message: 'enter valid last name' })
-  @Expose()
-  last_name: string;
-
-  @IsString()
-  @IsNotEmpty()
-  @Matches(
-    /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/,
-    { message: 'enter valid email' },
-  )
-  email_id: string;
-
-  @IsString()
-  @IsNotEmpty()
-  @Matches(
-    /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/,
-    {
-      message:
-        'Password must be at least 8 characters long, contain at least one uppercase letter, one lowercase letter, one digit, and one special character',
-    },
-  )
-  @Expose()
-  password: string;
-
-  @IsString()
-  @IsNotEmpty()
-  @Matches(/^[0-9]{10}$/, { message: 'enter valid contact number' })
-  @Expose()
-  mobile: string;
-
-  @Expose()
-  roles: any[];
-
-  is_firstlogin: number;
-
-  invitation_status: string;
-  is_defaultadmin: number;
-  is_customer: number;
-  appcode: string;
-  is_factory: number;
-
-  access: any[];
-}

package/src/module/user/dto/update-user.dto.ts

@@ -1,4 +0,0 @@
-import { PartialType } from '@nestjs/mapped-types';
-import { CreateUserDto } from './create-user.dto';
-
-export class UpdateUserDto extends PartialType(CreateUserDto) {}

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

@@ -1,33 +0,0 @@
-import { BaseEntity } from '../../meta/entity/base-entity.entity';
-import { ENTITYTYPE_ROLE } from '../../../constant/global.constant';
-import { Column, Entity } from 'typeorm';
-import { Exclude } from 'class-transformer';
-
-@Entity({ name: 'sso_role' })
-export class Role extends BaseEntity {
-  constructor() {
-    super();
-    this.entity_type = ENTITYTYPE_ROLE;
-  }
-
-  @Column({ type: 'int', nullable: true })
-  is_system: number;
-
-  @Column({ type: 'varchar', length: 250, nullable: true })
-  description: string;
-
-  @Column({ type: 'int', nullable: true })
-  organization_id: number;
-
-  @Exclude()
-  copy_from_role_id: number;
-
-  @Column({ type: 'int', nullable: true })
-  is_factory: number;
-
-  @Column({ type: 'varchar', length: 250, nullable: true })
-  parent_type: string;
-
-  @Column({ type: 'int', nullable: true })
-  parent_id: number;
-}

package/src/module/user/entity/user-session.entity.ts

@@ -1,73 +0,0 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
-
-@Entity({ name: 'sso_user_session' })
-export class UserSession {
-  @PrimaryGeneratedColumn()
-  id: number;
-
-  @Column({
-    name: 'is_session_loggedout',
-    nullable: true,
-    type: 'int',
-  })
-  is_session_loggedout: number;
-
-  @Column({
-    name: 'login_id',
-    nullable: true,
-    length: 50,
-  })
-  login_id: string;
-
-  @Column({
-    name: 'login_time',
-    nullable: true,
-  })
-  login_time: Date;
-
-  @Column({
-    name: 'logout_time',
-    nullable: true,
-  })
-  logout_time: Date;
-
-  @Column({
-    name: 'session_key',
-    nullable: true,
-    length: 100,
-  })
-  session_key: string;
-
-  @Column({
-    name: 'user_id',
-    nullable: true,
-    type: 'bigint',
-  })
-  user_id: number;
-
-  @Column({
-    name: 'access_token',
-    nullable: true,
-    type: 'varchar',
-    length: 5000,
-  })
-  access_token: string;
-
-  @Column({
-    name: 'expiry_date',
-    nullable: true,
-  })
-  expiry_date: Date;
-
-  @Column({ type: 'varchar', nullable: true })
-  fcm_token: string;
-
-  @Column({ type: 'varchar', nullable: true })
-  browser: string;
-
-  @Column({ type: 'varchar', nullable: true })
-  ip: string;
-
-  @Column({ type: 'varchar', nullable: true })
-  os: string;
-}