@tomei/finance 0.6.112 → 0.8.0

package/src/helpers/login-user.ts

@@ -1,38 +0,0 @@
-import { LoginUserBase } from '@tomei/general';
-
-export class LoginUser extends LoginUserBase {
-  ObjectId: string;
-  ObjectName: string;
-  TableName: string;
-  Roles: string[];
-  Privileges: string[];
-  private _ObjectType: 'LoginUser';
-
-  get ObjectType() {
-    return this._ObjectType;
-  }
-
-  checkPrivileges(
-    SystemCode: string,
-    PrivilegeName: string,
-  ): boolean | Promise<boolean> {
-    if (this.Privileges.includes(PrivilegeName)) {
-      return true;
-    }
-    return false;
-  }
-
-  CheckRole(SystemCode: string, RoleName: string): boolean | Promise<boolean> {
-    if (this.Roles.includes(RoleName)) {
-      return true;
-    }
-    return false;
-  }
-
-  constructor(objectId: string, objectName: string, tableName: string) {
-    super();
-    this.ObjectId = objectId;
-    this.ObjectName = objectName;
-    this.TableName = tableName;
-  }
-}

package/src/helpers/typeof.ts

@@ -1,35 +0,0 @@
-export function type(value: any): string {
-  if (value === null) {
-    return 'null';
-  }
-
-  const baseType = typeof value;
-
-  if (!['object', 'function'].includes(baseType)) {
-    return baseType;
-  }
-
-  // if value is object and have propery ObjectType: string return ObjectType instead.
-  if (baseType === 'object' && value.ObjectType) {
-    return value.ObjectType;
-  }
-
-  const tag = value[Symbol.toStringTag];
-  if (typeof tag === 'string') {
-    return tag;
-  }
-
-  if (
-    baseType === 'function' &&
-    Function.prototype.toString.call(value).startsWith('class')
-  ) {
-    return Function.prototype.toString.call(value).split(' ')[1];
-  }
-
-  const className = value.constructor.name;
-  if (typeof className === 'string' && className !== '') {
-    return className;
-  }
-
-  return baseType;
-}

package/src/index.ts

@@ -1,32 +0,0 @@
-import Account from './account/account';
-import FinanceCompany from './finance-company/finance-company';
-import FinanceCustomerBase from './customer/customer';
-import Document from './document/document';
-import DocumentItem from './document/document-item';
-import JournalEntry from './journal-entry/journal-entry';
-import LedgerTransaction from './ledger-transaction/ledger-transaction';
-import Payment from './payment/payment';
-import PaymentItem from './payment-item/payment-item';
-import PaymentMethod from './payment-method/payment-method';
-import PaymentMethodType from './payment-method-type/payment-method-type';
-import PaymentPaidWith from './payment-paid-with/payment-paid-with';
-import { TestDocument } from './test-document';
-
-export {
-  FinanceCompany,
-  Account,
-  FinanceCustomerBase,
-  Document,
-  DocumentItem,
-  JournalEntry,
-  LedgerTransaction,
-  Payment,
-  PaymentItem,
-  PaymentMethod,
-  PaymentMethodType,
-  PaymentPaidWith,
-  TestDocument,
-};
-export * as FinanceEnum from './enum';
-export * as FinanceInterfaces from './interfaces';
-export * as FinanceDb from './database';

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

@@ -1,51 +0,0 @@
-import Payment from '../payment/payment';
-import FinanceCustomerBase from '../customer/customer';
-import Account from '../account/account';
-import JournalEntry from '../journal-entry/journal-entry';
-import Document from '../document/document';
-import { DocumentStatus } from '../enum/document-status.enum';
-
-export interface IAccountSystem {
-  createAccount(Account: Account, dbTransaction?: any): Promise<string>;
-  createInvoice(
-    payload: {
-      customer: FinanceCustomerBase;
-      invoice: Document;
-      paymentMode: 'cash' | 'credit';
-    },
-    dbTransaction?: any,
-  ): Promise<{
-    invoiceRefId: string;
-    invoiceItems: {
-      name: string;
-      itemRefId: string;
-    }[];
-    invoiceNo: string;
-  }>;
-  createDebitNote(payload: any, dbTransaction?: any): Promise<any>;
-  createCreditNote(payload: any, dbTransaction?: any): Promise<any>;
-  postTransaction(
-    journalEntry: JournalEntry,
-    dbTransaction?: any,
-  ): Promise<any>;
-  createCustomer(
-    customer: FinanceCustomerBase,
-    dbTransaction?: any,
-  ): Promise<string>;
-  updateCustomer(
-    customer: FinanceCustomerBase,
-    dbTransaction?: any,
-  ): Promise<any>;
-  makePayment(
-    customer: FinanceCustomerBase,
-    paymentInfo: Payment,
-    dbTransaction?: any,
-  ): Promise<string>;
-  collectPayments(
-    customer: FinanceCustomerBase,
-    paymentInfo: Payment,
-    dbTransaction?: any,
-  ): Promise<string>;
-  postJournalEntry(payload: any): Promise<string>;
-  getInvoiceStatus(AccSystemRefId: any): Promise<DocumentStatus>;
-}

