@tomei/finance 0.2.14 → 0.3.0

package/src/document/document.ts

@@ -1,49 +1,155 @@
 import * as util from 'util';
 import * as fs from 'fs';
-import { IBaseRepository } from '@tomei/general';
+import puppeteer from 'puppeteer';
+import { IBaseRepository, RecordNotFoundError } from '@tomei/general';
 import {
   Medias,
   InternalMediaDto,
   IMediasRepository,
   CommonService as MediaCommonService,
   MediaType,
+  MediasModel,
 } from '@tomei/media';
 import { DocumentStatus, DocType } from '../enum';
-import { DocumentRepository } from './document.repository';
 import { IDocumentAttr } from './interfaces/document-attr.interface';
 import { DocumentItemRepository } from './document-item.repository';
 import { DocumentItem } from './document-item';
-import { AccountSystemEntity } from '../account-system-entity';
+import { IDocumentRepository } from './interfaces/document.repository.interface';
+import { AccountSystemEntity } from '../account-system-entity/account-system-entity';
+import DocumentModel from '../models/document.entity';
 
 export class Document extends AccountSystemEntity {
-  protected BaseRepository: IBaseRepository;
-  ObjectId: string;
-  ObjectName: string;
-  TableName: string;
   DocNo: string;
-  DocType: DocType;
-  DocDate: Date;
-  SystemCode: string;
+  private _DocType: DocType;
+  private _DocDate: Date = new Date();
   Currency: string;
   Amount: number;
   Description: string;
   IssuedById: string;
   IssuedToId: string;
   IssuedToType: string;
-  AccSystemCode: string;
+  CreatedById: string;
+  CreatedAt: Date;
+  UpdatedById?: string;
+  UpdatedAt?: Date;
   UseAccSystemDocYN: string;
-  private DocHTMLFilePath: string;
-  private DocPDFFilePath: string;
-  private Status: DocumentStatus;
+
+  private _documentRepository: IBaseRepository<DocumentModel> =
+    new DocumentModel();
+  protected _BaseRepository: IBaseRepository;
+
+  _ObjectId: string;
+  _ObjectName: string;
+  _TableName: string;
+
+  private _DocHTMLFileMediaId: string;
+  private _DocPDFFileMediaId: string;
+  private _Status: DocumentStatus = DocumentStatus.UNPAID;
 
   private IsNewRecord = true;
   private _DocumentItems: any;
 
-  documentRepository: DocumentRepository;
+  documentRepository: IDocumentRepository;
   documentItemRepository: DocumentItemRepository;
   mediaRepository: IMediasRepository;
   mediaCommonService: MediaCommonService;
 
+  public get DocType() {
+    return this._DocType;
+  }
+
+  private set DocType(docType: DocType) {
+    this._DocType = docType;
+  }
+
+  public get DocDate() {
+    return this._DocDate;
+  }
+
+  private set DocDate(date: Date) {
+    this._DocDate = date;
+  }
+
+  public get DocHTMLFileMediaId() {
+    return this._DocHTMLFileMediaId;
+  }
+
+  private set DocHTMLFileMediaId(mediaId: string) {
+    this._DocHTMLFileMediaId = mediaId;
+  }
+
+  public get DocPDFFileMediaId() {
+    return this._DocPDFFileMediaId;
+  }
+
+  private set DocPDFFileMediaId(mediaId: string) {
+    this._DocPDFFileMediaId = mediaId;
+  }
+
+  public get Status() {
+    return this._Status;
+  }
+
+  private set Status(status: DocumentStatus) {
+    this._Status = status;
+  }
+
+  /* AccountSystemEntity Implementation */
+  override get BaseRepository() {
+    return this._documentRepository;
+  }
+
+  /* ObjectBase Implementation */
+  override get ObjectId() {
+    return this.DocNo;
+  }
+
+  override get ObjectName() {
+    return this.DocNo;
+  }
+
+  override get TableName() {
+    return 'finance_Document';
+  }
+
+  constructor(dbTransaction: any);
+  constructor(dbTransaction: any, docNo?: string) {
+    super();
+    const documentData = this.BaseRepository.findOne({
+      where: {
+        DocNo: docNo,
+      },
+      transaction: dbTransaction,
+    });
+    if (documentData) {
+      this.IsNewRecord = false;
+      this.DocType = documentData.DocType;
+      this.DocDate = documentData.DocDate;
+      this.CompanyId = documentData.CompanyId;
+      this.Currency = documentData.Currency;
+      this.Amount = documentData.Amount;
+      this.Description = documentData.Description;
+      this.Status = documentData.Status;
+      this.IssuedById = documentData.IssuedById;
+      this.IssuedToId = documentData.IssuedToId;
+      this.IssuedToType = documentData.IssuedToType;
+      this.CreatedById = documentData.CreatedById;
+      this.CreatedAt = documentData.CreatedAt;
+      this.UpdatedById = documentData.UpdatedById;
+      this.UpdatedAt = documentData.UpdatedAt;
+      this.DocPDFFileMediaId = documentData.DocPDFFileMediaId;
+      this.DocHTMLFileMediaId = documentData.DocHTMLFileMediaId;
+      this.AccSystemRefId = documentData.AccSystemRefId;
+      this.PostedToAccSystemYN = documentData.PostedToAccSystemYN;
+      this.PostedById = documentData.PostedById;
+      this.PostedDateTime = documentData.PostedDateTime;
+      this.UseAccSystemDocYN = documentData.UseAccSystemDocYN;
+    } else {
+      const notFoundError = new RecordNotFoundError('No Record Found.');
+      throw notFoundError;
+    }
+  }
+
   public get DocumentItems() {
     // this._DocumentItems = new DocumentItem();
     if (this._DocumentItems === null) {
@@ -63,64 +169,124 @@ export class Document extends AccountSystemEntity {
     return this._DocumentItems;
   }
 
-  public get InvoiceInHTML() {
-    return (async () => {
-      this.DocHTMLFilePath = './invoice-template/index.html';
-      const readFileContent = util.promisify(fs.readFile);
-      const htmlBuffer = await readFileContent(this.DocHTMLFilePath);
-
-      const htmlStream: Express.Multer.File = {
-        buffer: htmlBuffer,
-        fieldname: 'FileStream',
-        originalname: 'index.html',
-        mimetype: 'text/html',
-        size: htmlBuffer.length,
-        encoding: '8bit',
-        filename: 'sample-invoice.html',
-        destination: '',
-        path: '',
-        stream: null,
-      };
-
-      return htmlStream;
-    })();
+  /**
+   * Returns HTML template file for invoice generation
+   *
+   * @see generateInvoice - for implementation
+   *
+   * @returns {Express.Multer.File} - HTML File
+   */
+  public static async DEFAULT_INVOICE_TEMPLATE_HTML(): Promise<Express.Multer.File> {
+    /* getting invoice template in HTML format */
+    const HTMLTemplateFilePath = './invoice-template/index.html';
+    const readFileContent = util.promisify(fs.readFile);
+    const htmlBuffer = await readFileContent(HTMLTemplateFilePath);
+
+    const htmlStream: Express.Multer.File = {
+      buffer: htmlBuffer,
+      fieldname: 'FileStream',
+      originalname: 'index.html',
+      mimetype: 'text/html',
+      size: htmlBuffer.length,
+      encoding: '8bit',
+      filename: 'sample-invoice.html',
+      destination: '',
+      path: '',
+      stream: null,
+    };
+
+    return htmlStream;
   }
 
-  public get InvoiceInPDF() {
+  /**
+   * Returns PDF template file for invoice generation
+   *
+   * @remarks - This function is converting generated HTML into PDF
+   *
+   * @see generateInvoice - for implementation
+   *
+   * @returns {Express.Multer.File} - PDF File
+   */
+  public static async DEFAULT_INVOICE_TEMPLATE_PDF(): Promise<Express.Multer.File> {
+    /* prepping HTML conversion by getting its URL and String */
+
+    /* todo: needs to generate HTML first before converting to PDF */
+    const HTMLTemplateFilePath = './invoice-template/index.html';
+    const readFileContent = util.promisify(fs.readFile);
+    const htmlString = await readFileContent(HTMLTemplateFilePath, 'utf8');
+
+    /* converting HTML to PDF */
+    const browser = await puppeteer.launch();
+    const page = await browser.newPage();
+
+    if (HTMLTemplateFilePath) {
+      await page.goto(HTMLTemplateFilePath, {
+        waitUntil: 'networkidle2',
+      });
+    } else if (htmlString) {
+      await page.setContent(htmlString);
+    } else {
+      await browser.close();
+    }
+
+    const pdfBuffer = await page.pdf({
+      format: 'a4',
+      printBackground: true,
+      margin: {
+        left: '0px',
+        top: '0px',
+        right: '0px',
+        bottom: '0px',
+      },
+    });
+
+    const pdfStream: Express.Multer.File = {
+      buffer: pdfBuffer,
+      fieldname: 'FileStream',
+      originalname: 'sample-invoice.pdf',
+      mimetype: 'application/pdf',
+      size: pdfBuffer.length,
+      encoding: '8bit',
+      filename: 'sample-invoice.pdf',
+      destination: '',
+      path: '',
+      stream: null,
+    };
+
+    return pdfStream;
+  }
+
+  /**
+   * Returns the media representing the document in HTML format
+   *
+   * @returns {MediasModel} - Invoice Media in HTML Format
+   */
+  public get DocumentFileInHTML(): Promise<MediasModel> {
     return (async () => {
-      this.DocPDFFilePath = './invoice-template/sample-invoice.pdf';
-      const readFileContent = util.promisify(fs.readFile);
-      const pdfBuffer = await readFileContent(this.DocPDFFilePath);
-
-      const pdfStream: Express.Multer.File = {
-        buffer: pdfBuffer,
-        fieldname: 'FileStream',
-        originalname: 'sample-invoice.[df]',
-        mimetype: 'application/pdf',
-        size: pdfBuffer.length,
-        encoding: '8bit',
-        filename: 'sample-invoice.pdf',
-        destination: '',
-        path: '',
-        stream: null,
-      };
-
-      return pdfStream;
+      const { HTMLMedia } = await this.generateInvoice();
+
+      return HTMLMedia;
     })();
   }
 
-  get objectId(): string {
-    return this.ObjectId;
-  }
-  get objectName(): string {
-    return this.ObjectName;
+  /**
+   * Returns the media representing the document in PDF format
+   *
+   * @returns {MediasModel} - Invoice Media in PDF Format
+   */
+  public get DocumentFileInPDF(): Promise<MediasModel> {
+    return (async () => {
+      const { PDFMedia } = await this.generateInvoice();
+
+      return PDFMedia;
+    })();
   }
 
   init(params: IDocumentAttr) {
     this.DocNo = params.DocNo;
     this.DocType = params.DocType;
     this.DocDate = params.DocDate;
-    this.SystemCode = params.SystemCode;
+    this.CompanyId = params.CompanyId;
     this.Currency = params.Currency;
     this.Amount = params.Amount;
     this.Description = params.Description;
@@ -128,50 +294,77 @@ export class Document extends AccountSystemEntity {
     this.IssuedById = params.IssuedById;
     this.IssuedToId = params.IssuedToId;
     this.IssuedToType = params.IssuedToType;
-    this.AccSystemCode = params.AccSystemCode;
+    this.CreatedById = params.CreatedById;
+    this.CreatedAt = params.CreatedAt;
+    this.UpdatedById = params.UpdatedById;
+    this.UpdatedAt = params.UpdatedAt;
+    this.DocPDFFileMediaId = params.DocPDFFileMediaId;
+    this.DocHTMLFileMediaId = params.DocHTMLFileMediaId;
+    this.AccSystemRefId = params.AccSystemRefId;
     this.PostedToAccSystemYN = params.PostedToAccSystemYN;
+    this.PostedById = params.PostedById;
+    this.PostedDateTime = params.PostedDateTime;
     this.UseAccSystemDocYN = params.UseAccSystemDocYN;
-    this.DocPDFFilePath = params.DocPDFFilePath;
-    this.DocHTMLFilePath = params.DocHTMLFilePath;
   }
 
-  async generateInvoice(userId?: string): Promise<void> {
+  /**
+   * Returns generated HTML & PDF Media
+   *
+   * @remarks - This function also create each media element in common_Media table
+   *
+   * @see DocumentFileInHTML - for implementation
+   * @see DocumentFileInPDF - for implementation
+   *
+   * @param userId - userId that trigger this function
+   * @returns {MediasModel} - HTML & PDF Media
+   */
+  async generateInvoice(userId?: string): Promise<{
+    HTMLMedia: MediasModel;
+    PDFMedia: MediasModel;
+  }> {
     const media: Medias = new Medias(
       this.mediaRepository,
       this.mediaCommonService,
     );
 
+    /* todo: needs to manipulate HTML DOM before uploading to media*/
+
+    /* insert FileStream on htmlPayload  */
     const htmlPayload: InternalMediaDto = {
       ObjectId: this.DocNo,
       ObjectType: this.DocType,
       Type: MediaType.Document,
       FileName: `${this.DocType}-${this.DocNo}`,
-      FileStream: '',
-      FileExtension: 'HTML',
+      FileStream: await Document.DEFAULT_INVOICE_TEMPLATE_HTML(),
+      FileExtension: 'html',
       Title: `${this.DocType}-${this.DocNo}.html`,
       Description: `HTML ${this.DocType}`,
       IsEncryptedYN: 'N',
     };
-    await media.postInternal(
-      await this.InvoiceInHTML,
+
+    /* create HTML media of the generated HTML */
+    const HTMLInvoiceMedia = await media.postInternal(
+      await Document.DEFAULT_INVOICE_TEMPLATE_HTML(),
       htmlPayload,
       userId ?? 'System',
     );
 
+    /* insert FileStream on pdfPayload  */
     const pdfPayload: InternalMediaDto = {
       ObjectId: this.DocNo,
       ObjectType: this.DocType,
       Type: MediaType.Document,
       FileName: `${this.DocType}-${this.DocNo}`,
-      FileStream: '',
-      FileExtension: 'PDF',
+      FileStream: await Document.DEFAULT_INVOICE_TEMPLATE_PDF(),
+      FileExtension: 'pdf',
       Title: `${this.DocType}-${this.DocNo}.pdf`,
       Description: `PDF ${this.DocType}`,
       IsEncryptedYN: 'N',
     };
 
-    await media.postInternal(
-      await this.InvoiceInPDF,
+    /* create PDF media from the converted HTML */
+    const PDFInvoiceMedia = await media.postInternal(
+      await Document.DEFAULT_INVOICE_TEMPLATE_PDF(),
       pdfPayload,
       userId ?? 'System',
     );
@@ -183,15 +376,27 @@ export class Document extends AccountSystemEntity {
         },
       });
 
-      document.DocHTMLFilePath = this.DocHTMLFilePath;
-      document.DocPDFFilePath = this.DocPDFFilePath;
+      /* storing HTML & PDF MediaId to finance_Document */
+      document.DocHTMLFileMediaId = HTMLInvoiceMedia.MediaId;
+      document.DocPDFFileMediaId = PDFInvoiceMedia.MediaId;
       await document.save();
     } catch (err) {
+      // tslint:disable-next-line:no-console
       console.log(err);
     }
+
+    return {
+      HTMLMedia: HTMLInvoiceMedia,
+      PDFMedia: PDFInvoiceMedia,
+    };
   }
 
-  async newDocumentItem() {
+  /**
+   * Create a new Document Item which is automatically added to the DocumentItems list
+   *
+   * @returns {DocumentItem}
+   */
+  async newDocumentItem(): Promise<DocumentItem> {
     const documentItem = new DocumentItem();
     documentItem.DocNo = this.DocNo;
     this.DocumentItems.push(documentItem);

package/src/document/interfaces/document-attr.interface.ts

@@ -4,7 +4,7 @@ export class IDocumentAttr {
   DocNo: string;
   DocType: DocType;
   DocDate: Date;
-  SystemCode: string;
+  CompanyId: string;
   Currency: string;
   Amount: number;
   Description: string;
@@ -12,9 +12,15 @@ export class IDocumentAttr {
   IssuedById: string;
   IssuedToId: string;
   IssuedToType: string;
-  AccSystemCode: string;
+  CreatedById: string;
+  CreatedAt: Date;
+  UpdatedById?: string;
+  UpdatedAt?: Date;
+  DocPDFFileMediaId?: string;
+  DocHTMLFileMediaId?: string;
+  AccSystemRefId?: string;
   PostedToAccSystemYN: string;
+  PostedById?: string;
+  PostedDateTime?: Date;
   UseAccSystemDocYN: string;
-  DocPDFFilePath: string;
-  DocHTMLFilePath: string;
 }

package/src/document/interfaces/document-item-attr.interface.ts

@@ -17,6 +17,6 @@ export class IDocumentItemAttr {
   TaxAmount?: number;
   TaxRate?: number;
   TaxInclusiveYN?: string;
-  DtAccountNo: string;
-  CtAccountNo: string;
+  DtAccountNo?: string;
+  CtAccountNo?: string;
 }

package/src/document/interfaces/document-item.repository.interface.ts

@@ -1,4 +1,4 @@
 import { IBaseRepository } from '@tomei/general';
-import { DocumentItemModel } from '../entities/document-item.entity';
+import DocumentItemModel from '../../models/document-item.entity';
 
 export type IDocumentItemRepository = IBaseRepository<DocumentItemModel>;

package/src/document/interfaces/document.repository.interface.ts

@@ -1,4 +1,4 @@
 import { IBaseRepository } from '@tomei/general';
-import { DocumentModel } from '../entities/document.entity'
+import DocumentModel from '../../models/document.entity';
 
 export type IDocumentRepository = IBaseRepository<DocumentModel>;

package/src/enum/doc-type.enum.ts

@@ -3,5 +3,6 @@ export enum DocType {
   DEBIT_NOTE = 'Debit Note',
   CREDIT_NOTE = 'Credit Note',
   QUOTATION = 'Quotation',
+  PURCHASEORDER = 'Purchase Order',
   RECEIPT = 'Receipt',
-}
+}

package/src/enum/document-status.enum.ts

@@ -1,4 +1,5 @@
 export enum DocumentStatus {
-  ACTIVE = 'Active',
-  CANCELED = 'Canceled',
+  UNPAID = 'Unpaid',
+  PAID = 'Paid',
+  CANCELLED = 'Cancelled',
 }

package/src/finance-company/finance-company.repository.ts

@@ -1,12 +1,11 @@
 import { BaseRepository, IBaseRepository } from '@tomei/general';
-import { FinanceCompanyModel } from './finance-company.entity';
+import FinanceCompanyModel from '../models/finance-company.entity';
 
 export class FinanceCompanyRepository
   extends BaseRepository<FinanceCompanyModel>
   implements IBaseRepository<FinanceCompanyModel>
 {
   constructor() {
-    const financeCompanyModel = new FinanceCompanyModel();
-    super(financeCompanyModel);
+    super(FinanceCompanyModel);
   }
 }