@tomei/finance 0.1.13 → 0.2.1

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

@@ -0,0 +1,136 @@
+import { LedgerTransactionRepository } from 'src/ledger-transaction/ledger-transaction.repository';
+import { LedgerTransaction } from 'src/ledger-transaction';
+import { ILedgerTransactionTypeOptionsAttr } from 'src/ledger-transaction/interfaces/ledger-transaction-attr.interface';
+import { JournalEntryRepository } from './journal-entry.repository';
+import { IJournalEntryAttr } from './interfaces/journal-entry-attr.interface';
+import { TransactionTypeOptions } from 'src/enum';
+import { Op } from 'sequelize';
+
+export class JournalEntry {
+  JournalEntryId: string;
+  Date: Date;
+  Name: string;
+  Description: string;
+  PostedById: string;
+  PostedToAccSystemYN: string;
+  DatePosted?: string;
+
+  journalEntryRepository: JournalEntryRepository;
+  ledgerTransactionRepository: LedgerTransactionRepository;
+
+  private _DebitTransactions: any = null;
+  private _CreditTransactions: any = null;
+
+  constructor(
+    journalEntryRepository: JournalEntryRepository,
+    ledgerTransactionRepository: LedgerTransactionRepository,
+  ) {
+    this.ledgerTransactionRepository = ledgerTransactionRepository;
+    this.journalEntryRepository = journalEntryRepository;
+  }
+
+  public get DebitTransactions() {
+    if (this._DebitTransactions === null) {
+      // this._DebitTransactions = new LedgerTransaction(
+      //   this.ledgerTransactionRepository,
+      // );
+      if (this.JournalEntryId !== 'New') {
+        this.ledgerTransactionRepository
+          .findAll({
+            where: {
+              JournalEntryId: {
+                [Op.ne]: 'New',
+              },
+              TransactionType: TransactionTypeOptions.Debit,
+            },
+          })
+          .then((allDebitTransactions) => {
+            return allDebitTransactions;
+          });
+      }
+    }
+
+    return this._DebitTransactions;
+  }
+
+  public get CreditTransactions() {
+    if (this._CreditTransactions === null) {
+      // this._CreditTransactions = new LedgerTransaction(
+      //   this.ledgerTransactionRepository,
+      // );
+      if (this.JournalEntryId !== 'New') {
+        this.ledgerTransactionRepository
+          .findAll({
+            where: {
+              JournalEntryId: {
+                [Op.ne]: 'New',
+              },
+              TransactionType: TransactionTypeOptions.Credit,
+            },
+          })
+          .then((allCreditTransactions) => {
+            return allCreditTransactions;
+          });
+      }
+    }
+
+    return this._CreditTransactions;
+  }
+
+  init(params: IJournalEntryAttr) {
+    this.JournalEntryId = params.JournalEntryId;
+    this.Date = params.Date;
+    this.Name = params.Name;
+    this.Description = params.Description;
+    this.PostedById = params.PostedById;
+    this.PostedToAccSystemYN = params.PostedToAccSystemYN;
+    this.DatePosted = params.DatePosted;
+  }
+
+  getData() {
+    return {
+      JournalEntryId: this.JournalEntryId,
+      Date: this.Date,
+      Name: this.Name,
+      Description: this.Description,
+      PostedById: this.PostedById,
+      PostedToAccSystemYN: this.PostedToAccSystemYN,
+      DatePosted: this.DatePosted,
+    };
+  }
+
+  async create() {
+    return await this.journalEntryRepository.create(this.getData);
+  }
+
+  async newLedgerTransaction({
+    transactionType,
+  }: ILedgerTransactionTypeOptionsAttr): Promise<any> {
+    this.init({
+      JournalEntryId: 'New',
+      Date: new Date(),
+      Name: '',
+      Description: '',
+      PostedById: '',
+      PostedToAccSystemYN: 'N',
+      DatePosted: null,
+    });
+
+    const ledgerTransaction = new LedgerTransaction(
+      this.ledgerTransactionRepository,
+    );
+
+    const newLedgerTransaction = await ledgerTransaction.newLedgerTransaction(
+      { transactionType },
+      this.JournalEntryId,
+    );
+
+    if (transactionType === TransactionTypeOptions.Debit) {
+      this.DebitTransactions;
+    } else if (transactionType === TransactionTypeOptions.Credit) {
+      this.CreditTransactions;
+    }
+
+    return newLedgerTransaction;
+  }
+}

package/src/ledger-transaction/entities/ledger-transaction.entity.ts

