taxtank-core 0.0.1 → 0.1.1

package/.browserslistrc

@@ -0,0 +1,16 @@
+# This file is used by the build system to adjust CSS and JS output to support the specified browsers below.
+# For additional information regarding the format and rule options, please see:
+# https://github.com/browserslist/browserslist#queries
+
+# For the full list of supported browsers by the Angular framework, please see:
+# https://angular.io/guide/browser-support
+
+# You can see what browsers were selected by your queries by running:
+#   npx browserslist
+
+last 1 Chrome version
+last 1 Firefox version
+last 2 Edge major versions
+last 2 Safari major versions
+last 2 iOS major versions
+Firefox ESR

package/karma.conf.js

@@ -0,0 +1,44 @@
+// Karma configuration file, see link for more information
+// https://karma-runner.github.io/1.0/config/configuration-file.html
+
+module.exports = function (config) {
+  config.set({
+    basePath: '',
+    frameworks: ['jasmine', '@angular-devkit/build-angular'],
+    plugins: [
+      require('karma-jasmine'),
+      require('karma-chrome-launcher'),
+      require('karma-jasmine-html-reporter'),
+      require('karma-coverage'),
+      require('@angular-devkit/build-angular/plugins/karma')
+    ],
+    client: {
+      jasmine: {
+        // you can add configuration options for Jasmine here
+        // the possible options are listed at https://jasmine.github.io/api/edge/Configuration.html
+        // for example, you can disable the random execution with `random: false`
+        // or set a specific seed with `seed: 4321`
+      },
+      clearContext: false // leave Jasmine Spec Runner output visible in browser
+    },
+    jasmineHtmlReporter: {
+      suppressAll: true // removes the duplicated traces
+    },
+    coverageReporter: {
+      dir: require('path').join(__dirname, '../../coverage/tt-core'),
+      subdir: '.',
+      reporters: [
+        { type: 'html' },
+        { type: 'text-summary' }
+      ]
+    },
+    reporters: ['progress', 'kjhtml'],
+    port: 9876,
+    colors: true,
+    logLevel: config.LOG_INFO,
+    autoWatch: true,
+    browsers: ['Chrome'],
+    singleRun: false,
+    restartOnFileChange: true
+  });
+};

package/ng-package.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/tt-core",
+  "lib": {
+    "entryFile": "src/public-api.ts"
+  },
+  "allowedNonPeerDependencies": [
+    "@auth0/angular-jwt",
+    "@stripe/stripe-js",
+    "event-source-polyfill"
+  ]
+}

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "taxtank-core",
-  "version": "0.0.1",
+  "version": "0.1.1",
   "private": false,
   "peerDependencies": {
     "@angular/common": "^12.2.3",
-    "@angular/core": "^12.2.3"
+    "@angular/core": "^12.2.3",
+    "@angular/router": "^12.2.3",
+    "class-transformer": "^0.4.0",
+    "moment": "^2.29.1",
+    "moment-range": "^4.0.2",
+    "lodash": "^4.17.21"
   },
   "dependencies": {
-    "tslib": "^2.0.0"
-  },
-  "main": "bundles/taxtank-core.umd.js",
-  "module": "fesm2015/taxtank-core.js",
-  "es2015": "fesm2015/taxtank-core.js",
-  "esm2015": "esm2015/taxtank-core.js",
-  "fesm2015": "fesm2015/taxtank-core.js",
-  "typings": "taxtank-core.d.ts",
-  "sideEffects": false
-}
+    "tslib": "^2.3.1",
+    "@auth0/angular-jwt": "^5.0.2",
+    "@stripe/stripe-js": "^1.11.0",
+    "event-source-polyfill": "^1.0.22"
+  }
+}

package/src/lib/collections/abstract.collection.ts

