rez_core 5.0.84 → 5.0.85

package/src/utils/service/encryptUtil.service.ts

@@ -1,97 +1,97 @@
-import { Injectable, InternalServerErrorException } from '@nestjs/common';
-import * as crypto from 'crypto';
-
-const CryptoJS = require('crypto-js');
-const encryptionType = 'aes-256-cbc';
-
-@Injectable()
-export class EncryptUtilService {
-  constructor() {}
-
-  static encryptGCM(data: any, Datakey: string, Dataiv: string) {
-    try {
-      const cipher = crypto.createCipheriv('aes-256-gcm', Datakey, Dataiv);
-      const encrypted = Buffer.concat([
-        cipher.update(data, 'utf8'),
-        cipher.final(),
-      ]);
-      const tag = cipher.getAuthTag();
-      return Buffer.concat([encrypted, tag]).toString('base64');
-    } catch (error) {
-      throw new InternalServerErrorException('Encryption process failed');
-    }
-  }
-
-  static decryptGCM(data: any, Datakey: any, Dataiv: any) {
-    try {
-      data = Buffer.from(data, 'base64');
-      const decipher = crypto.createDecipheriv('aes-256-gcm', Datakey, Dataiv);
-      const tag = data.slice(data.length - 16);
-      decipher.setAuthTag(tag);
-      data = data.slice(0, data.length - 16);
-      const decrypted = decipher.update(data, 'utf8') + decipher.final('utf8');
-      return decrypted;
-    } catch (error) {
-      throw new InternalServerErrorException('Decryption process failed');
-    }
-  }
-
-  static encryptCBC(data: any, Datakey: any, Dataiv: any) {
-    let encryptedRequest;
-    try {
-      const cipher = CryptoJS.AES.encrypt(data, Datakey, {
-        iv: Dataiv,
-        mode: CryptoJS.mode.CBC,
-      });
-      encryptedRequest = cipher.toString();
-    } catch (error) {
-      console.log(error);
-      throw new InternalServerErrorException('Encryption process failed');
-    }
-    return encryptedRequest;
-  }
-
-  static decryptCBC(data: any, Datakey: any, Dataiv: any) {
-    let decryptRequest;
-    try {
-      const cipher = CryptoJS.AES.decrypt(data, Datakey, {
-        iv: Dataiv,
-        mode: CryptoJS.mode.CBC,
-      });
-      decryptRequest = cipher.toString(CryptoJS.enc.Utf8);
-    } catch (error) {
-      throw new InternalServerErrorException('Encryption process failed');
-    }
-    return decryptRequest;
-  }
-
-  static encryptRequest(data: any, Datakey: any, Dataiv: any, type?: any) {
-    try {
-      switch (type) {
-        case 'GCM':
-          return this.encryptGCM(data, Datakey, Dataiv);
-        case 'CBC':
-          return this.encryptCBC(data, Datakey, Dataiv);
-        default:
-          return this.encryptCBC(data, Datakey, Dataiv);
-      }
-    } catch (error) {
-      throw new InternalServerErrorException('Encryption process failed');
-    }
-  }
-
-  static decryptRequest(data: any, Datakey: any, Dataiv: any, type?: any) {
-    try {
-      switch (type) {
-        case 'GCM':
-          return this.decryptGCM(data, Datakey, Dataiv);
-        case 'CBC':
-          return this.decryptCBC(data, Datakey, Dataiv);
-        default:
-          return this.decryptCBC(data, Datakey, Dataiv);
-      }
-    } catch (error) {
-      throw new InternalServerErrorException('Encryption process failed');
-    }
-  }
-}
+import { Injectable, InternalServerErrorException } from '@nestjs/common';
+import * as crypto from 'crypto';
+
+const CryptoJS = require('crypto-js');
+const encryptionType = 'aes-256-cbc';
+
+@Injectable()
+export class EncryptUtilService {
+  constructor() {}
+
+  static encryptGCM(data: any, Datakey: string, Dataiv: string) {
+    try {
+      const cipher = crypto.createCipheriv('aes-256-gcm', Datakey, Dataiv);
+      const encrypted = Buffer.concat([
+        cipher.update(data, 'utf8'),
+        cipher.final(),
+      ]);
+      const tag = cipher.getAuthTag();
+      return Buffer.concat([encrypted, tag]).toString('base64');
+    } catch (error) {
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+  }
+
+  static decryptGCM(data: any, Datakey: any, Dataiv: any) {
+    try {
+      data = Buffer.from(data, 'base64');
+      const decipher = crypto.createDecipheriv('aes-256-gcm', Datakey, Dataiv);
+      const tag = data.slice(data.length - 16);
+      decipher.setAuthTag(tag);
+      data = data.slice(0, data.length - 16);
+      const decrypted = decipher.update(data, 'utf8') + decipher.final('utf8');
+      return decrypted;
+    } catch (error) {
+      throw new InternalServerErrorException('Decryption process failed');
+    }
+  }
+
+  static encryptCBC(data: any, Datakey: any, Dataiv: any) {
+    let encryptedRequest;
+    try {
+      const cipher = CryptoJS.AES.encrypt(data, Datakey, {
+        iv: Dataiv,
+        mode: CryptoJS.mode.CBC,
+      });
+      encryptedRequest = cipher.toString();
+    } catch (error) {
+      console.log(error);
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+    return encryptedRequest;
+  }
+
+  static decryptCBC(data: any, Datakey: any, Dataiv: any) {
+    let decryptRequest;
+    try {
+      const cipher = CryptoJS.AES.decrypt(data, Datakey, {
+        iv: Dataiv,
+        mode: CryptoJS.mode.CBC,
+      });
+      decryptRequest = cipher.toString(CryptoJS.enc.Utf8);
+    } catch (error) {
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+    return decryptRequest;
+  }
+
+  static encryptRequest(data: any, Datakey: any, Dataiv: any, type?: any) {
+    try {
+      switch (type) {
+        case 'GCM':
+          return this.encryptGCM(data, Datakey, Dataiv);
+        case 'CBC':
+          return this.encryptCBC(data, Datakey, Dataiv);
+        default:
+          return this.encryptCBC(data, Datakey, Dataiv);
+      }
+    } catch (error) {
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+  }
+
+  static decryptRequest(data: any, Datakey: any, Dataiv: any, type?: any) {
+    try {
+      switch (type) {
+        case 'GCM':
+          return this.decryptGCM(data, Datakey, Dataiv);
+        case 'CBC':
+          return this.decryptCBC(data, Datakey, Dataiv);
+        default:
+          return this.decryptCBC(data, Datakey, Dataiv);
+      }
+    } catch (error) {
+      throw new InternalServerErrorException('Encryption process failed');
+    }
+  }
+}

package/src/utils/service/excel-helper.service.ts

@@ -1,72 +1,72 @@
-import * as ExcelJS from 'exceljs';
-import { ExcelData } from '../dto/excel-data.dto';
-import * as XLSX from 'xlsx';
-
-export class ExcelHelper {
-  static getHeader(filePath: string, sheetName: string): string[] {
-    const rows = this.readExcel(filePath, 'HEADER', sheetName);
-    return rows.length > 0 ? rows[0] : [];
-  }
-
-  static readExcel(
-    filePath: string,
-    rowLevel: string,
-    sheetName: string,
-  ): string[][] {
-    const workbook = new ExcelJS.Workbook();
-    workbook.xlsx.readFile(filePath);
-    const sheet = workbook.getWorksheet(sheetName);
-    if (!sheet) throw new Error(`Sheet ${sheetName} not found`);
-
-    const result: string[][] = [];
-    sheet.eachRow((row, rowNumber) => {
-      if (rowLevel === 'HEADER' && rowNumber > 1) return;
-      if (rowLevel === 'ROWDATA' && rowNumber === 1) return;
-
-      const rowData: string[] = (row.values as any[]).slice(1).map((value) => {
-        return value !== undefined ? String(value).trim() : '';
-      });
-      result.push(rowData);
-      result.push(rowData);
-    });
-
-    return result;
-  }
-
-  static getRowData(filePath: string, sheetName: string): string[][] {
-    return this.readExcel(filePath, 'ROWDATA', sheetName);
-  }
-
-  static getJSONStringFromList(header: string[], rowData: string[][]): string {
-    return JSON.stringify(
-      rowData.map((row) =>
-        Object.fromEntries(header.map((col, i) => [col, row[i] || ''])),
-      ),
-    );
-  }
-
-  static getDataObjectListFromXLS<T>(
-    filePath: string,
-    sheetName: string,
-    classType: new () => T,
-  ): T[] {
-    const header = this.getHeader(filePath, sheetName);
-    const rowData = this.getRowData(filePath, sheetName);
-    const jsonString = this.getJSONStringFromList(header, rowData);
-    return JSON.parse(jsonString) as T[];
-  }
-
-  static writeExcel(excelData: ExcelData) {
-    const wb = XLSX.utils.book_new();
-
-    for (const sheetData of excelData.sheetList) {
-      const ws = XLSX.utils.aoa_to_sheet([
-        sheetData.headers,
-        ...sheetData.rowList,
-      ]);
-      XLSX.utils.book_append_sheet(wb, ws, sheetData.sheetName || 'Sheet1');
-    }
-
-    XLSX.writeFile(wb, excelData.filePath);
-  }
-}
+import * as ExcelJS from 'exceljs';
+import { ExcelData } from '../dto/excel-data.dto';
+import * as XLSX from 'xlsx';
+
+export class ExcelHelper {
+  static getHeader(filePath: string, sheetName: string): string[] {
+    const rows = this.readExcel(filePath, 'HEADER', sheetName);
+    return rows.length > 0 ? rows[0] : [];
+  }
+
+  static readExcel(
+    filePath: string,
+    rowLevel: string,
+    sheetName: string,
+  ): string[][] {
+    const workbook = new ExcelJS.Workbook();
+    workbook.xlsx.readFile(filePath);
+    const sheet = workbook.getWorksheet(sheetName);
+    if (!sheet) throw new Error(`Sheet ${sheetName} not found`);
+
+    const result: string[][] = [];
+    sheet.eachRow((row, rowNumber) => {
+      if (rowLevel === 'HEADER' && rowNumber > 1) return;
+      if (rowLevel === 'ROWDATA' && rowNumber === 1) return;
+
+      const rowData: string[] = (row.values as any[]).slice(1).map((value) => {
+        return value !== undefined ? String(value).trim() : '';
+      });
+      result.push(rowData);
+      result.push(rowData);
+    });
+
+    return result;
+  }
+
+  static getRowData(filePath: string, sheetName: string): string[][] {
+    return this.readExcel(filePath, 'ROWDATA', sheetName);
+  }
+
+  static getJSONStringFromList(header: string[], rowData: string[][]): string {
+    return JSON.stringify(
+      rowData.map((row) =>
+        Object.fromEntries(header.map((col, i) => [col, row[i] || ''])),
+      ),
+    );
+  }
+
+  static getDataObjectListFromXLS<T>(
+    filePath: string,
+    sheetName: string,
+    classType: new () => T,
+  ): T[] {
+    const header = this.getHeader(filePath, sheetName);
+    const rowData = this.getRowData(filePath, sheetName);
+    const jsonString = this.getJSONStringFromList(header, rowData);
+    return JSON.parse(jsonString) as T[];
+  }
+
+  static writeExcel(excelData: ExcelData) {
+    const wb = XLSX.utils.book_new();
+
+    for (const sheetData of excelData.sheetList) {
+      const ws = XLSX.utils.aoa_to_sheet([
+        sheetData.headers,
+        ...sheetData.rowList,
+      ]);
+      XLSX.utils.book_append_sheet(wb, ws, sheetData.sheetName || 'Sheet1');
+    }
+
+    XLSX.writeFile(wb, excelData.filePath);
+  }
+}

package/src/utils/service/excelUtil.service.ts

@@ -1,15 +1,15 @@
-import * as xlsx from 'xlsx';
-
-export class ExcelUtil {
-  static readExcel(fileBuffer: Buffer): Record<string, any[]> {
-    const workbook = xlsx.read(fileBuffer, { type: 'buffer' });
-    const data: Record<string, any[]> = {};
-
-    workbook.SheetNames.forEach((sheetName) => {
-      const sheet = workbook.Sheets[sheetName];
-      data[sheetName] = xlsx.utils.sheet_to_json(sheet);
-    });
-
-    return data;
-  }
-}
+import * as xlsx from 'xlsx';
+
+export class ExcelUtil {
+  static readExcel(fileBuffer: Buffer): Record<string, any[]> {
+    const workbook = xlsx.read(fileBuffer, { type: 'buffer' });
+    const data: Record<string, any[]> = {};
+
+    workbook.SheetNames.forEach((sheetName) => {
+      const sheet = workbook.Sheets[sheetName];
+      data[sheetName] = xlsx.utils.sheet_to_json(sheet);
+    });
+
+    return data;
+  }
+}

package/src/utils/service/file-util.service.ts

@@ -1,11 +1,11 @@
-import * as fs from 'node:fs';
-
-export class FileUtil {
-  static deleteFile(path: string) {
-    fs.unlink(path, (err) => {
-      if (err) {
-        console.log(`Error deleting file ${path}:`, err);
-      }
-    });
-  }
-}
+import * as fs from 'node:fs';
+
+export class FileUtil {
+  static deleteFile(path: string) {
+    fs.unlink(path, (err) => {
+      if (err) {
+        console.log(`Error deleting file ${path}:`, err);
+      }
+    });
+  }
+}

package/src/utils/service/json-util.service.ts

@@ -1,23 +1,23 @@
-export class JsonUtil {
-  static merge(mainNode: any, updatedNode: any): any {
-    if (typeof mainNode !== 'object' || typeof updatedNode !== 'object') {
-      return updatedNode;
-    }
-
-    const mergedNode: any = {};
-
-    for (const key in updatedNode) {
-      if (updatedNode.hasOwnProperty(key)) {
-        mergedNode[key] = this.merge(mainNode[key], updatedNode[key]);
-      }
-    }
-
-    for (const key in mainNode) {
-      if (mainNode.hasOwnProperty(key) && !updatedNode.hasOwnProperty(key)) {
-        mergedNode[key] = mainNode[key];
-      }
-    }
-
-    return mergedNode;
-  }
-}
+export class JsonUtil {
+  static merge(mainNode: any, updatedNode: any): any {
+    if (typeof mainNode !== 'object' || typeof updatedNode !== 'object') {
+      return updatedNode;
+    }
+
+    const mergedNode: any = {};
+
+    for (const key in updatedNode) {
+      if (updatedNode.hasOwnProperty(key)) {
+        mergedNode[key] = this.merge(mainNode[key], updatedNode[key]);
+      }
+    }
+
+    for (const key in mainNode) {
+      if (mainNode.hasOwnProperty(key) && !updatedNode.hasOwnProperty(key)) {
+        mergedNode[key] = mainNode[key];
+      }
+    }
+
+    return mergedNode;
+  }
+}

package/src/utils/service/loggingUtil.service.ts

@@ -1,88 +1,88 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import axios from 'axios';
-
-@Injectable()
-export class LoggingService {
-  private readonly logger = new Logger(LoggingService.name);
-  private readonly graylogUrl: string;
-  private readonly environment: string;
-
-  constructor(private readonly configService: ConfigService) {
-    this.graylogUrl =
-      this.configService.get<string>('GRAYLOG_URL') ||
-      'http://localhost:12201/gelf';
-    this.environment = this.configService.get<string>('PROFILE') || 'dev';
-  }
-
-  async log(
-    level: string,
-    serviceName: string,
-    methodName: string,
-    message: string,
-    parameters?: unknown[],
-    debugInfo?: unknown[],
-  ) {
-    const logLevel = level.toLowerCase().trim();
-    const logMessage = `${serviceName}.${methodName}: ${message} | Params: ${JSON.stringify(
-      parameters,
-    )} | Debug: ${JSON.stringify(debugInfo)}`;
-
-    // Console output via NestJS Logger
-    switch (logLevel) {
-      case 'debug':
-      case 'info':
-        this.logger.debug(logMessage);
-        break;
-      case 'warn':
-        this.logger.warn(logMessage);
-        break;
-      case 'error':
-        this.logger.error(logMessage);
-        break;
-      default:
-        this.logger.log(logMessage);
-    }
-
-    // Send to Graylog asynchronously
-    this.sendToGraylog({
-      version: '1.1',
-      host: serviceName || 'nestjs-app',
-      short_message: message,
-      full_message: logMessage,
-      level: this.mapLogLevel(logLevel),
-      _service: serviceName,
-      _method: methodName,
-      _parameters: parameters,
-      _debug: debugInfo,
-      _environment: this.environment,
-      timestamp: Date.now() / 1000,
-    });
-  }
-
-  private async sendToGraylog(payload: Record<string, any>) {
-    try {
-      await axios.post(this.graylogUrl, payload, {
-        headers: { 'Content-Type': 'application/json' },
-        timeout: 2000, // short timeout
-      });
-    } catch (err) {
-      this.logger.warn(`Graylog send failed: ${err.message}`);
-    }
-  }
-
-  private mapLogLevel(level: string): number {
-    // Graylog levels: 0 (emerg) → 7 (debug)
-    const mapping: Record<string, number> = {
-      emerg: 0,
-      alert: 1,
-      crit: 2,
-      error: 3,
-      warn: 4,
-      notice: 5,
-      info: 6,
-      debug: 7,
-    };
-    return mapping[level] ?? 6;
-  }
-}
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import axios from 'axios';
+
+@Injectable()
+export class LoggingService {
+  private readonly logger = new Logger(LoggingService.name);
+  private readonly graylogUrl: string;
+  private readonly environment: string;
+
+  constructor(private readonly configService: ConfigService) {
+    this.graylogUrl =
+      this.configService.get<string>('GRAYLOG_URL') ||
+      'http://localhost:12201/gelf';
+    this.environment = this.configService.get<string>('PROFILE') || 'dev';
+  }
+
+  async log(
+    level: string,
+    serviceName: string,
+    methodName: string,
+    message: string,
+    parameters?: unknown[],
+    debugInfo?: unknown[],
+  ) {
+    const logLevel = level.toLowerCase().trim();
+    const logMessage = `${serviceName}.${methodName}: ${message} | Params: ${JSON.stringify(
+      parameters,
+    )} | Debug: ${JSON.stringify(debugInfo)}`;
+
+    // Console output via NestJS Logger
+    switch (logLevel) {
+      case 'debug':
+      case 'info':
+        this.logger.debug(logMessage);
+        break;
+      case 'warn':
+        this.logger.warn(logMessage);
+        break;
+      case 'error':
+        this.logger.error(logMessage);
+        break;
+      default:
+        this.logger.log(logMessage);
+    }
+
+    // Send to Graylog asynchronously
+    this.sendToGraylog({
+      version: '1.1',
+      host: serviceName || 'nestjs-app',
+      short_message: message,
+      full_message: logMessage,
+      level: this.mapLogLevel(logLevel),
+      _service: serviceName,
+      _method: methodName,
+      _parameters: parameters,
+      _debug: debugInfo,
+      _environment: this.environment,
+      timestamp: Date.now() / 1000,
+    });
+  }
+
+  private async sendToGraylog(payload: Record<string, any>) {
+    try {
+      await axios.post(this.graylogUrl, payload, {
+        headers: { 'Content-Type': 'application/json' },
+        timeout: 2000, // short timeout
+      });
+    } catch (err) {
+      this.logger.warn(`Graylog send failed: ${err.message}`);
+    }
+  }
+
+  private mapLogLevel(level: string): number {
+    // Graylog levels: 0 (emerg) → 7 (debug)
+    const mapping: Record<string, number> = {
+      emerg: 0,
+      alert: 1,
+      crit: 2,
+      error: 3,
+      warn: 4,
+      notice: 5,
+      info: 6,
+      debug: 7,
+    };
+    return mapping[level] ?? 6;
+  }
+}