@@ -0,0 +1,134 @@
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  Column,
+  ForeignKey,
+  Model,
+  Table,
+  DataType,
+  BelongsTo,
+} from 'sequelize-typescript';
+import { AccountModel } from 'src/account';
+import { JournalEntryModel } from 'src/journal-entry/entities/journal-entry.entity';
+
+@Table({
+  tableName: 'finance_LedgerTransaction',
+  timestamps: false,
+})
+export class LedgerTransactionModel extends Model {
+  @ApiProperty({ type: String, description: 'Transactionid' })
+  @Column({
+    primaryKey: true,
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  TransactionId: string;
+
+  @ApiProperty({
+    type: String,
+    description: 'Transaction Type eg. "Credit", "Debit"',
+  })
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(20),
+  })
+  TransactionType: string;
+
+  @ApiProperty({ type: String, description: 'JournalEntryId' })
+  @ForeignKey(() => JournalEntryModel)
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  JournalEntryId: string;
+
+  @ApiProperty({ type: String, description: 'AccountNo' })
+  @ForeignKey(() => AccountModel)
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  AccountNo: string;
+
+  @ApiProperty({ type: Date, description: 'Date' })
+  @Column({
+    allowNull: false,
+    type: DataType.DATE,
+  })
+  Date: Date;
+
+  @ApiProperty({
+    type: String,
+    description: 'Name of the ledger transaction',
+  })
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(200),
+  })
+  Name: string;
+
+  @ApiProperty({
+    type: String,
+    description: 'Description of the ledger transaction',
+  })
+  @Column({
+    allowNull: true,
+    type: DataType.STRING(1000),
+  })
+  Description: string;
+
+  @ApiProperty({
+    type: String,
+    description: 'Currency',
+  })
+  @Column({
+    allowNull: false,
+    type: DataType.CHAR(3),
+  })
+  Currency: string;
+
+  @ApiProperty({
+    type: Number,
+    description: 'Debit Amount of the ledger transaction',
+  })
+  @Column({
+    allowNull: true,
+    type: DataType.DECIMAL(10, 2),
+  })
+  DebitAmount: number;
+
+  @ApiProperty({
+    type: Number,
+    description: 'Credit Amount of the ledger transaction',
+  })
+  @Column({
+    allowNull: true,
+    type: DataType.DECIMAL(10, 2),
+  })
+  CreditAmount: number;
+
+  @ApiProperty({
+    type: String,
+    description: 'RelatedObjectId',
+  })
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  RelatedObjectId: string;
+
+  @ApiProperty({
+    type: String,
+    description: 'RelatedObjectType',
+  })
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(200),
+  })
+  RelatedObjectType: string;
+
+  @BelongsTo(() => AccountModel)
+  Account: AccountModel;
+
+  @BelongsTo(() => JournalEntryModel)
+  JournalEntry: JournalEntryModel;
+}

package/src/ledger-transaction/index.ts

@@ -0,0 +1,13 @@
+import { LedgerTransaction } from './ledger-transaction';
+import { LedgerTransactionModel } from './entities/ledger-transaction.entity';
+import { ILedgerTransactionAttr } from './interfaces/ledger-transaction-attr.interface';
+import { ILedgerTransactionRepository } from './interfaces/ledger-transaction.repository.interface';
+import { LedgerTransactionRepository } from './ledger-transaction.repository';
+
+export {
+  ILedgerTransactionRepository,
+  LedgerTransaction,
+  LedgerTransactionModel,
+  ILedgerTransactionAttr,
+  LedgerTransactionRepository,
+};

package/src/ledger-transaction/interfaces/ledger-transaction-attr.interface.ts

@@ -0,0 +1,20 @@
+import { TransactionTypeOptions } from 'src/enum/transaction-type.enum';
+
+export interface ILedgerTransactionAttr {
+  TransactionId: string;
+  TransactionType: string;
+  JournalEntryId: string;
+  AccountNo: string;
+  Date: Date;
+  Name: string;
+  Description: string;
+  Currency: string;
+  DebitAmount: number;
+  CreditAmount: number;
+  RelatedObjectId: string;
+  RelatedObjectType: string;
+}
+
+export interface ILedgerTransactionTypeOptionsAttr {
+  transactionType: TransactionTypeOptions;
+}

package/src/ledger-transaction/interfaces/ledger-transaction.repository.interface.ts

@@ -0,0 +1,7 @@
+export interface ILedgerTransactionRepository<T> {
+  create?(data: T | any, options?: any): Promise<T> | any;
+
+  findAll?(options?: any): Promise<T[]>;
+
+  findOne?(options: any): Promise<T>;
+}

