mvc-common-toolkit 1.43.10 → 1.44.0

package/src/pkg/worksheet.utils.ts

@@ -0,0 +1,178 @@
+import { Worksheet, Cell, Row, Column } from "exceljs";
+
+import { ICellData, ICellOptions } from "../interfaces";
+
+export class WorksheetUtils {
+  protected isAlive = true;
+
+  public id: number;
+
+  constructor(protected worksheet: Worksheet) {
+    this.id = worksheet.id;
+  }
+
+  public markRemoved(): void {
+    this.isAlive = false;
+  }
+
+  public rename(newName: string): void {
+    this.worksheet.name = newName;
+  }
+
+  public setRowHeight(rowNumber: number, height: number): void {
+    const row = this.getRow(rowNumber);
+
+    row.height = height;
+  }
+
+  public setColumnSize(columnName: string, width: number): void {
+    const column = this.getColumn(columnName);
+
+    column.width = width;
+  }
+
+  public getCellByAddress(
+    rowIndexOrName: string | number,
+    colIndexOrName: string | number
+  ): Cell {
+    const targetCell = this.worksheet.getCell(rowIndexOrName, colIndexOrName);
+
+    return targetCell;
+  }
+
+  public writeCellByAddress(
+    cellAddress: string,
+    cellData: Partial<ICellData>
+  ): Cell {
+    const targetCell = this.worksheet.getCell(cellAddress);
+
+    this.writeCell(targetCell, cellData);
+
+    return targetCell;
+  }
+
+  public writeRow(
+    rowNumber: number,
+    startColumnNumber: number,
+    writeData: any[]
+  ): Row {
+    const emptyArrayWithLength = Array(startColumnNumber);
+    const rowData = emptyArrayWithLength.concat(writeData);
+    const newRow = this.worksheet.insertRow(rowNumber, rowData, "o+");
+
+    newRow.commit();
+
+    return newRow;
+  }
+
+  public duplicateRow(rowNumber: number, amount = 1, insert = true): void {
+    this.worksheet.duplicateRow(rowNumber, amount, insert);
+  }
+
+  public duplicateColumn(colIndex: number): void {
+    const columnValues = this.worksheet.getColumn(colIndex).values;
+
+    this.cutAndOptionallyAddColumns(colIndex, 0, columnValues.slice());
+  }
+
+  public cutAndOptionallyAddColumns(
+    startColIndex: number,
+    cutCount: number,
+    ...args: any[][]
+  ) {
+    return this.worksheet.spliceColumns(startColIndex, cutCount, ...args);
+  }
+
+  public mergeCells(
+    startCellName: string,
+    endCellName: string,
+    ignoreStyle?: boolean
+  ): void {
+    this.throwIfNotAlive();
+
+    return this.worksheet.mergeCells(`${startCellName}:${endCellName}`);
+  }
+
+  public getRow(rowNumber1Based: number): Row {
+    this.throwIfNotAlive();
+
+    return this.worksheet.getRow(rowNumber1Based);
+  }
+
+  public getColumn(columnName: string): Partial<Column> {
+    this.throwIfNotAlive();
+
+    return this.worksheet.getColumn(columnName);
+  }
+
+  public commit(): void {
+    this.worksheet.commit();
+  }
+
+  public getColumnData(columnName: string, startIndex = 0): any[] {
+    this.throwIfNotAlive();
+
+    const column = this.getColumn(columnName);
+    const columnValues = column.values;
+
+    if (!columnValues || !columnValues.length) {
+      return [];
+    }
+
+    return columnValues.map((i) => i.valueOf()).slice(startIndex);
+  }
+
+  public getRowData(
+    rowNumber1Based: number,
+    startColIndex = 0,
+    endColIndex: number
+  ): any[] {
+    this.throwIfNotAlive();
+
+    const row = this.getRow(rowNumber1Based);
+    const rowValues = row.values;
+
+    if (!rowValues || !rowValues.length) {
+      return [];
+    }
+
+    if (Array.isArray(rowValues)) {
+      return rowValues
+        .map((cellValue) => cellValue.valueOf())
+        .slice(startColIndex, endColIndex);
+    } else {
+      return Object.values(rowValues)
+        .map((i) => i.valueOf())
+        .slice(startColIndex, endColIndex);
+    }
+  }
+
+  protected applyOptionsToCell(cell: Cell, options?: ICellOptions): void {
+    const { style, border } = options;
+
+    if (style) {
+      cell.style = style;
+    }
+
+    if (border) {
+      cell.border = border;
+    }
+  }
+
+  protected writeCell(cell: Cell, cellData: Partial<ICellData>): void {
+    const { value, options } = cellData;
+
+    cell.value = value;
+    if (options) {
+      this.applyOptionsToCell(cell, options);
+    }
+  }
+
+  protected throwIfNotAlive(): void {
+    if (this.isAlive) {
+      return;
+    }
+
+    throw new Error("Worksheet has been destroyed.");
+  }
+}