@@ -0,0 +1,83 @@
+import { CollectionDictionary } from './collection-dictionary';
+import first from 'lodash/first';
+import last from 'lodash/last';
+
+/**
+ * collection abstract class. Contains common properties and methods for all collections
+ */
+export abstract class AbstractCollection<Model extends object> implements Iterable<Model> {
+  // list of collection's items
+  items: Model[];
+
+  constructor(
+    items: Model[] = []
+  ) {
+    this.items = items;
+  }
+
+  groupBy(prop: string): CollectionDictionary<AbstractCollection<Model>> {
+    return new CollectionDictionary(this, prop);
+  }
+
+  /**
+   * Iterator that allow to iterate collection items
+   */
+  [Symbol.iterator](): Iterator<Model> {
+    // .values() returns Iterator instance for array
+    return this.items.values();
+  }
+
+  /**
+   * get collection length
+   */
+  get length(): number {
+    return this.items.length;
+  }
+
+  /**
+   * method returns amount of fields from passed items
+   * @param field Name of field for calculation
+   * @param items (optional) Array of items need to be calculated. All collection's items by default
+   */
+  protected getSummary(field: string, items: Model[] = this.toArray()): number {
+    return items.reduce((sum: number, item: Model) => sum += item[field], 0);
+  }
+
+  /**
+   * Get list of items ids
+   */
+  getIds(): number[] {
+    return this.items.map((item: Model): number => item['id']);
+  }
+
+  /**
+   * Get single item by id
+   */
+  getById(id: number): Model {
+    return this.items.find((item: Model): boolean => item['id'] === id);
+  }
+
+  getByIds(ids: number[]): Model[] {
+    return this.items.filter((item: Model): boolean => ids.includes(item['id']));
+  }
+
+  /**
+   * Get total sum of items by field
+   * @param field Name of the field for sum
+   */
+  sumBy(field: string): number {
+    return +this.items.reduce((sum: number, item: Model): number => sum + Number(item[field]), 0).toFixed(2);
+  }
+
+  toArray(): Model[] {
+    return [...this.items];
+  }
+
+  get first(): Model {
+    return first(this.items);
+  }
+
+  get last(): Model {
+    return last(this.items);
+  }
+}

package/src/lib/collections/bank-account.collection.ts

