@tomei/finance 0.2.3 → 0.2.5

package/src/document/document.ts

@@ -0,0 +1,167 @@
+import * as util from 'util';
+import * as fs from 'fs';
+import { ObjectBase } from '@tomei/general';
+import {
+  Medias,
+  InternalMediaDto,
+  IMediasRepository,
+  CommonService as MediaCommonService,
+  MediaType,
+} from '@tomei/media';
+import { DocumentStatus, DocType } from 'src/enum';
+import { DocumentRepository } from './document.repository';
+import { IDocumentAttr } from './interfaces/document-attr.interface';
+
+export class Document extends ObjectBase {
+  ObjectId: string;
+  ObjectName: string;
+
+  DocNo: string;
+  DocType: DocType;
+  DocDate: Date;
+  SystemCode: string;
+  Currency: string;
+  Amount: number;
+  Description: string;
+  Status: DocumentStatus;
+  IssuedById: string;
+  IssuedToId: string;
+  IssuedToType: string;
+  AccSystemCode: string;
+  PostedToAccYN: string;
+  UseAccSystemDocYN: string;
+  private DocHTMLFilePath: string;
+  private DocPDFFilePath: string;
+
+  documentRepository: DocumentRepository;
+  mediaRepository: IMediasRepository;
+  mediaCommonService: MediaCommonService;
+
+  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;
+    })();
+  }
+
+  public get InvoiceInPDF() {
+    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;
+    })();
+  }
+
+  get objectId(): string {
+    return this.ObjectId;
+  }
+  get objectName(): string {
+    return this.ObjectName;
+  }
+
+  init(params: IDocumentAttr) {
+    this.DocNo = params.DocNo;
+    this.DocType = params.DocType;
+    this.DocDate = params.DocDate;
+    this.SystemCode = params.SystemCode;
+    this.Currency = params.Currency;
+    this.Amount = params.Amount;
+    this.Description = params.Description;
+    this.Status = params.Status;
+    this.IssuedById = params.IssuedById;
+    this.IssuedToId = params.IssuedToId;
+    this.IssuedToType = params.IssuedToType;
+    this.AccSystemCode = params.AccSystemCode;
+    this.PostedToAccYN = params.PostedToAccYN;
+    this.UseAccSystemDocYN = params.UseAccSystemDocYN;
+    this.DocPDFFilePath = params.DocPDFFilePath;
+    this.DocHTMLFilePath = params.DocHTMLFilePath;
+  }
+
+  async generateInvoice(userId?: string): Promise<void> {
+    const media: Medias = new Medias(
+      this.mediaRepository,
+      this.mediaCommonService,
+    );
+
+    const htmlPayload: InternalMediaDto = {
+      ObjectId: this.DocNo,
+      ObjectType: this.DocType,
+      Type: MediaType.Document,
+      FileName: `${this.DocType}-${this.DocNo}`,
+      FileStream: '',
+      FileExtension: 'HTML',
+      Title: `${this.DocType}-${this.DocNo}.html`,
+      Description: `HTML ${this.DocType}`,
+      IsEncryptedYN: 'N',
+    };
+    await media.postInternal(
+      await this.InvoiceInHTML,
+      htmlPayload,
+      userId ?? 'System',
+    );
+
+    const pdfPayload: InternalMediaDto = {
+      ObjectId: this.DocNo,
+      ObjectType: this.DocType,
+      Type: MediaType.Document,
+      FileName: `${this.DocType}-${this.DocNo}`,
+      FileStream: '',
+      FileExtension: 'PDF',
+      Title: `${this.DocType}-${this.DocNo}.pdf`,
+      Description: `PDF ${this.DocType}`,
+      IsEncryptedYN: 'N',
+    };
+
+    await media.postInternal(
+      await this.InvoiceInPDF,
+      pdfPayload,
+      userId ?? 'System',
+    );
+
+    try {
+      const document = await this.documentRepository.findOne({
+        where: {
+          DocNo: this.DocNo,
+        },
+      });
+
+      document.DocHTMLFilePath = this.DocHTMLFilePath;
+      document.DocPDFFilePath = this.DocPDFFilePath;
+      await document.save();
+    } catch (err) {
+      console.log(err);
+    }
+  }
+}

package/src/document/entities/document.entity.ts

@@ -1,5 +1,5 @@
 import { Column, DataType, HasMany, Model, Table } from 'sequelize-typescript';
-import { DocumentType, DocumentStatus } from '../../enum';
+import { DocType, DocumentStatus } from '../../enum';
 import { DocumentItemModel } from './document-item.entity';
 
 @Table({ tableName: 'finance_Document', timestamps: false })
@@ -15,7 +15,7 @@ export class DocumentModel extends Model {
     allowNull: false,
     type: DataType.STRING(30),
   })