package/src/services/audit-service.ts

@@ -0,0 +1,22 @@
+import { AuditGateway } from "../interfaces";
+import { LogObject } from "../models/audit-log";
+
+export class AuditService {
+  constructor(protected auditCarrier: AuditGateway) {}
+
+  public async emitLog(log: LogObject): Promise<any> {
+    let result = null;
+    try {
+      result = await this.auditCarrier.publish(
+        log.logId,
+        log.level,
+        log.toJSON()
+      );
+    } catch (error) {
+      console.error(`[${log.logId}]failed to emit log: ` + log.toJSON());
+      console.error(error);
+    }
+
+    return result;
+  }
+}

package/src/services/excel.service.ts

@@ -0,0 +1,103 @@
+import "core-js/modules/es.promise";
+import "core-js/modules/es.string.includes";
+import "core-js/modules/es.object.assign";
+import "core-js/modules/es.object.keys";
+import "core-js/modules/es.symbol";
+import "core-js/modules/es.symbol.async-iterator";
+import "regenerator-runtime/runtime"; // For exceljs es5 to work.
+
+import { AddWorksheetOptions, Buffer, Workbook as IWorkbook } from "exceljs";
+import * as stream from "stream";
+import { WorksheetUtils } from "../pkg/worksheet.utils";
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const Workbook = require("exceljs/dist/es5/doc/workbook.js");
+
+export class ExcelService {
+  protected workbook: IWorkbook;
+  protected workSheetMap = new Map() as Map<string, WorksheetUtils>;
+
+  public async loadTemplate(templatePath: string): Promise<this> {
+    try {
+      if (!templatePath) {
+        throw new Error("Missing excel template path");
+      }
+
+      const newWorkbook = new Workbook();
+      this.workbook = await newWorkbook.xlsx.readFile(templatePath);
+
+      return this;
+    } catch (error: any) {
+      throw new Error(`Error loading excel template: ${error.message}`);
+    }
+  }
+
+  public async loadFromBuffer(buffer: Buffer): Promise<this> {
+    try {
+      if (!buffer || !buffer.byteLength) {
+        throw new Error("Excel buffer is empty!");
+      }
+
+      const newWorkbook = new Workbook();
+      this.workbook = await newWorkbook.xlsx.load(buffer);
+
+      return this;
+    } catch (error: any) {
+      throw new Error(`Error loading excel from buffer: ${error.message}`);
+    }
+  }
+
+  public addWorkSheet(
+    workSheetName: string,
+    options?: Partial<AddWorksheetOptions>
+  ): WorksheetUtils {
+    const newWorksheet = this.workbook.addWorksheet(workSheetName, options);
+    const wrappedWorksheet = new WorksheetUtils(newWorksheet);
+
+    this.workSheetMap.set(workSheetName, wrappedWorksheet);
+
+    return wrappedWorksheet;
+  }
+
+  public getWorkSheet(workSheetName: string): WorksheetUtils {
+    const worksheet = this.workbook.getWorksheet(workSheetName);
+
+    if (worksheet) {
+      const newWorkSheetUtil = new WorksheetUtils(worksheet);
+      this.workSheetMap.set(workSheetName, newWorkSheetUtil);
+
+      return newWorkSheetUtil;
+    }
+
+    return this.addWorkSheet(workSheetName);
+  }
+
+  public writeToStream(readStream: stream.Stream): Promise<void> {
+    return this.workbook.xlsx.write(readStream);
+  }
+
+  public writeToFile(path: string): Promise<void> {
+    return this.workbook.xlsx.writeFile(path);
+  }
+
+  public write(stream: stream.Stream): Promise<void> {
+    return this.writeToStream(stream);
+  }
+
+  public writeToBuffer(): Promise<Buffer> {
+    return this.workbook.xlsx.writeBuffer();
+  }
+
+  public removeWorkSheet(worksheet: WorksheetUtils): void {
+    worksheet.markRemoved();
+    return this.workbook.removeWorksheet(worksheet.id);
+  }
+
+  protected throwIfTemplateNotLoaded(): void {
+    if (this.workbook) {
+      return;
+    }
+
+    throw new Error("Template not loaded. Please load template.");
+  }
+}

package/src/services/http-service.ts