@@ -0,0 +1,171 @@
+import { AbstractCollection } from './abstract.collection';
+import { BankAccountTypeEnum } from '../db/Enums/bank-account-type.enum';
+import { TankTypeEnum } from '../db/Enums/tank-type.enum';
+import { BankAccount } from '../models/bank/bank-account';
+import { BankAccountProperty } from '../models/bank/bank-account-property';
+import { Property } from '../models/property/property';
+import flatten from 'lodash/flatten';
+import uniqBy from 'lodash/uniqBy';
+import concat from 'lodash/concat';
+import { TYPE_LOAN } from '../models/bank/type-loan.const';
+
+/**
+ * Collection of bank accounts.
+ */
+export class BankAccountCollection extends AbstractCollection<BankAccount> {
+  /**
+   * get list of bank accounts with passed types
+   */
+  getByType(types: BankAccountTypeEnum | BankAccountTypeEnum[], isExclude: boolean = false): BankAccount[] {
+    // get types always as array (if only one passed)
+    const typesArray: BankAccountTypeEnum[] = concat(types);
+    return this.items.filter((bankAccount: BankAccount) => {
+      if (isExclude) {
+        return !typesArray.includes(bankAccount.type);
+      }
+      return typesArray.includes(bankAccount.type);
+    });
+  }
+
+  /**
+   * get amount of initial loans
+   */
+  getInitialLoanAmount(): number {
+    return this.getByType(TYPE_LOAN)
+      .reduce((sum: number, bankAccount: BankAccount) => {
+        return sum += bankAccount.balances.length ? bankAccount.getOpeningBalance() : 0;
+      }, 0);
+  }
+
+  /**
+   * get amount of current loans
+   */
+  getCurrentLoanAmount(): number {
+    return this.getByType(TYPE_LOAN)
+      .reduce((sum: number, bankAccount: BankAccount) => {
+        return sum += bankAccount.currentBalance;
+      }, 0);
+  }
+
+  /**
+   * get collection filtered by property id
+   */
+  getByPropertyId(id: number): BankAccountCollection {
+    return new BankAccountCollection(this.items.filter((bankAccount: BankAccount) => {
+      return bankAccount.bankAccountProperties.find((bankAccountProperty: BankAccountProperty) => {
+        return bankAccountProperty.property.id === id;
+      });
+    }));
+  }
+
+  /**
+   * get collection filtered by properties ids
+   */
+  getByPropertiesIds(ids: number[]): BankAccountCollection {
+    return new BankAccountCollection(
+      this.items.filter((bankAccount: BankAccount) => {
+        return bankAccount.bankAccountProperties.find((bankAccountProperty: BankAccountProperty) => {
+          return ids.includes(bankAccountProperty.property.id);
+        });
+      })
+    );
+  }
+
+  /**
+   * get collection of active bank accounts
+   */
+  getActiveBankAccounts(): BankAccountCollection {
+    return new BankAccountCollection(this.items.filter((bankAccount: BankAccount) => {
+      return bankAccount.isActive();
+    }));
+  }
+
+  /**
+   * get reduction of loan (reduction of principle) percentage
+   */
+  getPrincipleReductionPercent(): number {
+    const initialLoans: number = this.getInitialLoanAmount();
+    const currentLoans: number = this.getCurrentLoanAmount();
+
+    if (!initialLoans) {
+      return 0;
+    }
+
+    return (initialLoans - currentLoans) / initialLoans * 100;
+  }
+
+  /**
+   * Get collection of loan bank accounts
+   */
+  getLoanAccounts(): BankAccountCollection {
+    return new BankAccountCollection(this.getByType(TYPE_LOAN));
+  }
+
+  getSavingsAccounts(): BankAccountCollection {
+    return new BankAccountCollection(this.getByType(TYPE_LOAN, true));
+  }
+
+  getOpeningBalance(): number {
+    return this.items.reduce((sum: number, bankAccount: BankAccount): number => sum + bankAccount.getOpeningBalance(), 0);
+  }
+
+  get currentBalance(): number {
+    return this.sumBy('currentBalance');
+  }
+
+  /**
+   * Get Collection of bank accounts with property tank type
+   */
+  getPropertyBankAccounts(): BankAccountCollection {
+    return new BankAccountCollection(
+      this.items.filter((bankAccount: BankAccount): boolean => bankAccount.isPropertyTank())
+    );
+  }
+
+  /**
+   * Get Collection of bank accounts with work tank type
+   */
+  getWorkBankAccounts(): BankAccountCollection {
+    return new BankAccountCollection(
+      this.items.filter((bankAccount: BankAccount): boolean => bankAccount.isWorkTank())
+    );
+  }
+
+  /**
+   * Get Collection of bank accounts by tank type
+   */
+  getByTankType(tankType: TankTypeEnum): BankAccountCollection {
+    return new BankAccountCollection(
+      this.items.filter((bankAccount: BankAccount): boolean => bankAccount.tankType === tankType)
+    );
+  }
+
+  /**
+   * Get list of all bank account properties
+   */
+  getBankAccountPropertiesList(): BankAccountProperty[] {
+    return flatten(
+      this.items.map((bankAccount: BankAccount): BankAccountProperty[] => {
+        return bankAccount.bankAccountProperties;
+      })
+    );
+  }
+
+  /**
+   * Get lis of unique properties from all bank accounts properties
+   */
+  getProperties(): Property[] {
+    return uniqBy(
+      this.getBankAccountPropertiesList().map((bankAccountProperty: BankAccountProperty) => {
+        return bankAccountProperty.property;
+      }),
+      'id'
+    );
+  }
+
+  getPropertyBalanceAmount(propertyId: number): number {
+    return this.items.reduce((sum: number, bankAccount: BankAccount): number => {
+      return sum + bankAccount.getPropertyBalanceAmount(propertyId);
+    }, 0);
+  }
+}

package/src/lib/collections/bank-transaction.collection.ts