package/src/interfaces/index.ts

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

package/src/journal-entry/interfaces/journal-entry-attr.interface.ts

@@ -1,12 +0,0 @@
-export interface IJournalEntryAttr {
-  CompanyId?: string;
-  JournalEntryId?: string;
-  Date?: Date;
-  Name?: string;
-  Description?: string;
-  AccSystemRefId?: string;
-  PostedToAccSystemYN?: string;
-  PostedById?: string;
-  PostedDateTime?: Date;
-  dbTransaction?: any;
-}

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

@@ -1,17 +0,0 @@
-import { RepositoryBase, IRepositoryBase } from '@tomei/general';
-import JournalEntryModel from '../models/journal-entry.entity';
-
-export class JournalEntryRepository
-  extends RepositoryBase<JournalEntryModel>
-  implements IRepositoryBase<JournalEntryModel>
-{
-  constructor() {
-    super(JournalEntryModel);
-  }
-
-  async count(dbTransaction?: any) {
-    return await JournalEntryModel.count({
-      transaction: dbTransaction,
-    });
-  }
-}

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

@@ -1,264 +0,0 @@
-import { IJournalEntryAttr } from './interfaces/journal-entry-attr.interface';
-import { TransactionTypeOptions } from '../enum';
-import JournalEntryModel from '../models/journal-entry.entity';
-import { AccountSystemEntity } from '../account-system-entity/account-system-entity';
-import { LedgerTransactionRepository } from '../ledger-transaction/ledger-transaction.repository';
-import LedgerTransaction from '../ledger-transaction/ledger-transaction';
-import { JournalEntryRepository } from './journal-entry.repository';
-import { RecordNotFoundError } from '@tomei/general/dist/class/exceptions/record-not-found.error';
-
-export default class JournalEntry extends AccountSystemEntity {
-  private _JournalEntryId = 'New';
-  Date = new Date();
-  Name = '';
-  Description = '';
-  protected _ObjectType: 'JournalEntry';
-
-  private static _RepositoryBase = new JournalEntryRepository();
-  private static _LedgerTransactionRepository =
-    new LedgerTransactionRepository();
-
-  private _DbTransaction: any;
-  private _DebitTransactions: LedgerTransaction[] = [];
-  private _CreditTransactions: LedgerTransaction[] = [];
-
-  get JournalEntryId() {
-    return this._JournalEntryId;
-  }
-
-  private set JournalEntryId(id: string) {
-    this._JournalEntryId = id;
-  }
-
-  get ObjectType() {
-    return this._ObjectType;
-  }
-
-  get RepositoryBase() {
-    return JournalEntry._RepositoryBase;
-  }
-
-  get TableName() {
-    return 'finance_JournalEntry';
-  }
-
-  get ObjectName() {
-    return this.Name;
-  }
-
-  get ObjectId() {
-    return this._JournalEntryId;
-  }
-
-  constructor(dbTransaction?: any, journalEntryId?: string) {
-    super();
-    if (dbTransaction) {
-      this._DbTransaction = dbTransaction;
-    }
-    if (!journalEntryId) {
-      this.init({
-        JournalEntryId: 'New',
-        CompanyId: '',
-        Date: new Date(),
-        Name: '',
-        Description: '',
-        AccSystemRefId: '',
-        PostedToAccSystemYN: 'N',
-        PostedById: '',
-        PostedDateTime: null,
-      });
-    }
-  }
-
-  public static async initJournalEntry(
-    dbTransaction?: any,
-    journalEntryId?: string,
-  ): Promise<JournalEntry> {
-    try {
-      if (journalEntryId) {
-        const journalEntryData = await JournalEntry._RepositoryBase.findOne({
-          where: {
-            JournalEntryId: journalEntryId,
-          },
-          transaction: dbTransaction,
-        });
-
-        if (journalEntryData) {
-          const journalEntry = new JournalEntry();
-          journalEntry.init({
-            JournalEntryId: journalEntryData.JournalEntryId,
-            CompanyId: journalEntryData.CompanyId,
-            Date: new Date(),
-            Name: journalEntryData.Name,
-            Description: journalEntryData.Description,
-            AccSystemRefId: journalEntryData.AccSystemRefId,
-            PostedToAccSystemYN: journalEntryData.PostedToAccSystemYN,
-            PostedById: journalEntryData.PostedById,
-            PostedDateTime: journalEntryData.PostedDateTime,
-          });
-
-          return journalEntry;
-        } else {
-          const notFoundError = new RecordNotFoundError(
-            'JournalEntryErrMsg',
-            'No Record Found.',
-          );
-          throw notFoundError;
-        }
-      } else {
-        const journalEntry = new JournalEntry(dbTransaction);
-
-        return journalEntry;
-      }
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  get DebitTransactions(): Promise<LedgerTransaction[]> {
-    return new Promise((resolve, reject) => {
-      if (this.JournalEntryId !== 'New') {
-        JournalEntry._LedgerTransactionRepository
-          .findAll({
-            where: {
-              TransactionType: TransactionTypeOptions.DEBIT,
-            },
-            transaction: this._DbTransaction,
-          })
-          .then((debitTransactions) => {
-            const debitTransactionObjects = debitTransactions.map(
-              (debitTransactionData) =>
-                new LedgerTransaction(
-                  this._DbTransaction,
-                  debitTransactionData.LedgerNo,
-                ),
-            );
-            return Promise.all(debitTransactionObjects);
-          })
-          .then((debitTransactionObjects) => {
-            this._DebitTransactions = debitTransactionObjects;
-            resolve(this._DebitTransactions);
-          })
-          .catch((err) => {
-            reject(err);
-          });
-      } else {
-        resolve(this._DebitTransactions);
-      }
-    });
-  }
-
-  get CreditTransactions(): Promise<LedgerTransaction[]> {
-    return new Promise((resolve, reject) => {
-      if (this.JournalEntryId !== 'New') {
-        JournalEntry._LedgerTransactionRepository
-          .findAll({
-            where: {
-              TransactionType: TransactionTypeOptions.CREDIT,
-            },
-            transaction: this._DbTransaction,
-          })
-          .then((creditTransaction) => {
-            const creditTransactionObjects = creditTransaction.map(
-              (creditTransactionData) =>
-                new LedgerTransaction(
-                  this._DbTransaction,
-                  creditTransactionData.LedgerNo,
-                ),
-            );
-            return Promise.all(creditTransactionObjects);
-          })
-          .then((creditTransactionObjects) => {
-            this._CreditTransactions = creditTransactionObjects;
-            resolve(this._CreditTransactions);
-          })
-          .catch((err) => {
-            reject(err);
-          });
-      } else {
-        resolve(this._CreditTransactions);
-      }
-    });
-  }
-
-  init(params: IJournalEntryAttr) {
-    if (params.JournalEntryId) this.JournalEntryId = params.JournalEntryId;
-    if (params.CompanyId) this.CompanyId = params.CompanyId;
-    if (params.Date) this.Date = params.Date;
-    if (params.Name) this.Name = params.Name;
-    if (params.Description) this.Description = params.Description;
-    if (params.PostedById) this.PostedById = params.PostedById;
-    if (params.PostedToAccSystemYN)
-      this.PostedToAccSystemYN = params.PostedToAccSystemYN;
-    if (params.PostedDateTime) this.PostedDateTime = params.PostedDateTime;
-  }
-
-  getData() {
-    return {
-      JournalEntryId: this.JournalEntryId,
-      Date: this.Date,
-      Name: this.Name,
-      Description: this.Description,
-      PostedById: this.PostedById,
-      PostedToAccSystemYN: this.PostedToAccSystemYN,
-      PostedDateTime: this.PostedDateTime,
-    };
-  }
-
-  async create(dbTransaction?: any) {
-    return await this.RepositoryBase.create(this.getData, {
-      transaction: dbTransaction,
-    });
-  }
-
-  async save(userId: string, dbTransaction?: any): Promise<JournalEntryModel> {
-    try {
-      const count = await this.RepositoryBase.count(dbTransaction);
-      this.JournalEntryId = `${count + 1}`;
-
-      const data = await this.RepositoryBase.create(
-        {
-          JournalEntryId: this.JournalEntryId,
-          CompanyId: this.CompanyId,
-          Date: this.Date,
-          Name: this.Name,
-          Description: this.Description,
-          PostedById: this.PostedToAccSystemYN == 'Y' ? userId : null,
-          PostedToAccSystemYN: this.PostedToAccSystemYN,
-          PostedDateTime:
-            this.PostedToAccSystemYN == 'Y' ? this.PostedDateTime : null,
-        },
-        { transaction: dbTransaction },
-      );
-      return data;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  /**
-   * Create a new LedgerTransaction
-   *
-   *
-   * @param transactionType - Indicating the type of ledger transaction to create
-   *
-   * @returns {LedgerTransaction}
-   */
-  async newLedgerTransaction(
-    transactionType: TransactionTypeOptions,
-  ): Promise<LedgerTransaction> {
-    const ledgerTransaction = new LedgerTransaction(
-      transactionType,
-      this._DbTransaction,
-    );
-    ledgerTransaction.JournalEntryId = this.JournalEntryId;
-
-    if (transactionType === TransactionTypeOptions.DEBIT) {
-      this._DebitTransactions.push(ledgerTransaction);
-    } else if (transactionType === TransactionTypeOptions.CREDIT) {
-      this._CreditTransactions.push(ledgerTransaction);
-    }
-
-    return ledgerTransaction;
-  }
-}

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

@@ -1,18 +0,0 @@
-import { TransactionTypeOptions } from '../../enum';
-
-export interface ILedgerTransactionAttr {
-  LedgerNo?: string;
-  TransactionType?: TransactionTypeOptions;
-  JournalEntryId?: string;
-  AccountNo?: string;
-  Date?: Date;
-  Name?: string;
-  Description?: string;
-  Currency?: string;
-  DebitAmount?: number;
-  CreditAmount?: number;
-  RelatedObjectId?: string;
-  RelatedObjectType?: string;
-  RelatedDocNo?: string;
-  RelatedPaymentId?: string;
-}

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

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

@@ -1,17 +0,0 @@
-import LedgerTransactionModel from '../models/ledger-transaction.entity';
-import { RepositoryBase, IRepositoryBase } from '@tomei/general';
-
-export class LedgerTransactionRepository
-  extends RepositoryBase<LedgerTransactionModel>
-  implements IRepositoryBase<LedgerTransactionModel>
-{
-  constructor() {
-    super(LedgerTransactionModel);
-  }
-
-  async count(dbTransaction?: any) {
-    return await LedgerTransactionModel.count({
-      transaction: dbTransaction,
-    });
-  }
-}

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

@@ -1,182 +0,0 @@
-import { ILedgerTransactionAttr } from './interfaces/ledger-transaction-attr.interface';
-import { TransactionTypeOptions } from '../enum/transaction-type.enum';
-import { LedgerTransactionRepository } from './ledger-transaction.repository';
-import LedgerTransactionModel from '../models/ledger-transaction.entity';
-import { ObjectBase } from '@tomei/general';
-
-export default class LedgerTransaction extends ObjectBase {
-  ObjectName: string;
-  TableName: string;
-  ObjectType = 'LedgerTransaction';
-  ObjectId = 'New';
-  TransactionType = TransactionTypeOptions.DEBIT;
-  JournalEntryId = '';
-  AccountNo = '';
-  Date = new Date();
-  Name = '';
-  Description = '';
-  Currency = 'MYR';
-  DebitAmount = 0;
-  CreditAmount = 0;
-  RelatedObjectId = '';
-  RelatedObjectType = '';
-  RelatedDocNo = '';
-  RelatedPaymentId = '';
-
-  get LedgerNo() {
-    return this.ObjectId;
-  }
-
-  set LedgerNo(id: string) {
-    this.ObjectId = id;
-  }
-
-  private _DbTransaction: any;
-
-  private static _LedgerTransactionRepository =
-    new LedgerTransactionRepository();
-
-  constructor(
-    transactionType: TransactionTypeOptions,
-    dbTransaction?: any,
-    LedgerNo?: string,
-  ) {
-    super();
-    this.TransactionType = transactionType;
-    if (dbTransaction) {
-      this._DbTransaction = dbTransaction;
-    }
-    if (LedgerNo) {
-      this.LedgerNo = LedgerNo;
-    }
-  }
-
-  init(params?: ILedgerTransactionAttr) {
-    if (params.LedgerNo) this.LedgerNo = params.LedgerNo;
-    if (params.TransactionType) this.TransactionType = params.TransactionType;
-    if (params.JournalEntryId) this.JournalEntryId = params.JournalEntryId;
-    if (params.AccountNo) this.AccountNo = params.AccountNo;
-    if (params.Date) this.Date = params.Date;
-    if (params.Description) this.Description = params.Description;
-    if (params.Currency) this.Currency = params.Currency;
-    if (params.DebitAmount) this.DebitAmount = params.DebitAmount;
-    if (params.CreditAmount) this.CreditAmount = params.CreditAmount;
-    if (params.RelatedObjectId) this.RelatedObjectId = params.RelatedObjectId;
-    if (params.RelatedObjectType)
-      this.RelatedObjectType = params.RelatedObjectType;
-    if (params.Name) this.Name = params.Name;
-  }
-
-  getData() {
-    return {
-      LedgerNo: this.LedgerNo,
-      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,
-      RelatedDocNo: this.RelatedDocNo,
-      RelatedPaymentId: this.RelatedPaymentId,
-    };
-  }
-
-  async save(dbTransaction?: any): Promise<LedgerTransactionModel> {
-    try {
-      const count =
-        await LedgerTransaction._LedgerTransactionRepository.count(
-          dbTransaction,
-        );
-      this.LedgerNo = `${count + 1}`;
-
-      return await LedgerTransaction._LedgerTransactionRepository.create(
-        {
-          LedgerNo: this.LedgerNo,
-          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 || undefined,
-          RelatedObjectType: this.RelatedObjectType || undefined,
-          RelatedDocNo: this.RelatedDocNo || undefined,
-          RelatedPaymentId: this.RelatedPaymentId || undefined,
-        },
-        { transaction: dbTransaction },
-      );
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  async create() {
-    return await LedgerTransaction._LedgerTransactionRepository.create(
-      this.getData,
-      { transaction: this._DbTransaction },
-    );
-  }
-
-  async findAll(options: any) {
-    return await LedgerTransaction._LedgerTransactionRepository.findAll(
-      options,
-    );
-  }
-
-  async findAllWithPagination(options: any) {
-    return await LedgerTransaction._LedgerTransactionRepository.findAllWithPagination(
-      options,
-    );
-  }
-
-  async accountTransactionHistory(accountNo: string) {
-    return await this.findAll({
-      where: {
-        AccountNo: accountNo,
-      },
-      order: [['Date', 'DESC']],
-    });
-  }
-
-  async newLedgerTransaction(
-    transactionType: TransactionTypeOptions,
-    journalEntryId?: string,
-  ): Promise<any> {
-    this.init({
-      LedgerNo: this.createId(),
-      TransactionType: transactionType,
-      JournalEntryId: journalEntryId,
-      // Name: journalEntry.Name,
-      // AccountNo: '',
-      // Date: new Date(),
-      // Description: journalEntry.Description,
-      // Currency: 'MYR',
-      // DebitAmount: 0,
-      // CreditAmount: 0,
-      // RelatedObjectId: '',
-      // RelatedObjectType: '',
-      // RelatedDocNo: '',
-      // RelatedPaymentId: '',
-    });
-
-    if (transactionType === TransactionTypeOptions.DEBIT) {
-      this.TransactionType = TransactionTypeOptions.DEBIT;
-    } else if (transactionType === TransactionTypeOptions.CREDIT) {
-      this.TransactionType = TransactionTypeOptions.CREDIT;
-    }
-
-    if (journalEntryId) {
-      this.JournalEntryId = journalEntryId;
-    }
-
-    return await this.create();
-  }
-}