taxtank-core 0.32.89 → 0.33.1

package/esm2022/src/lib/collections/asset-sale.collection.mjs

@@ -0,0 +1,56 @@
+import { Collection } from './collection';
+export class AssetSaleCollection extends Collection {
+    get grossCapitalProfit() {
+        return this.filter((sale) => sale.grossCapitalGain > 0)
+            .sumBy('grossCapitalGain');
+    }
+    get fullExemptionSales() {
+        return this.filter((sale) => sale.grossCapitalGain != 0 && sale.netCapitalGain == 0);
+    }
+    get fullExemptionGrossCapitalProfit() {
+        return this.filter((sale) => sale.grossCapitalGain > 0 && sale.netCapitalGain == 0).grossCapitalProfit;
+    }
+    get halfExemptionGrossCapitalProfit() {
+        return this.filter((sale) => sale.netCapitalGain > 0 && sale.netCapitalGain !== sale.grossCapitalGain).grossCapitalProfit;
+    }
+    get noExemptionGrossCapitalProfit() {
+        return this.filter((sale) => sale.netCapitalGain > 0 && sale.netCapitalGain === sale.grossCapitalGain).grossCapitalProfit;
+    }
+    get taxableGrossCapitalProfit() {
+        return this.halfExemptionGrossCapitalProfit + this.noExemptionGrossCapitalProfit;
+    }
+    get currentYearCapitalLoss() {
+        return Math.abs(this.filterByFinancialYear('date').filter((sale) => sale.netCapitalGain < 0).sumBy('grossCapitalGain'));
+    }
+    calculateForwardCapitalLoss(priorCapitalLoss) {
+        // gross capital profit
+        const taxableGrossCapitalProfit = this.taxableGrossCapitalProfit;
+        // gross capital loss
+        const currentYearCapitalLoss = this.currentYearCapitalLoss;
+        const currentYearCapitalLossApplied = Math.min(taxableGrossCapitalProfit, currentYearCapitalLoss);
+        const priorYearCapitalLossApplied = Math.min(priorCapitalLoss, taxableGrossCapitalProfit - currentYearCapitalLossApplied);
+        const capitalLossApplied = currentYearCapitalLossApplied + priorYearCapitalLossApplied;
+        return this.currentYearCapitalLoss + priorCapitalLoss - capitalLossApplied;
+    }
+    /**
+     * NET CAPITAL GAIN/(LOSS) AFTER CONCESSIONS & DISCOUNTS
+     */
+    calculateNetCapitalGain(priorCapitalLoss) {
+        // gross capital profit
+        const noExemptionGrossCapitalProfit = this.noExemptionGrossCapitalProfit;
+        const taxableGrossCapitalProfit = this.taxableGrossCapitalProfit;
+        // gross capital loss
+        const currentYearCapitalLoss = this.currentYearCapitalLoss;
+        const currentYearCapitalLossApplied = Math.min(taxableGrossCapitalProfit, currentYearCapitalLoss);
+        const priorYearCapitalLossApplied = Math.min(priorCapitalLoss, taxableGrossCapitalProfit - currentYearCapitalLossApplied);
+        const capitalLossApplied = currentYearCapitalLossApplied + priorYearCapitalLossApplied;
+        // grossCapitalProfit after loss
+        const noExemptionCapitalGain = Math.max(noExemptionGrossCapitalProfit - capitalLossApplied, 0);
+        const halfExemptionCapitalGain = Math.max(this.halfExemptionGrossCapitalProfit - (capitalLossApplied - noExemptionGrossCapitalProfit), 0);
+        const capitalGain = noExemptionCapitalGain + halfExemptionCapitalGain;
+        // capitalGain after exemption
+        const cgtDiscount = halfExemptionCapitalGain / 2;
+        return noExemptionCapitalGain + cgtDiscount - currentYearCapitalLoss + currentYearCapitalLossApplied;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/collections/bank-account.collection.mjs

@@ -0,0 +1,153 @@
+import { Collection } from './collection';
+import { BankAccountTypeEnum } from '../db/Enums';
+import { TYPE_LOAN } from '../models';
+import flatten from 'lodash/flatten';
+import uniqBy from 'lodash/uniqBy';
+import uniq from 'lodash/uniq';
+import concat from 'lodash/concat';
+import { CollectionDictionary } from './collection-dictionary';
+import { LoanCollection } from './loan';
+/**
+ * Collection of bank accounts.
+ */
+export class BankAccountCollection extends Collection {
+    /**
+     * get list of bank accounts with passed types
+     */
+    getByType(types, isExclude = false) {
+        // get types always as array (if only one passed)
+        const typesArray = concat(types);
+        return this.items.filter((bankAccount) => {
+            if (isExclude) {
+                return !typesArray.includes(bankAccount.type);
+            }
+            return typesArray.includes(bankAccount.type);
+        });
+    }
+    /**
+     * get amount of current loans
+     */
+    getCurrentLoanAmount() {
+        return this.getByType(TYPE_LOAN)
+            .reduce((sum, bankAccount) => sum += bankAccount.currentBalance, 0);
+    }
+    /**
+     * get collection filtered by property id
+     */
+    getByPropertyId(id) {
+        return new BankAccountCollection(this.items.filter((bankAccount) => bankAccount.bankAccountProperties.find((bankAccountProperty) => bankAccountProperty.property.id === id)));
+    }
+    groupByProperty() {
+        const dictionary = new CollectionDictionary(new BankAccountCollection());
+        this.items.forEach((bankAccount) => {
+            bankAccount.bankAccountProperties.forEach((bankAccountProperty) => {
+                dictionary.addTo(bankAccountProperty.property.id, bankAccount);
+            });
+        });
+        return dictionary;
+    }
+    /**
+     * get collection filtered by properties ids
+     */
+    getByPropertiesIds(ids) {
+        return new BankAccountCollection(this.items.filter((bankAccount) => bankAccount.bankAccountProperties.find((bankAccountProperty) => ids.includes(bankAccountProperty.property.id))));
+    }
+    /**
+     * @TODO feature functionality allow to work with shared accounts
+     * get collection of active bank accounts
+     */
+    getActive() {
+        return this.getOwn().filter((bankAccount) => bankAccount.isActive());
+    }
+    /**
+     * Get collection of loan bank accounts
+     */
+    getLoanAccounts() {
+        return new BankAccountCollection(this.getByType(TYPE_LOAN));
+    }
+    get loans() {
+        return new LoanCollection(this.filterBy('type', BankAccountTypeEnum.LOAN).map((bankAccount) => bankAccount.loan));
+    }
+    getSavingsAccounts() {
+        return new BankAccountCollection(this.getByType(TYPE_LOAN, true));
+    }
+    getOpeningBalance() {
+        return this.items.reduce((sum, bankAccount) => sum + bankAccount.getOpeningBalance(), 0);
+    }
+    get currentBalance() {
+        return this.sumBy('currentBalance');
+    }
+    get bankShortNames() {
+        return uniq(this.map((bankAccount) => bankAccount.bank.shortName)).join(', ');
+    }
+    /**
+     * Get Collection of bank accounts with property tank type
+     */
+    getPropertyBankAccounts() {
+        return new BankAccountCollection(this.items.filter((bankAccount) => bankAccount.isPropertyTank()));
+    }
+    /**
+     * Get Collection of bank accounts with work tank type
+     */
+    getWorkBankAccounts() {
+        return new BankAccountCollection(this.items.filter((bankAccount) => bankAccount.isWorkTank()));
+    }
+    /**
+     * Get Collection of bank accounts by tank type
+     */
+    getByTankType(tankType) {
+        return new BankAccountCollection(this.items.filter((bankAccount) => bankAccount.tankType === tankType));
+    }
+    /**
+     * Get list of all bank account properties
+     */
+    getBankAccountPropertiesList() {
+        return flatten(this.items.map((bankAccount) => bankAccount.bankAccountProperties));
+    }
+    /**
+     * Get lis of unique properties from all bank accounts properties
+     */
+    getProperties() {
+        return uniqBy(this.getBankAccountPropertiesList().map((bankAccountProperty) => bankAccountProperty.property), 'id');
+    }
+    /**
+     * @TODO Alex not efficient, filter bankAccounts by property first
+     */
+    getPropertyBalanceAmount(propertyId) {
+        return this.items.reduce((sum, bankAccount) => sum + bankAccount.getPropertyBalanceAmount(propertyId), 0);
+    }
+    get propertiesBalanceAmount() {
+        let balanceAmount = 0;
+        this.items.forEach((bankAccount) => {
+            bankAccount.bankAccountProperties.forEach((bankAccountProperty) => {
+                balanceAmount += Math.abs(bankAccount.getPropertyBalanceAmount(bankAccountProperty.property.id));
+            });
+        });
+        return balanceAmount;
+    }
+    get propertiesMonthlyRepaymentAmount() {
+        let repaymentAmount = 0;
+        this.getLoanAccounts().items.forEach((bankAccount) => {
+            bankAccount.bankAccountProperties.forEach((bankAccountProperty) => {
+                repaymentAmount += bankAccount.getMonthlyRepaymentAmount(bankAccountProperty.property.id);
+            });
+        });
+        return repaymentAmount;
+    }
+    getPropertyMonthlyRepaymentAmount(propertyId) {
+        return this.getLoanAccounts().reduce((sum, bankAccount) => sum + bankAccount.getMonthlyRepaymentAmount(propertyId), 0);
+    }
+    getLVR(property) {
+        return this.getPropertyBalanceAmount(property.id) / property.currentYearForecast.marketValue;
+    }
+    /**
+     * @TODO Alex/Vik: maybe we should get it from jwtToken or think about some localStorageService?
+     */
+    getOwn() {
+        return this.filter((bankAccount) => bankAccount.isOwner(+localStorage.getItem('userId')));
+    }
+    getActiveLoanAccountsByProperties(ids) {
+        return this.getActive().getLoanAccounts().getByPropertiesIds(ids);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bank-account.collection.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/collections/bank-account.collection.ts"],"names":[],"mappings":"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","sourcesContent":["import { Collection } from './collection';\nimport { BankAccountTypeEnum } from '../db/Enums';\nimport { TankTypeEnum } from '../db/Enums/tank-type.enum';\nimport { BankAccount, BankAccountProperty, Property, TYPE_LOAN } from '../models';\nimport flatten from 'lodash/flatten';\nimport uniqBy from 'lodash/uniqBy';\nimport uniq from 'lodash/uniq';\nimport concat from 'lodash/concat';\nimport { CollectionDictionary } from './collection-dictionary';\nimport { LoanCollection } from './loan';\n\n/**\n * Collection of bank accounts.\n */\nexport class BankAccountCollection extends Collection<BankAccount> {\n  /**\n   * get list of bank accounts with passed types\n   */\n  getByType(types: BankAccountTypeEnum | BankAccountTypeEnum[], isExclude = false): BankAccount[] {\n    // get types always as array (if only one passed)\n    const typesArray: BankAccountTypeEnum[] = concat(types);\n    return this.items.filter((bankAccount: BankAccount) => {\n      if (isExclude) {\n        return !typesArray.includes(bankAccount.type);\n      }\n      return typesArray.includes(bankAccount.type);\n    });\n  }\n\n  /**\n   * get amount of current loans\n   */\n  getCurrentLoanAmount(): number {\n    return this.getByType(TYPE_LOAN)\n      .reduce((sum: number, bankAccount: BankAccount) => sum += bankAccount.currentBalance, 0);\n  }\n\n  /**\n   * get collection filtered by property id\n   */\n  getByPropertyId(id: number): BankAccountCollection {\n    return new BankAccountCollection(this.items.filter((bankAccount: BankAccount) => bankAccount.bankAccountProperties.find((bankAccountProperty: BankAccountProperty) => bankAccountProperty.property.id === id)));\n  }\n\n  groupByProperty(): CollectionDictionary<BankAccountCollection> {\n    const dictionary = new CollectionDictionary(new BankAccountCollection());\n\n    this.items.forEach((bankAccount) => {\n      bankAccount.bankAccountProperties.forEach((bankAccountProperty) => {\n        dictionary.addTo(bankAccountProperty.property.id, bankAccount);\n      });\n    });\n\n    return dictionary;\n  }\n\n  /**\n   * get collection filtered by properties ids\n   */\n  getByPropertiesIds(ids: number[]): BankAccountCollection {\n    return new BankAccountCollection(\n      this.items.filter((bankAccount: BankAccount) => bankAccount.bankAccountProperties.find((bankAccountProperty: BankAccountProperty) => ids.includes(bankAccountProperty.property.id)))\n    );\n  }\n\n  /**\n   * @TODO feature functionality allow to work with shared accounts\n   * get collection of active bank accounts\n   */\n  getActive(): BankAccountCollection {\n    return this.getOwn().filter((bankAccount) => bankAccount.isActive());\n  }\n\n  /**\n   * Get collection of loan bank accounts\n   */\n  getLoanAccounts(): BankAccountCollection {\n    return new BankAccountCollection(this.getByType(TYPE_LOAN));\n  }\n\n  get loans(): LoanCollection {\n    return new LoanCollection(this.filterBy('type', BankAccountTypeEnum.LOAN).map((bankAccount) => bankAccount.loan));\n  }\n\n  getSavingsAccounts(): BankAccountCollection {\n    return new BankAccountCollection(this.getByType(TYPE_LOAN, true));\n  }\n\n  getOpeningBalance(): number {\n    return this.items.reduce((sum: number, bankAccount: BankAccount): number => sum + bankAccount.getOpeningBalance(), 0);\n  }\n\n  get currentBalance(): number {\n    return this.sumBy('currentBalance');\n  }\n\n  get bankShortNames(): string {\n    return uniq(this.map((bankAccount) => bankAccount.bank.shortName)).join(', ');\n  }\n\n  /**\n   * Get Collection of bank accounts with property tank type\n   */\n  getPropertyBankAccounts(): BankAccountCollection {\n    return new BankAccountCollection(\n      this.items.filter((bankAccount: BankAccount): boolean => bankAccount.isPropertyTank())\n    );\n  }\n\n  /**\n   * Get Collection of bank accounts with work tank type\n   */\n  getWorkBankAccounts(): BankAccountCollection {\n    return new BankAccountCollection(\n      this.items.filter((bankAccount: BankAccount): boolean => bankAccount.isWorkTank())\n    );\n  }\n\n  /**\n   * Get Collection of bank accounts by tank type\n   */\n  getByTankType(tankType: TankTypeEnum): BankAccountCollection {\n    return new BankAccountCollection(\n      this.items.filter((bankAccount: BankAccount): boolean => bankAccount.tankType === tankType)\n    );\n  }\n\n  /**\n   * Get list of all bank account properties\n   */\n  getBankAccountPropertiesList(): BankAccountProperty[] {\n    return flatten(\n      this.items.map((bankAccount: BankAccount): BankAccountProperty[] => bankAccount.bankAccountProperties)\n    );\n  }\n\n  /**\n   * Get lis of unique properties from all bank accounts properties\n   */\n  getProperties(): Property[] {\n    return uniqBy(\n      this.getBankAccountPropertiesList().map((bankAccountProperty: BankAccountProperty) => bankAccountProperty.property),\n      'id'\n    );\n  }\n\n  /**\n   * @TODO Alex not efficient, filter bankAccounts by property first\n   */\n  getPropertyBalanceAmount(propertyId: number): number {\n    return this.items.reduce((sum: number, bankAccount: BankAccount): number => sum + bankAccount.getPropertyBalanceAmount(propertyId), 0);\n  }\n\n  get propertiesBalanceAmount(): number {\n    let balanceAmount = 0;\n    this.items.forEach((bankAccount) => {\n      bankAccount.bankAccountProperties.forEach((bankAccountProperty) => {\n        balanceAmount += Math.abs(bankAccount.getPropertyBalanceAmount(bankAccountProperty.property.id));\n      });\n    });\n\n    return balanceAmount;\n  }\n\n  get propertiesMonthlyRepaymentAmount(): number {\n    let repaymentAmount = 0;\n    this.getLoanAccounts().items.forEach((bankAccount) => {\n      bankAccount.bankAccountProperties.forEach((bankAccountProperty) => {\n        repaymentAmount += bankAccount.getMonthlyRepaymentAmount(bankAccountProperty.property.id);\n      });\n    });\n\n    return repaymentAmount;\n  }\n\n  getPropertyMonthlyRepaymentAmount(propertyId: number): number {\n    return this.getLoanAccounts().reduce((sum: number, bankAccount: BankAccount): number =>\n      sum + bankAccount.getMonthlyRepaymentAmount(propertyId), 0\n    );\n  }\n\n  getLVR(property: Property): number {\n    return this.getPropertyBalanceAmount(property.id) / property.currentYearForecast.marketValue;\n  }\n\n  /**\n   * @TODO Alex/Vik: maybe we should get it from jwtToken or think about some localStorageService?\n   */\n  getOwn(): this {\n    return this.filter((bankAccount: BankAccount) => bankAccount.isOwner(+localStorage.getItem('userId')));\n  }\n\n  getActiveLoanAccountsByProperties(ids: number[]): BankAccountCollection {\n    return this.getActive().getLoanAccounts().getByPropertiesIds(ids);\n  }\n}\n"]}

package/esm2022/src/lib/collections/bank-transaction.collection.mjs

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

package/esm2022/src/lib/collections/chart-accounts.collection.mjs

@@ -0,0 +1,26 @@
+import { Collection } from './collection';
+import { FinancialYear } from '../models';
+import { ChartAccountsListEnum } from '../db/Enums';
+export class ChartAccountsCollection extends Collection {
+    constructor(items = []) {
+        super(items);
+        // Sort personal chart accounts by name (TT-1950)
+        // @TODO Alex: implement general initial sorting solution in parent class
+        this.items.sort((a, b) => {
+            if (a.isPersonal() && b.isPersonal()) {
+                return a.name > b.name ? 1 : -1;
+            }
+            return 0;
+        });
+    }
+    getManual() {
+        return this.filter(chartAccounts => !!chartAccounts.user);
+    }
+    /**
+     * Get 'Kms travelled for work' related chart account value
+     */
+    getVehicleKmsRate(year = new FinancialYear().year) {
+        return this.findBy('id', ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK).getValueByYear(year).value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/collections/chat/chat.collection.mjs

@@ -0,0 +1,26 @@
+import { Collection } from '../collection';
+import { Dictionary } from '../../models';
+import { MessageCollection } from './message.collection';
+import uniqBy from 'lodash/uniqBy';
+import differenceBy from 'lodash/differenceBy';
+import { ChatStatusEnum } from '../../db/Enums/chat-status.enum';
+export class ChatCollection extends Collection {
+    /**
+     * Sort chats by last messages (newest first) + empty chats in the end
+     */
+    getSortedByNewest(messages) {
+        const chatsById = new Dictionary(this.toArray());
+        // get chats array sorted from newest to oldest
+        const chats = uniqBy(new MessageCollection(messages)
+            .filterBy('chat.id', this.getIds())
+            .sortBy('createdAt')
+            .toArray()
+            .map((message) => chatsById.get(message.chat.id)), 'id');
+        const emptyChats = differenceBy(this.toArray(), chats, 'id');
+        return this.create([...chats, ...emptyChats]);
+    }
+    getActive() {
+        return this.filterBy('status', ChatStatusEnum.ACTIVE);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/collections/chat/index.mjs

@@ -0,0 +1,4 @@
+export * from './chat.collection';
+export * from './message-document.collection';
+export * from './message.collection';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvY29sbGVjdGlvbnMvY2hhdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2hhdC5jb2xsZWN0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vbWVzc2FnZS1kb2N1bWVudC5jb2xsZWN0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vbWVzc2FnZS5jb2xsZWN0aW9uJztcbiJdfQ==

package/esm2022/src/lib/collections/chat/message-document.collection.mjs

@@ -0,0 +1,13 @@
+import { Collection } from '../collection';
+/**
+ * Collection of MessageDocument instances
+ */
+export class MessageDocumentCollection extends Collection {
+    /**
+     * get list of documents which are not attached to any message
+     */
+    getUnattached() {
+        return new MessageDocumentCollection(this.items.filter((doc) => !doc.message));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZS1kb2N1bWVudC5jb2xsZWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL2NvbGxlY3Rpb25zL2NoYXQvbWVzc2FnZS1kb2N1bWVudC5jb2xsZWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHM0M7O0dBRUc7QUFDSCxNQUFNLE9BQU8seUJBQTBCLFNBQVEsVUFBMkI7SUFDeEU7O09BRUc7SUFDSCxhQUFhO1FBQ1gsT0FBTyxJQUFJLHlCQUF5QixDQUNsQyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQW9CLEVBQVcsRUFBRSxDQUFDLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxDQUNuRSxDQUFDO0lBQ0osQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29sbGVjdGlvbiB9IGZyb20gJy4uL2NvbGxlY3Rpb24nO1xuaW1wb3J0IHsgTWVzc2FnZURvY3VtZW50IH0gZnJvbSAnLi4vLi4vbW9kZWxzJztcblxuLyoqXG4gKiBDb2xsZWN0aW9uIG9mIE1lc3NhZ2VEb2N1bWVudCBpbnN0YW5jZXNcbiAqL1xuZXhwb3J0IGNsYXNzIE1lc3NhZ2VEb2N1bWVudENvbGxlY3Rpb24gZXh0ZW5kcyBDb2xsZWN0aW9uPE1lc3NhZ2VEb2N1bWVudD4ge1xuICAvKipcbiAgICogZ2V0IGxpc3Qgb2YgZG9jdW1lbnRzIHdoaWNoIGFyZSBub3QgYXR0YWNoZWQgdG8gYW55IG1lc3NhZ2VcbiAgICovXG4gIGdldFVuYXR0YWNoZWQoKTogTWVzc2FnZURvY3VtZW50Q29sbGVjdGlvbiB7XG4gICAgcmV0dXJuIG5ldyBNZXNzYWdlRG9jdW1lbnRDb2xsZWN0aW9uKFxuICAgICAgdGhpcy5pdGVtcy5maWx0ZXIoKGRvYzogTWVzc2FnZURvY3VtZW50KTogYm9vbGVhbiA9PiAhZG9jLm1lc3NhZ2UpXG4gICAgKTtcbiAgfVxufVxuIl19

package/esm2022/src/lib/collections/chat/message.collection.mjs

@@ -0,0 +1,31 @@
+import { Collection } from '../collection';
+import uniqBy from 'lodash/uniqBy';
+export class MessageCollection extends Collection {
+    getFirstUnreadMessage(user) {
+        return this.items.find((message) => !message.isRead() && message.isFromEmployee() !== user.isEmployee());
+    }
+    /**
+     * Get List of unread chats
+     */
+    getUnread() {
+        return this.items.filter((message) => !message.readAt);
+    }
+    getFromActiveChats() {
+        return this.filter((message) => message.chat.isActive());
+    }
+    /**
+     * Get amount of chats that contains unread messages
+     */
+    getUnreadChatsAmount(isFromEmployee = false) {
+        // filtered messages for client/employee
+        const filteredMessages = this.filter((message) => isFromEmployee ? message.isFromEmployee() : !message.isFromEmployee());
+        return uniqBy(filteredMessages.getFromActiveChats().getUnread(), 'chat.id').length;
+    }
+    /**
+     * Check if chat has unread chats
+     */
+    hasUnread() {
+        return !!this.getUnread().length;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/collections/client-invite.collection.mjs

@@ -0,0 +1,7 @@
+import { Collection } from './collection';
+export class ClientInviteCollection extends Collection {
+    getPending() {
+        return this.filter((invite) => invite.isPending());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50LWludml0ZS5jb2xsZWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL2NvbGxlY3Rpb25zL2NsaWVudC1pbnZpdGUuY29sbGVjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBRzFDLE1BQU0sT0FBTyxzQkFBdUIsU0FBUSxVQUF3QjtJQUNsRSxVQUFVO1FBQ1IsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsTUFBb0IsRUFBRSxFQUFFLENBQUMsTUFBTSxDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUM7SUFDbkUsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29sbGVjdGlvbiB9IGZyb20gJy4vY29sbGVjdGlvbic7XG5pbXBvcnQgeyBDbGllbnRJbnZpdGUgfSBmcm9tICcuLi9tb2RlbHMvY2xpZW50L2NsaWVudC1pbnZpdGUnO1xuXG5leHBvcnQgY2xhc3MgQ2xpZW50SW52aXRlQ29sbGVjdGlvbiBleHRlbmRzIENvbGxlY3Rpb248Q2xpZW50SW52aXRlPiB7XG4gIGdldFBlbmRpbmcoKTogdGhpcyB7XG4gICAgcmV0dXJuIHRoaXMuZmlsdGVyKChpbnZpdGU6IENsaWVudEludml0ZSkgPT4gaW52aXRlLmlzUGVuZGluZygpKTtcbiAgfVxufVxuIl19

package/esm2022/src/lib/collections/client-movement.collection.mjs

@@ -0,0 +1,47 @@
+import { Collection } from './collection';
+import { SERVICE_PRODUCT_ROLES } from '../models';
+import { EmployeeCollection } from './employee.collection';
+import { FirmTypeEnum } from '../db/Enums/firm-type.enum';
+import { CollectionDictionary } from './collection-dictionary';
+import { ServiceSubscriptionCollection } from './subscription';
+/**
+ * Collection of tax review
+ */
+export class ClientMovementCollection extends Collection {
+    get active() {
+        return new ClientMovementCollection(this.items.filter((clientMovement) => !clientMovement.dateTo));
+    }
+    get employees() {
+        return new EmployeeCollection(this.items.map((clientMovement) => clientMovement.employee));
+    }
+    get clients() {
+        return new EmployeeCollection(this.items.map((clientMovement) => clientMovement.client));
+    }
+    get accountant() {
+        return this.items.filter((clientMovement) => clientMovement.firm.type === FirmTypeEnum.ACCOUNTANT)[0] ?? null;
+    }
+    get advisors() {
+        return new ClientMovementCollection(this.items.filter((clientMovement) => clientMovement.firm.type === FirmTypeEnum.ADVISOR));
+    }
+    getByEmployeeId(id) {
+        return new ClientMovementCollection(this.items.filter((clientMovement) => clientMovement.employee.id === id));
+    }
+    getByFirmType(firmType) {
+        return new ClientMovementCollection(this.items.filter((clientMovement) => clientMovement.firm.type === firmType));
+    }
+    /**
+     * group clients (client movements) by tanks
+     */
+    groupByRoles() {
+        const dictionary = new CollectionDictionary(new ClientMovementCollection());
+        SERVICE_PRODUCT_ROLES.forEach((role) => {
+            const movements = this.filter(movement => {
+                const subscriptions = new ServiceSubscriptionCollection(movement.client.subscriptions).filterByRole(role);
+                return (subscriptions.getPaid().last ?? subscriptions.getTrials().first)?.isActive;
+            });
+            dictionary.add(role, movements);
+        });
+        return dictionary;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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