@@ -0,0 +1,153 @@
+import { TransactionOperationEnum } from '../db/Enums/transaction-operation.enum';
+import { BankTransaction } from '../models/bank/bank-transaction';
+import { MonthNumberEnum } from '../models/financial-year/month-number.enum';
+import { IncomeSource } from '../models/income-source/income-source';
+import { BankAccount } from '../models/bank/bank-account';
+import { AbstractCollection } from './abstract.collection';
+import { CollectionDictionary } from './collection-dictionary';
+import { TransactionAllocationCollection } from './transaction-allocation.collection';
+
+/**
+ * Maximal delay between transfer transactions
+ */
+const TRANSACTION_TRANSFER_DELAY: number = 96 * 3600 * 1000;
+
+/**
+ * Collection of bank transactions.
+ * IMPORTANT: Create this collection based on bank transactions from TransactionAllocationService
+ * @TODO find way to accept interface with allocation instead of bankTransaction to prevent wrong usage
+ * because all amounts calculates with allocated amounts but not from bank transactions amounts.
+ */
+export class BankTransactionCollection extends AbstractCollection<BankTransaction> {
+  getAmount(): number {
+    return this.sumBy('amount');
+  }
+
+  /**
+   * Difference between total bank transactions amount and sum of allocations for passed bank transactions
+   */
+  getUnallocatedAmount(allocations: TransactionAllocationCollection) {
+    return +(this.getAmount() - allocations.getByBankTransactionsIds(this.getIds()).amount).toFixed(2);
+  }
+
+  /**
+   * get date of the last transaction
+   */
+  getLastTransactionDate(): Date {
+    return new Date(Math.max.apply(Math, this.items.map((bankTransaction: BankTransaction) => bankTransaction.date)));
+  }
+
+  /**
+   * get list of credit transactions
+   */
+  get creditTransactions(): BankTransactionCollection {
+    return new BankTransactionCollection(
+      this.items.filter((bankTransaction: BankTransaction) => bankTransaction.isCredit())
+    );
+  }
+
+  /**
+   * get list of debit transactions
+   */
+  get debitTransactions(): BankTransactionCollection {
+    return new BankTransactionCollection(
+      this.items.filter((bankTransaction: BankTransaction) => bankTransaction.isDebit())
+    );
+  }
+
+  /**
+   * get difference between debit and credit transactions amounts
+   */
+  get balanceAmount(): number {
+    return this.items.reduce((sum: number, bankTransaction: BankTransaction) => sum + bankTransaction.balanceAmount, 0);
+  }
+
+  /**
+   * get list of transactions for passed month
+   * @param monthIndex Month number from 0 to 11
+   */
+  getTransactionsByMonth(monthIndex: MonthNumberEnum): BankTransactionCollection {
+    return new BankTransactionCollection(
+      this.items.filter((bankTransaction: BankTransaction) => bankTransaction.date.getMonth() === monthIndex)
+    );
+  }
+
+  /**
+   * get list of transactions by provided bank accounts
+   * @param bankAccounts by which transactions should be returned
+   */
+  getByBankAccounts(bankAccounts: BankAccount[]): BankTransaction[] {
+    const bankAccountIds: number[] = bankAccounts.map((bankAccount: BankAccount) => bankAccount.id);
+    return this.items.filter((bankTransaction: BankTransaction) => bankAccountIds.includes(bankTransaction.bankAccount.id));
+  }
+
+  /**
+   * get list of transactions by provided ids of bank accounts
+   * @param ids of bank accounts
+   */
+  getByBankAccountsIds(ids: number[]): BankTransactionCollection {
+    return new BankTransactionCollection(
+      this.items.filter((bankTransaction: BankTransaction) => ids.includes(bankTransaction.bankAccount.id))
+    );
+  }
+
+  /**
+   * Find Bank Transaction available for transfer
+   */
+  findTransfer(bankTransaction: BankTransaction): BankTransaction {
+    return this.items.find((item: BankTransaction): boolean => {
+      return item.amount + bankTransaction.amount === 0 &&
+        Math.abs(bankTransaction.date.getTime() - item.date.getTime()) < TRANSACTION_TRANSFER_DELAY;
+    });
+  }
+
+  /**
+   * Group bank transactions by transaction id.
+   * Each group is bank transaction collection and contains bank transactions related to transactions via allocations
+   */
+  groupByTransaction(allocations: TransactionAllocationCollection): CollectionDictionary<BankTransactionCollection> {
+    // Group allocations by transaction id
+    const allocationsByTransactions = new CollectionDictionary(allocations, 'transaction');
+    // Init an empty dictionary we will fill below
+    const bankTransactionsByTransactions: CollectionDictionary<BankTransactionCollection> = new CollectionDictionary(new BankTransactionCollection([]));
+
+    // Fill dictionary with the same keys as at allocationsByTransactions
+    allocationsByTransactions.keys.forEach((key: string): void => {
+      bankTransactionsByTransactions.add(key, this.getByAllocations(allocationsByTransactions.get(key)));
+    });
+
+    return bankTransactionsByTransactions;
+  }
+
+  /**
+   * Get collection of bank transactions related with passed allocations
+   */
+  getByAllocations(allocations: TransactionAllocationCollection): BankTransactionCollection {
+    return new BankTransactionCollection(
+      this.items.filter((bankTransaction: BankTransaction): boolean => allocations.hasBankTransaction(bankTransaction))
+    );
+  }
+
+  /**
+   * Set allocate operation for bank transactions with amounts equal to salary
+   */
+  preselectAllocateOperationForSalary(salaryIncomeSources: IncomeSource[]): void {
+    // incomeSource.salaryForecasts[0] because each income source has only one forecast for current fin year
+    const salaryAmounts: number[] = salaryIncomeSources.map((incomeSource: IncomeSource): number => incomeSource.salaryForecasts[0]?.netPay || 0);
+
+    this.items.forEach((bankTransaction: BankTransaction): void => {
+      if (salaryAmounts.includes(bankTransaction.amount)) {
+        bankTransaction.operation = TransactionOperationEnum.ALLOCATE;
+      }
+    });
+  }
+
+  /**
+   * Get collection of unallocated bankTransactions
+   */
+  getUnallocatedBankTransactions(allocations: TransactionAllocationCollection): BankTransactionCollection {
+    return new BankTransactionCollection(
+      this.items.filter((bankTransaction: BankTransaction): boolean => !bankTransaction.isAllocated(allocations))
+    );
+  }
+}

