rez_core 4.0.116 → 4.0.121

package/src/utils/service/base64util.service.ts

@@ -1,18 +1,18 @@
-export class Base64Util {
-  static encode(byteArray: Uint8Array): string {
-    return Buffer.from(byteArray).toString('base64');
-  }
-
-  static decode(base64String: string): Uint8Array {
-    if (typeof Buffer !== 'undefined') {
-      return Uint8Array.from(Buffer.from(base64String, 'base64'));
-    }
-
-    const binaryString = atob(base64String);
-    const byteArray = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-      byteArray[i] = binaryString.charCodeAt(i);
-    }
-    return byteArray;
-  }
-}
+export class Base64Util {
+  static encode(byteArray: Uint8Array): string {
+    return Buffer.from(byteArray).toString('base64');
+  }
+
+  static decode(base64String: string): Uint8Array {
+    if (typeof Buffer !== 'undefined') {
+      return Uint8Array.from(Buffer.from(base64String, 'base64'));
+    }
+
+    const binaryString = atob(base64String);
+    const byteArray = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      byteArray[i] = binaryString.charCodeAt(i);
+    }
+    return byteArray;
+  }
+}

package/src/utils/service/clockIDGenUtil.service.ts

@@ -1,21 +1,21 @@
-import { Injectable } from '@nestjs/common';
-
-@Injectable()
-export class ClockIDGenService {
-  private _counter = 0n;
-  private timestampBits = 42;
-  private timestampMask = BigInt(
-    Math.floor(Math.pow(2, this.timestampBits)) - 1,
-  );
-  private counterBits = 10;
-  private counterMask = BigInt(Math.floor(Math.pow(2, this.counterBits)) - 1);
-
-  idGenerator(prefix?: string): string {
-    const timestamp = BigInt(Date.now()) & this.timestampMask;
-    const counter = BigInt(this._counter++) & this.counterMask;
-    let now = timestamp << BigInt(this.counterBits);
-    now = now | counter;
-    const id = now.toString(36).toUpperCase();
-    return prefix ? prefix + id : id;
-  }
-}
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class ClockIDGenService {
+  private _counter = 0n;
+  private timestampBits = 42;
+  private timestampMask = BigInt(
+    Math.floor(Math.pow(2, this.timestampBits)) - 1,
+  );
+  private counterBits = 10;
+  private counterMask = BigInt(Math.floor(Math.pow(2, this.counterBits)) - 1);
+
+  idGenerator(prefix?: string): string {
+    const timestamp = BigInt(Date.now()) & this.timestampMask;
+    const counter = BigInt(this._counter++) & this.counterMask;
+    let now = timestamp << BigInt(this.counterBits);
+    now = now | counter;
+    const id = now.toString(36).toUpperCase();
+    return prefix ? prefix + id : id;
+  }
+}

package/src/utils/service/codeGenerator.service.ts

@@ -1,22 +1,22 @@
-export class CodeGeneratorService {
-  static generateCode(input_string: string) {
-    if (!input_string) {
-      throw new Error('Input string cannot be empty');
-    }
-
-    // Step 1: Trim, to lowercase
-    let code = input_string.trim().toLowerCase();
-
-    // Step 2: Replace all whitespace with underscores
-    code = code.replace(/\s+/g, '_');
-
-    // Step 3: Remove all non-alphanumeric and non-underscore characters
-    const sanitizedCode = code.replace(/[^a-z0-9_]/g, '');
-
-    if (!sanitizedCode) {
-      throw new Error('Invalid input string, cannot generate code');
-    }
-
-    return sanitizedCode;
-  }
-}
+export class CodeGeneratorService {
+  static generateCode(input_string: string) {
+    if (!input_string) {
+      throw new Error('Input string cannot be empty');
+    }
+
+    // Step 1: Trim, to lowercase
+    let code = input_string.trim().toLowerCase();
+
+    // Step 2: Replace all whitespace with underscores
+    code = code.replace(/\s+/g, '_');
+
+    // Step 3: Remove all non-alphanumeric and non-underscore characters
+    const sanitizedCode = code.replace(/[^a-z0-9_]/g, '');
+
+    if (!sanitizedCode) {
+      throw new Error('Invalid input string, cannot generate code');
+    }
+
+    return sanitizedCode;
+  }
+}

package/src/utils/service/dateUtil.service.ts

@@ -1,17 +1,17 @@
-import { Injectable } from '@nestjs/common';
-
-@Injectable()
-export class DateUtil {
-  static formatDate(date: Date, format: string): string {
-    const map: { [key: string]: string } = {
-      dd: String(date.getDate()).padStart(2, '0'),
-      MM: String(date.getMonth() + 1).padStart(2, '0'),
-      yyyy: String(date.getFullYear()),
-      HH: String(date.getHours()).padStart(2, '0'),
-      mm: String(date.getMinutes()).padStart(2, '0'),
-      ss: String(date.getSeconds()).padStart(2, '0'),
-    };
-
-    return format.replace(/dd|MM|yyyy|HH|mm|ss/g, (matched) => map[matched]);
-  }
-}
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class DateUtil {
+  static formatDate(date: Date, format: string): string {
+    const map: { [key: string]: string } = {
+      dd: String(date.getDate()).padStart(2, '0'),
+      MM: String(date.getMonth() + 1).padStart(2, '0'),
+      yyyy: String(date.getFullYear()),
+      HH: String(date.getHours()).padStart(2, '0'),
+      mm: String(date.getMinutes()).padStart(2, '0'),
+      ss: String(date.getSeconds()).padStart(2, '0'),
+    };
+
+    return format.replace(/dd|MM|yyyy|HH|mm|ss/g, (matched) => map[matched]);
+  }
+}

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;
+  }
+}