rez_core 6.6.6 → 7.0.0

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

@@ -0,0 +1,294 @@
+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/notification.controller.ts

@@ -1,58 +1,58 @@
-import {
-  Body,
-  Controller,
-  Get,
-  Post,
-  Query,
-  Req,
-  UseGuards,
-} from '@nestjs/common';
-import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
-import { NotificationsService } from '../service/notification.service';
-
-@Controller('notifications')
-export class NotificationsController {
-  constructor(private readonly notificationsService: NotificationsService) {}
-
-  // Store token from frontend
-  @Post('register-token')
-  async registerToken(@Body() body: { userId?: string; token: string }) {
-    // Optional: associate token with userId if provided
-    return this.notificationsService.saveToken(body.userId, body.token);
-  }
-
-  @Post('send')
-  async sendNotification(
-    @Body()
-    body: {
-      token: string;
-      title: string;
-      message: string;
-      data?: Record<string, any>;
-    },
-  ) {
-    return this.notificationsService.sendToDevice(
-      body.token,
-      body.title,
-      body.message,
-      body.data,
-    );
-  }
-
-  @Get('all')
-  @UseGuards(JwtAuthGuard)
-  async getNotifications(@Req() req: any, @Query() filterQuery: any) {
-    const loggedInUser = req.user.userData;
-    return this.notificationsService.getAllNotifications(
-      loggedInUser,
-      filterQuery,
-    );
-  }
-
-  @Post('mark-all-read')
-  @UseGuards(JwtAuthGuard)
-  async markAllAsRead(@Req() req: any) {
-    const loggedInUser = req.user.userData;
-    return this.notificationsService.markAllAsRead(loggedInUser);
-  }
-}
+import {
+  Body,
+  Controller,
+  Get,
+  Post,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { NotificationsService } from '../service/notification.service';
+
+@Controller('notifications')
+export class NotificationsController {
+  constructor(private readonly notificationsService: NotificationsService) {}
+
+  // Store token from frontend
+  @Post('register-token')
+  async registerToken(@Body() body: { userId?: string; token: string }) {
+    // Optional: associate token with userId if provided
+    return this.notificationsService.saveToken(body.userId, body.token);
+  }
+
+  @Post('send')
+  async sendNotification(
+    @Body()
+    body: {
+      token: string;
+      title: string;
+      message: string;
+      data?: Record<string, any>;
+    },
+  ) {
+    return this.notificationsService.sendToDevice(
+      body.token,
+      body.title,
+      body.message,
+      body.data,
+    );
+  }
+
+  @Get('all')
+  @UseGuards(JwtAuthGuard)
+  async getNotifications(@Req() req: any, @Query() filterQuery: any) {
+    const loggedInUser = req.user.userData;
+    return this.notificationsService.getAllNotifications(
+      loggedInUser,
+      filterQuery,
+    );
+  }
+
+  @Post('mark-all-read')
+  @UseGuards(JwtAuthGuard)
+  async markAllAsRead(@Req() req: any) {
+    const loggedInUser = req.user.userData;
+    return this.notificationsService.markAllAsRead(loggedInUser);
+  }
+}

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

@@ -1,117 +1,117 @@
-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' },
-        ],
-      },
-    );
-  }
-}
+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' },
+        ],
+      },
+    );
+  }
+}