-  DocType: DocumentType;
+  DocType: DocType;
 
   @Column({
     allowNull: false,

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

@@ -1,8 +1,8 @@
-import { DocumentType, DocumentStatus } from '../../enum';
+import { DocType, DocumentStatus } from '../../enum';
 
 export class IDocumentAttr {
   DocNo: string;
-  DocType: DocumentType;
+  DocType: DocType;
   DocDate: Date;
   SystemCode: string;
   Currency: string;

package/src/enum/{document-type.enum.ts → doc-type.enum.ts}

@@ -1,7 +1,7 @@
-export enum DocumentType {
+export enum DocType {
   INVOICE = 'Invoice',
   DEBIT_NOTE = 'Debit Note',
   CREDIT_NOTE = 'Credit Note',
   QUOTATION = 'Quotation',
   RECEIPT = 'Receipt',
-}
+}

package/src/enum/index.ts

@@ -2,7 +2,7 @@ import { ClientScopes } from './quick-book-client-scopes.enum';
 import { PaymentType } from './payment-type.enum';
 import { PaymentMethod } from './payment-method.enum';
 import { TransactionTypeOptions } from './transaction-type.enum';
-import { DocumentType } from './document-type.enum';
+import { DocType } from './doc-type.enum';
 import { DocumentStatus } from './document-status.enum';
 
 export {
@@ -10,6 +10,6 @@ export {
   PaymentType,
   PaymentMethod,
   TransactionTypeOptions,
-  DocumentType,
+  DocType,
   DocumentStatus,
 };

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

@@ -2,96 +2,92 @@ import { BadRequestException } from '@nestjs/common';
 import { IAccountSystem } from 'src/interfaces';
 import { JournalEntry, JournalEntryRepository } from 'src/journal-entry';
 import { LedgerTransactionRepository } from 'src/ledger-transaction';
-import * as uniqid from 'uniqid';
 import axios from 'axios';
-import { JournalEntryModel } from 'src/journal-entry';
 import { Account } from 'src/account';
+import { CompanyBase, PersonBase } from '@tomei/general';
 
 export class FinanceCompany {
   journalEntryRepository: JournalEntryRepository;
   ledgerTransactionRepository: LedgerTransactionRepository;
-
   accountingSystem: IAccountSystem;
 
+  private SystemCode: string;
+  private AccSystemCode: string;
+  private Company: CompanyBase;
+  private LoginUser: PersonBase;
+
   constructor(
-    journalEntryRepository: JournalEntryRepository,
-    ledgerTransactionRepository: LedgerTransactionRepository,
-    accountingSystem: IAccountSystem,
+    company: CompanyBase,
+    systemCode: string,
+    accSystemCode: string,
+    loginUser: PersonBase,
   ) {
-    this.ledgerTransactionRepository = ledgerTransactionRepository;
-    this.journalEntryRepository = journalEntryRepository;
-    this.accountingSystem = accountingSystem;
-  }
-
-  async postJournal(journalEntryId: string, userId: string): Promise<any> {
-    const journalEntry = new JournalEntry(
-      this.journalEntryRepository,
-      this.ledgerTransactionRepository,
-    );
-
-    if (
-      journalEntry.CreditTransactions?.length < 1 ||
-      journalEntry.DebitTransactions?.length < 1
-    ) {
-      throw new BadRequestException(
-        'There should be at least 1 debit ledger transaction and 1 credit ledger transaction in the journal entry',
-      );
+    this.SystemCode = systemCode;
+    this.AccSystemCode = accSystemCode;
+    if (company != null && company.ObjectId == '') {
+      this.Company = company;
+    } else {
+      throw new BadRequestException('Company cannot be null');
     }
 
-    if (
-      journalEntry.CreditTransactions?.length !==
-      journalEntry.DebitTransactions?.length
-    ) {
-      throw new BadRequestException(
-        'Credit ledger transaction and debit ledger transaction should the same amount',
-      );
+    if (loginUser != null && loginUser.ObjectId == '') {
+      this.LoginUser = loginUser;
+    } else {
+      throw new BadRequestException('Login user cannot be null');
     }
+  }
 
-    const matchingJournalEntry = await this.journalEntryRepository.findOne({
-      where: {
-        JournalEntryId: journalEntryId,
-      },
-    });
+  async postJournal(dbTransaction: any, journalEntry: JournalEntry) {
+    try {
+      if (
+        journalEntry.CreditTransactions?.length < 1 ||
+        journalEntry.DebitTransactions?.length < 1
+      ) {
+        throw new BadRequestException(
+          'There should be at least 1 debit ledger transaction and 1 credit ledger transaction in the journal entry',
+        );
+      }
 
-    matchingJournalEntry.PostedById = userId;
-    await matchingJournalEntry.save();
+      if (
+        journalEntry.CreditTransactions?.length !==
+        journalEntry.DebitTransactions?.length
+      ) {
+        throw new BadRequestException(
+          'Credit ledger transaction and debit ledger transaction should the same amount',
+        );
+      }
 
-    const allLedgerTransactions =
-      await this.ledgerTransactionRepository.findAll();
+      const newJournalEntry = await journalEntry.save('test', dbTransaction);
 
-    for (const ledgerTransaction of allLedgerTransactions) {
-      ledgerTransaction.JournalEntryId = journalEntryId;
-      ledgerTransaction.save();
-    }
+      const allLedgerTransactions =
+        await this.ledgerTransactionRepository.findAll();
+
+      for (const ledgerTransaction of allLedgerTransactions) {
+        ledgerTransaction.JournalEntryId = newJournalEntry.JournalEntryId;
+        ledgerTransaction.save();
+      }
+
+      await this.accountingSystem.postJournalEntry(newJournalEntry);
 
-    journalEntry.init({
-      JournalEntryId: uniqid(),
-      Date: new Date(),
-      Name: '',
-      Description: '',
-      PostedById: userId,
-      PostedToAccSystemYN: 'N',
-      DatePosted: null,
-    });
-
-    await this.accountingSystem.postJournalEntry(matchingJournalEntry);
-
-    const payload = {
-      Action: 'Create',
-      Activity: 'Post Journal Entry',
-      Description: `Journal Entry (ID: ${matchingJournalEntry.JournalEntryId}) has been created`,
-      EntityType: typeof JournalEntryModel,
-      EntityValueBefore: JSON.stringify({}),
-      EntityValueAfter: JSON.stringify(matchingJournalEntry),
-      PerformedById: userId,
-      PerformedAt: new Date(),
-      EntityId: matchingJournalEntry.JournalEntryId,
-    };
-
-    await axios.post(
-      `${process.env.COMMON_API_URL}/activity-histories`,
-      payload,
-    );
+      const payload = {
+        Action: 'Create',
+        Activity: 'Post Journal Entry',
+        Description: `Journal Entry (ID: ${newJournalEntry.JournalEntryId}) has been created`,
+        EntityType: 'JournalEntry',
+        EntityValueBefore: JSON.stringify({}),
+        EntityValueAfter: JSON.stringify(newJournalEntry),
+        PerformedById: 'test',
+        PerformedAt: new Date(),
+        EntityId: newJournalEntry.JournalEntryId,
+      };
+
+      await axios.post(
+        `${process.env.COMMON_API_URL}/activity-histories`,
+        payload,
+      );
+    } catch (error) {
+      throw error;
+    }
   }
 
   async createAccount(dbTransaction: any, account: Account) {

package/src/interfaces/account-system-entity.interface.ts

@@ -0,0 +1,7 @@
+export interface IAccountSystemEntity {
+  AccSystemCode: string;
+  PostedToAccSystemYN: string;
+  AccSystemRefId: string;
+  PostedById: string;
+  PostedDateTime: Date;
+}

package/src/interfaces/index.ts

@@ -1,3 +1,3 @@
-import { IAccountSystem } from '../interfaces/account-system.interface';
-
-export { IAccountSystem };
+import { IAccountSystem } from '../interfaces/account-system.interface';
+
+export { IAccountSystem };

package/src/journal-entry/journal-entry.ts

@@ -5,6 +5,7 @@ import { JournalEntryRepository } from './journal-entry.repository';
 import { IJournalEntryAttr } from './interfaces/journal-entry-attr.interface';
 import { TransactionTypeOptions } from 'src/enum';
 import { Op } from 'sequelize';
+import { JournalEntryModel } from './entities/journal-entry.entity';
 
 export class JournalEntry {
   JournalEntryId: string;
@@ -22,8 +23,8 @@ export class JournalEntry {
   private _CreditTransactions: any = null;
 
   constructor(
-    journalEntryRepository: JournalEntryRepository,
-    ledgerTransactionRepository: LedgerTransactionRepository,
+    journalEntryRepository?: JournalEntryRepository,
+    ledgerTransactionRepository?: LedgerTransactionRepository,
   ) {
     this.ledgerTransactionRepository = ledgerTransactionRepository;
     this.journalEntryRepository = journalEntryRepository;
@@ -103,6 +104,22 @@ export class JournalEntry {
     return await this.journalEntryRepository.create(this.getData);
   }
 
+  async save(userId: string, dbTransaction?: any): Promise<JournalEntryModel> {
+    const data = await this.journalEntryRepository.create(
+      {
+        JournalEntryId: this.JournalEntryId,
+        Date: this.Date,
+        Name: this.Name,
+        Description: this.Description,
+        PostedById: userId,
+        PostedToAccSystemYN: this.PostedToAccSystemYN,
+        DatePosted: this.DatePosted,
+      },
+      dbTransaction,
+    );
+    return data;
+  }
+
   async newLedgerTransaction({
     transactionType,
   }: ILedgerTransactionTypeOptionsAttr): Promise<any> {