@@ -0,0 +1,71 @@
+import axios from "axios";
+
+import { PinoLogger } from "../pkg/logger";
+import { APP_ERROR, HttpMethod } from "../constants";
+import {
+  HttpRequestOption,
+  HttpService,
+  Logger,
+  OperationResult,
+} from "../interfaces";
+
+export class AxiosHttpService implements HttpService {
+  constructor(protected logger: Logger = new PinoLogger()) {}
+
+  public async send<T = any>(
+    method: HttpMethod,
+    url: string,
+    options: HttpRequestOption = {}
+  ): Promise<OperationResult<T>> {
+    let response: any;
+
+    try {
+      response = await axios.request({
+        method,
+        url,
+        headers: options.headers,
+        data: options.body,
+        params: options.query,
+        ...options,
+      });
+
+      if (response.status >= 400) {
+        return {
+          success: false,
+          httpCode: response.status,
+          data: response.data,
+        };
+      }
+
+      return {
+        success: true,
+        data: response.data,
+      };
+    } catch (error: any) {
+      const errMsg =
+        error?.message ||
+        response?.data?.message ||
+        "error sending http request";
+
+      const errDetails = response?.data?.data ||
+        response?.data || { stack: error.stack };
+      this.logger.error(errMsg, errDetails);
+
+      // Due to timeout
+      if (error?.code && error.code === APP_ERROR.HTTP_REQ_TIMEOUT) {
+        return {
+          success: false,
+          code: APP_ERROR.HTTP_REQ_TIMEOUT,
+          httpCode: 408,
+          message: "request timeout",
+        };
+      }
+
+      return {
+        success: false,
+        message: error.message,
+        data: response?.data || {},
+      };
+    }
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,8 @@
+export * from "./audit-service";
+export * from "./excel.service";
+export * from "./mailer-service";
+export * from "./kafka-service";
+export * from "./redis-service";
+export * from "./security-service";
+export * from "./http-service";
+export * from "./paginated-cache";

package/src/services/kafka-service.ts

@@ -0,0 +1,81 @@
+import { IMessageQueueService } from "../interfaces";
+import {
+  Consumer,
+  ConsumerConfig,
+  ConsumerSubscribeTopics,
+  Kafka,
+  KafkaConfig,
+  Producer,
+  ProducerConfig,
+  ConsumerRunConfig,
+  ProducerRecord,
+  TopicPartitionOffsetAndMetadata,
+} from "kafkajs";
+
+export class KafkaService implements IMessageQueueService {
+  protected _kafka: Kafka;
+
+  protected _producer: Producer;
+  protected _consumer: Consumer;
+
+  public get producer() {
+    if (!this._producer) {
+      throw new Error("producer not yet init");
+    }
+
+    return this._producer;
+  }
+
+  public get consumer() {
+    if (!this._consumer) {
+      throw new Error("consumer not yet init");
+    }
+
+    return this._consumer;
+  }
+
+  constructor(config: KafkaConfig) {
+    this._kafka = new Kafka(config);
+  }
+
+  async initProducer(config?: ProducerConfig) {
+    if (this._producer) {
+      console.warn("producer already initialized");
+
+      return;
+    }
+
+    this._producer = this._kafka.producer(config);
+
+    await this._producer.connect();
+  }
+
+  async initConsumer(config?: ConsumerConfig) {
+    if (this._consumer) {
+      console.warn("consumer already initialized");
+
+      return;
+    }
+
+    this._consumer = this._kafka.consumer(config);
+
+    await this._consumer.connect();
+  }
+
+  async listen(
+    subscribeConfig: ConsumerSubscribeTopics,
+    runConfig: ConsumerRunConfig
+  ): Promise<void> {
+    await this.consumer.subscribe(subscribeConfig);
+
+    return this.consumer.run(runConfig);
+  }
+
+  async publish(record: ProducerRecord): Promise<void> {
+    this._producer.send(record);
+  }
+
+  async commitOffsets(data: TopicPartitionOffsetAndMetadata[]): Promise<void> {
+    return this.consumer.commitOffsets(data);
+  }
+}

package/src/services/mailer-service.ts

@@ -0,0 +1,43 @@
+import { EmailSender, SendMailOptions } from "../interfaces";
+
+export interface MailServiceConfig {
+  adminEmails?: string[];
+}
+
+export class MailService {
+  protected adminEmails: string[];
+
+  constructor(
+    protected transporter: EmailSender,
+    protected config: MailServiceConfig
+  ) {
+    this.adminEmails = config?.adminEmails || [];
+  }
+
+  public async sendToAdmin(mailOptions: SendMailOptions) {
+    if (this.adminEmails.length === 0) {
+      throw new Error("admin email list is empty");
+    }
+
+    mailOptions.to = this.adminEmails;
+
+    return this.send(mailOptions);
+  }
+
+  public async send(
+    mailOptions: SendMailOptions,
+    ccOptions = { ccToAdmin: false, bccToAdmin: false }
+  ) {
+    const message = { from: process.env.SMTP_MAIL_FROM, ...mailOptions };
+    const { ccToAdmin, bccToAdmin } = ccOptions;
+
+    if (ccToAdmin && this.adminEmails.length > 0) message.cc = this.adminEmails;
+    if (bccToAdmin && this.adminEmails.length > 0)
+      message.bcc = this.adminEmails;
+
+    return this.transporter.send(message).catch((e) => {
+      console.error("Send mail error", e);
+      return false;
+    });
+  }
+}