package/src/ledger-transaction/ledger-transaction.repository.ts

@@ -0,0 +1,28 @@
+import { InjectModel } from '@nestjs/sequelize';
+import { LedgerTransactionModel } from './entities/ledger-transaction.entity';
+import { ILedgerTransactionAttr } from './interfaces/ledger-transaction-attr.interface';
+import { ILedgerTransactionRepository } from './interfaces/ledger-transaction.repository.interface';
+
+export class LedgerTransactionRepository
+  implements ILedgerTransactionRepository<LedgerTransactionModel>
+{
+  constructor(
+    @InjectModel(LedgerTransactionModel)
+    private readonly ledgerTransactionModel: typeof LedgerTransactionModel,
+  ) {}
+
+  create(
+    data: ILedgerTransactionAttr | any,
+    options?: any,
+  ): Promise<LedgerTransactionModel> | any {
+    return this.ledgerTransactionModel.create(data, options);
+  }
+
+  findAll(options?: any): Promise<LedgerTransactionModel[]> {
+    return this.ledgerTransactionModel.findAll(options);
+  }
+
+  findOne(options: any): Promise<LedgerTransactionModel> | any {
+    return this.ledgerTransactionModel.findOne(options);
+  }
+}

package/src/ledger-transaction/ledger-transaction.ts

@@ -0,0 +1,96 @@
+import {
+  ILedgerTransactionAttr,
+  ILedgerTransactionTypeOptionsAttr,
+} from './interfaces/ledger-transaction-attr.interface';
+import { TransactionTypeOptions } from 'src/enum/transaction-type.enum';
+import { LedgerTransactionRepository } from './ledger-transaction.repository';
+import * as uniqid from 'uniqid';
+
+export class LedgerTransaction {
+  TransactionId: string;
+  JournalEntryId: string;
+  AccountNo: string;
+  Date: Date;
+  Name: string;
+  Description: string;
+  Currency: string;
+  DebitAmount: number;
+  CreditAmount: number;
+  RelatedObjectId: string;
+  RelatedObjectType: string;
+
+  TransactionType: string;
+
+  ledgerTransactionRepository: LedgerTransactionRepository;
+  constructor(ledgerTransactionRepository: LedgerTransactionRepository) {
+    this.ledgerTransactionRepository = ledgerTransactionRepository;
+  }
+
+  init(params?: ILedgerTransactionAttr) {
+    this.TransactionId = params.TransactionId;
+    this.TransactionType = params.TransactionType;
+    this.JournalEntryId = params.JournalEntryId;
+    this.AccountNo = params.AccountNo;
+    this.Date = params.Date;
+    this.Name = params.Name;
+    this.Description = params.Description;
+    this.Currency = params.Currency;
+    this.DebitAmount = params.DebitAmount;
+    this.CreditAmount = params.CreditAmount;
+    this.RelatedObjectId = params.RelatedObjectId;
+    this.RelatedObjectType = params.RelatedObjectType;
+  }
+
+  getData() {
+    return {
+      TransactionId: this.TransactionId,
+      TransactionType: this.TransactionType,
+      JournalEntryId: this.JournalEntryId,
+      AccountNo: this.AccountNo,
+      Date: this.Date,
+      Name: this.Name,
+      Description: this.Description,
+      Currency: this.Currency,
+      DebitAmount: this.DebitAmount,
+      CreditAmount: this.CreditAmount,
+      RelatedObjectId: this.RelatedObjectId,
+      RelatedObjectType: this.RelatedObjectType,
+    };
+  }
+
+  async create() {
+    return await this.ledgerTransactionRepository.create(this.getData);
+  }
+
+  async newLedgerTransaction(
+    { transactionType }: ILedgerTransactionTypeOptionsAttr,
+    journalEntryId?: string,
+  ): Promise<any> {
+    this.init({
+      TransactionId: uniqid(),
+      TransactionType: 'Debit',
+      JournalEntryId: '',
+      AccountNo: '',
+      Date: new Date(),
+      Name: '',
+      Description: '',
+      Currency: 'MYR',
+      DebitAmount: 0,
+      CreditAmount: 0,
+      RelatedObjectId: '',
+      RelatedObjectType: '',
+    });
+
+    if (transactionType === TransactionTypeOptions.Debit) {
+      this.TransactionType = 'Debit';
+    } else if (transactionType === TransactionTypeOptions.Credit) {
+      this.TransactionType = 'Credit';
+    }
+
+    if (journalEntryId) {
+      this.JournalEntryId = journalEntryId;
+    }
+
+    return await this.create();
+  }
+}