rez_core 7.0.0 → 7.0.1

package/src/module/module/service/module-import.service.ts

@@ -1,294 +0,0 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
-import { EntityManager } from 'typeorm';
-import { ExcelUtil } from 'src/utils/service/excelUtil.service';
-import { ConfigService } from '@nestjs/config';
-
-@Injectable()
-export class ModuleImportService {
-    constructor(
-        private readonly entityManager: EntityManager,
-        private readonly configService: ConfigService,
-    ) { }
-
-    schema = this.configService.get('DB_SCHEMA');
-
-    private readonly moduleSequence = [
-        {
-            table: 'sso_module',
-            unique_fields: ['module_code'],
-        },
-        {
-            table: 'sso_menu',
-            unique_fields: ['module_id'],
-        },
-        {
-            table: 'sso_module_ucp',
-            unique_fields: ['module_id', 'action_code'],
-        },
-        {
-            table: 'sso_module_access',
-            unique_fields: ['module_id', 'action_type', 'role_id', 'level_type'],
-        },
-    ];
-
-    /**
-     * Get columns to exclude from INSERT/UPDATE operations based on table
-     * module_code is only needed in sso_module table, excluded from others
-     * action_type is only needed in sso_module_access table, excluded from others
-     */
-    private getExcludedColumns(tableName: string): string[] {
-        const baseExcluded = ['role_code', 'appcode'];
-
-        // module_code should only be included in sso_module table
-        if (tableName !== 'sso_module') {
-            baseExcluded.push('module_code');
-        }
-
-        // action_type should only be included in sso_module_access table
-        if (tableName !== 'sso_module_access') {
-            baseExcluded.push('action_type');
-        }
-
-        return baseExcluded;
-    }
-
-    async uploadModuleData(file) {
-        const data = ExcelUtil.readExcel(file.buffer);
-        const errors: any[] = [];
-
-        for (let i = 0; i < this.moduleSequence.length; i++) {
-            const { table, unique_fields } = this.moduleSequence[i];
-            const sheetData = data[table];
-
-            if (!sheetData) {
-                console.log(`Sheet ${table} not found in the Excel file.`);
-                continue;
-            }
-
-            console.log(`Processing sheet: ${table}`);
-
-            // Process each row and resolve codes to IDs
-            for (let rowIndex = 0; rowIndex < sheetData.length; rowIndex++) {
-                const row = sheetData[rowIndex];
-
-                try {
-                    // Resolve codes to IDs based on table
-                    if (table === 'sso_menu') {
-                        await this.resolveModuleCode(row);
-                        await this.resolveAppCode(row);
-                    } else if (table === 'sso_module_ucp') {
-                        await this.resolveModuleCode(row);
-                    } else if (table === 'sso_module_access') {
-                        await this.resolveModuleCode(row);
-                        await this.resolveRoleCode(row);
-                        await this.resolveAppCode(row);
-                        await this.resolveActionType(row);
-                    } else if (table === 'sso_module') {
-                        await this.resolveAppCode(row);
-                    }
-                } catch (error) {
-                    errors.push({
-                        sheet: table,
-                        row: rowIndex + 1,
-                        error: error.message,
-                    });
-                }
-            }
-
-            // If there are errors, throw exception before upserting
-            if (errors.length > 0) {
-                throw new BadRequestException({
-                    message: 'Validation errors found during code resolution',
-                    errors,
-                });
-            }
-
-            // Upsert data for this table
-            await this.upsertModuleData(table, unique_fields, sheetData);
-        }
-
-        return {
-            message: 'Module data uploaded successfully',
-        };
-    }
-
-    /**
-     * Resolve module_code to module_id
-     */
-    private async resolveModuleCode(row: any): Promise<void> {
-        if (!row.module_code) {
-            throw new Error('module_code is required but not provided');
-        }
-
-        const moduleData = await this.entityManager.query(
-            `SELECT id FROM ${this.schema}.sso_module WHERE module_code = $1 LIMIT 1`,
-            [row.module_code],
-        );
-
-        if (!moduleData || moduleData.length === 0) {
-            throw new Error(
-                `Module not found for module_code: ${row.module_code}`,
-            );
-        }
-
-        row.module_id = moduleData[0].id;
-    }
-
-    /**
-     * Resolve role_code to role_id
-     */
-    private async resolveRoleCode(row: any): Promise<void> {
-        if (!row.role_code) {
-            throw new Error('role_code is required but not provided');
-        }
-
-        const roleData = await this.entityManager.query(
-            `SELECT id FROM ${this.schema}.sso_role WHERE code = $1 LIMIT 1`,
-            [row.role_code],
-        );
-
-        if (!roleData || roleData.length === 0) {
-            throw new Error(`Role not found for role_code: ${row.role_code}`);
-        }
-
-        row.role_id = roleData[0].id;
-    }
-
-    /**
-     * Resolve appcode to app_id
-     */
-    private async resolveAppCode(row: any): Promise<void> {
-        if (!row.appcode) {
-            // appcode might be optional in some cases
-            return;
-        }
-
-        const appData = await this.entityManager.query(
-            `SELECT id FROM ${this.schema}.sso_app_master WHERE code = $1 LIMIT 1`,
-            [row.appcode],
-        );
-
-        if (!appData || appData.length === 0) {
-            throw new Error(`App not found for appcode: ${row.appcode}`);
-        }
-
-        row.app_id = appData[0].id;
-    }
-
-    /**
-     * Resolve action_type (action_code) to action_id
-     * This requires both module_code and action_type to find the correct action
-     */
-    private async resolveActionType(row: any): Promise<void> {
-        if (!row.action_type) {
-            throw new Error('action_type is required but not provided');
-        }
-
-        if (!row.module_code) {
-            throw new Error('module_code is required to resolve action_type');
-        }
-
-        // First get the module_id
-        const moduleData = await this.entityManager.query(
-            `SELECT id FROM ${this.schema}.sso_module WHERE module_code = $1 LIMIT 1`,
-            [row.module_code],
-        );
-
-        if (!moduleData || moduleData.length === 0) {
-            throw new Error(
-                `Module not found for module_code: ${row.module_code}`,
-            );
-        }
-
-        // Then find the action using module_id and action_code
-        const actionData = await this.entityManager.query(
-            `SELECT id FROM ${this.schema}.sso_module_ucp WHERE module_id = $1 AND action_code = $2 LIMIT 1`,
-            [moduleData[0].id, row.action_type],
-        );
-
-        if (!actionData || actionData.length === 0) {
-            throw new Error(
-                `Action not found for module_code: ${row.module_code} and action_type: ${row.action_type}`,
-            );
-        }
-
-        row.action_id = actionData[0].id;
-    }
-
-    /**
-     * Upsert data into the specified table
-     */
-    private async upsertModuleData(
-        tableName: string,
-        uniqueFields: string[],
-        data: any[],
-    ): Promise<void> {
-        const excludedColumns = this.getExcludedColumns(tableName);
-
-        for (const row of data) {
-            const whereClause = uniqueFields
-                .map((field, index) => `${field} = $${index + 1}`)
-                .join(' AND ');
-
-            const whereParams = uniqueFields.map((field) => row[field]);
-
-            const existing = await this.entityManager.query(
-                `SELECT * FROM ${this.schema}.${tableName} WHERE ${whereClause} LIMIT 1`,
-                whereParams,
-            );
-
-            if (existing.length > 0) {
-                // Update existing record
-                const setClauses: string[] = [];
-                const setParams: any[] = [];
-                let paramIndex = 1;
-
-                for (const key in row) {
-                    // Exclude code columns and unique fields from update
-                    if (row.hasOwnProperty(key) &&
-                        !uniqueFields.includes(key) &&
-                        !excludedColumns.includes(key)) {
-                        setClauses.push(`${key} = $${paramIndex}`);
-                        setParams.push(row[key]);
-                        paramIndex++;
-                    }
-                }
-
-                // Add where parameters
-                whereParams.forEach((param) => {
-                    setParams.push(param);
-                });
-
-                const updateWhereClause = uniqueFields
-                    .map((field, index) => `${field} = $${paramIndex + index}`)
-                    .join(' AND ');
-
-                if (setClauses.length > 0) {
-                    await this.entityManager.query(
-                        `UPDATE ${this.schema}.${tableName} SET ${setClauses.join(', ')} WHERE ${updateWhereClause}`,
-                        setParams,
-                    );
-                }
-            } else {
-                // Insert new record - exclude code columns
-                const filteredRow: any = {};
-                for (const key in row) {
-                    if (row.hasOwnProperty(key) && !excludedColumns.includes(key)) {
-                        filteredRow[key] = row[key];
-                    }
-                }
-
-                const columns = Object.keys(filteredRow).join(', ');
-                const placeholders = Object.keys(filteredRow)
-                    .map((_, index) => `$${index + 1}`)
-                    .join(', ');
-                const values = Object.values(filteredRow);
-
-                await this.entityManager.query(
-                    `INSERT INTO ${this.schema}.${tableName} (${columns}) VALUES (${placeholders})`,
-                    values,
-                );
-            }
-        }
-    }
-}

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

