rez_core 0.0.1

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

@@ -0,0 +1,56 @@
+import * as ExcelJS from 'exceljs';
+
+export class ExcelHelperService {
+  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[];
+  }
+}

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

@@ -0,0 +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;
+  }
+}

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

@@ -0,0 +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;
+    }
+}

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

@@ -0,0 +1,56 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { transports } from 'winston';
+const winston = require('winston');
+const moment = require('moment');
+
+@Injectable()
+export class LoggingService {
+    
+    constructor(
+    ) { }
+
+  
+             
+    async log(
+        level: string, 
+        serviceName: string, 
+        methodName: string, 
+        message: string, 
+        parameters?: unknown[], 
+        debuginfo?: unknown[]) {
+
+
+        let levelInfo = level.toLowerCase().trim();
+        let logger = new Logger(serviceName);
+        
+        const fileConfiguration = {
+            format: winston.format.combine(
+                winston.format.errors({ stzack: true }),
+                winston.format.timestamp({ format: 'DD/MM/YYYY HH:mm:ss' }),
+                winston.format.printf(info => `${info.timestamp} : ${info.level}: ${serviceName}: ${methodName} : ${message} : ${JSON.stringify(parameters) || ""} : ${JSON.stringify(debuginfo) || ""}`),
+            ),
+
+            transports: [
+                new transports.File({
+                    dirname: `/data01/logs/${moment().format("DD-MM-YYYY")}/activity/${moment().format("HH dddd")}`,
+                    filename: 'activity.log',
+                    level: `${level}`
+                })
+            ],
+        }
+
+        const filelogger = winston.createLogger(fileConfiguration);
+        let data = `${message} -- Parameters: ${JSON.stringify(parameters)}`;
+
+        if (levelInfo == "debug" || levelInfo == "info") {
+            logger.debug(`${methodName} : ${message} : Parameters :${JSON.stringify(parameters)}: Debug Info: ${JSON.stringify(debuginfo)}`);
+        }
+        else if (levelInfo == "error") {
+            logger.error(`${methodName} : ${message} : Parameters :${JSON.stringify(parameters)}: Debug Info: ${JSON.stringify(debuginfo)}`)
+        }
+        filelogger.on('finish', () => {});
+        filelogger.end();
+    }
+
+
+}

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

@@ -0,0 +1,53 @@
+import { Injectable } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { DataSource, Repository } from 'typeorm';
+import { getRepositoryToken } from '@nestjs/typeorm';
+
+@Injectable()
+export class ReflectionHelper {
+  constructor(
+    private moduleRef: ModuleRef,
+    private dataSource: DataSource,
+  ) {}
+
+  getRepoService(entityName: string): Repository<any> | null {
+    const entityMetadata: any = this.dataSource.entityMetadatas.find(
+      (meta) =>
+        meta.name === entityName ||
+        (meta.target && (meta.target as any).name === entityName),
+    );
+
+    if (!entityMetadata) {
+      console.error(`Entity "${entityName}" not found in TypeORM metadata`);
+      return null;
+    }
+
+    try {
+      return this.moduleRef.get<Repository<any>>(
+        getRepositoryToken(entityMetadata.target),
+        { strict: false },
+      );
+    } catch (error) {
+      console.error(`Repository for "${entityName}" not found:`, error.message);
+      return null;
+    }
+  }
+
+  async getBean<T>(beanName: string): Promise<T | null> {
+    try {
+      const provider = this.moduleRef.get<T>(beanName as any, {
+        strict: false,
+      });
+
+      if (!provider) {
+        console.error(`Bean "${beanName}" not found in moduleRef.`);
+        return null;
+      }
+
+      return provider;
+    } catch (error) {
+      console.error(`Bean "${beanName}" not found:`, error.message);
+      return null;
+    }
+  }
+}

package/src/utils/utils.module.ts

@@ -0,0 +1,14 @@
+import { Global, Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { DataSource } from 'typeorm';
+import { LoggingService } from './service/loggingUtil.service';
+import { ReflectionHelper } from './service/reflection-helper.service';
+import { ExcelUtil } from './service/excelUtil.service';
+
+@Global()
+@Module({
+  imports: [TypeOrmModule.forFeature([])], // Import TypeORM to make DataSource available
+  providers: [LoggingService, ReflectionHelper, ExcelUtil], // Ensure DataSource is provided
+  exports: [LoggingService, ReflectionHelper, ExcelUtil],
+})
+export class UtilsModule {}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2021",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "noFallthroughCasesInSwitch": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test"]
+}