package/src/lib/collections/client-movement.collection.ts

@@ -0,0 +1,42 @@
+import { AbstractCollection } from './abstract.collection';
+import { ClientMovement } from '../models/client/client-movement';
+import { EmployeeCollection } from './employee.collection';
+import { ClientCollection } from './client.collection';
+import { FirmTypeEnum } from '../db/Enums/firm-type.enum';
+
+/**
+ * Collection of tax review
+ */
+export class ClientMovementCollection extends AbstractCollection<ClientMovement> {
+  get active(): ClientMovementCollection {
+    return new ClientMovementCollection(this.items.filter((clientMovement: ClientMovement) => !clientMovement.dateTo));
+  }
+
+  get employees(): EmployeeCollection {
+    return new EmployeeCollection(this.items.map((clientMovement: ClientMovement) => clientMovement.employee));
+  }
+
+  get clients(): ClientCollection {
+    return new EmployeeCollection(this.items.map((clientMovement: ClientMovement) => clientMovement.client));
+  }
+
+  get accountant(): ClientMovement {
+    return this.items.filter((clientMovement: ClientMovement) => clientMovement.firm.type === FirmTypeEnum.ACCOUNTANT)[0] ?? null;
+  }
+
+  get advisors(): ClientMovementCollection {
+    return new ClientMovementCollection(
+      this.items.filter((clientMovement: ClientMovement) => clientMovement.firm.type === FirmTypeEnum.ADVISOR)
+    );
+  }
+
+  getByEmployeeId(id: number): ClientMovementCollection {
+    return new ClientMovementCollection(this.items.filter((clientMovement: ClientMovement) => clientMovement.employee.id === id));
+  }
+
+  getByFirmType(firmType: FirmTypeEnum): ClientMovementCollection {
+    return new ClientMovementCollection(
+      this.items.filter((clientMovement: ClientMovement) => clientMovement.firm.type === firmType)
+    );
+  }
+}

package/src/lib/collections/client-portfolio-report.collection.ts

@@ -0,0 +1,47 @@
+/**
+ * Collection of employee clients tax summary information
+ */
+import { AbstractCollection } from './abstract.collection';
+import { ClientPortfolioReport } from '../models/client/client-portfolio-report';
+
+export class ClientPortfolioReportCollection extends AbstractCollection<ClientPortfolioReport> {
+  get marketValue(): number {
+    return this.sumBy('marketValue');
+  }
+
+  get loanBalance(): number {
+    return this.sumBy('loanBalance');
+  }
+
+  get equityPosition(): number {
+    return this.sumBy('equityPosition');
+  }
+
+  /**
+   * Get average market value if there are more than 1 item in the collection
+   */
+  get averageMarketValue(): number {
+    return this.items.length > 1 ? this.marketValue / this.items.length : null;
+  }
+
+  /**
+   * Get average loan balance if there are more than 1 item in the collection
+   */
+  get averageLoanBalance(): number {
+    return this.items.length > 1 ? this.loanBalance / this.items.length : null;
+  }
+
+  /**
+   * Get average equity position if there are more than 1 item in the collection
+   */
+  get averageEquityPosition(): number {
+    return this.items.length > 1 ? this.equityPosition / this.items.length : null;
+  }
+
+  /**
+   * Return report by provided category name
+   */
+  getByCategoryName(name: string): ClientPortfolioReport {
+    return this.items.find((item: ClientPortfolioReport): boolean => item.category === name);
+  }
+}

package/src/lib/collections/client.collection.ts

@@ -0,0 +1,5 @@
+import { AbstractCollection } from './abstract.collection';
+import { User } from '../models/user/user';
+
+export class ClientCollection extends AbstractCollection<User> {
+}