@@ -1,144 +0,0 @@
-import { DataSource } from 'typeorm';
-import { 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';
-import { PreferenceService } from 'src/module/preference_master/preference.service';
-
-@Injectable()
-export class OtpService {
-  constructor(
-    private readonly otpRepository: OtpRepository,
-    private readonly idGen: ClockIDGenService,
-    private configService: ConfigService,
-    private readonly loginService: LoginService,
-    private readonly dataSource: DataSource,
-    // private readonly preferenceService: PreferenceService,
-    private readonly emailService: EmailService,
-  ) {
-  }
-
-  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: any = await this.dataSource
-      .getRepository('sso_user')
-      .findOne({ where: { email_id: identifier } });
-
-    const data = {
-      name: userData?.name || '',
-      otp: otp.otp,
-    };
-
-    // TODO: Inject and use PreferenceService here
-    // const preference = await this.preferenceService.fetchPreferenceByType('OTP', true);
-
-    // if (preference) {
-    //   let otpBody = preference.filter((item) => item.key === 'OTP_BODY')[0].value;
-    //   otpBody = otpBody.replace('${otp}', otp.otp);
-    //   const otpSubject = preference.filter((item) => item.key === 'OTP_SUBJECT')[0].value;
-    //   this.emailService.sendEmailWithoutTemplate(userData.email_id, otpSubject, otpBody);
-    // }
-
-    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();
-  }
-}