taxtank 0.1.0

package/projects/tt-core/src/lib/collections/property/property.collection.ts

@@ -0,0 +1,181 @@
+import { Collection } from '../collection';
+import { Dictionary, Property, PropertyCategory } from '../../models';
+import uniqBy from 'lodash/uniqBy';
+import { DepreciationCollection } from '../depreciation.collection';
+import { TransactionCollection } from '../transaction';
+import { CollectionDictionary } from '../collection-dictionary';
+import { PropertyCategoryMovementCollection } from './property-category-movement.collection';
+import { BankAccountCollection } from '../bank-account.collection';
+
+export class PropertyCollection extends Collection<Property> {
+  /**
+   * Get new property collection filtered by active status
+   */
+  getActive(): PropertyCollection {
+    return new PropertyCollection(
+      this.items.filter((property: Property): boolean => property.isActive)
+    );
+  }
+
+  getCreatedProperties(): PropertyCollection {
+    return new PropertyCollection(
+      this.items.filter((property: Property): boolean => property.isOwn())
+    );
+  }
+
+  /**
+   * Get new property collection filtered by shared
+   */
+  getSharedProperties(): PropertyCollection {
+    return new PropertyCollection(
+      this.items.filter((property: Property): boolean => !property.isOwn())
+    );
+  }
+
+  getUnsold(): this {
+    return this.create(
+      this.items.filter((property: Property) => !property.isSold())
+    );
+  }
+
+  /**
+   * Get total purchase price for all properties in the collection
+   */
+  get purchasePrice(): number {
+    return this.sumBy('purchasePrice');
+  }
+
+  get growthPercent(): number {
+    return this.sumBy('growthPercent');
+  }
+
+  get marketValue(): number {
+    return this.sumBy('marketValue');
+  }
+
+  get sharedMarketValue(): number {
+    return this.sumBy('sharedMarketValue');
+  }
+
+  /**
+   * Get list of unique property categories from collection
+   */
+  getCategories(): PropertyCategory[] {
+    return uniqBy(this.items.map((property: Property): PropertyCategory => property.category), 'id');
+  }
+
+  /**
+   * list of properties
+   */
+  getCGTApplicable(): this {
+    return this.create(
+      this.items.filter((property: Property) => property.isCGTApplicable())
+    );
+  }
+
+  /**
+   * Get property with the highest growth percent
+   */
+  getBestPerformanceGrowthProperty(): Property {
+    return this.items.reduce((max: Property, current: Property): Property => max.getGrowth() < current.getGrowth() ? current : max, this.first);
+  }
+
+  /**
+   * Get property with the lowest tax position
+   */
+  getBestPerformanceTaxProperty(transactions: TransactionCollection, depreciations: DepreciationCollection): Property {
+    const transactionsByProperty: CollectionDictionary<TransactionCollection> = transactions.groupBy('property.id');
+    const depreciationsByProperty: CollectionDictionary<DepreciationCollection> = depreciations.groupBy('property.id');
+
+    return this.items.reduce((min: Property, current: Property): Property => {
+      const minTaxPosition: number = min.getTaxPosition(transactionsByProperty.get(min.id), depreciationsByProperty.get(min.id));
+      const currentTaxPosition: number = current.getTaxPosition(transactionsByProperty.get(current.id), depreciationsByProperty.get(current.id));
+
+      return minTaxPosition > currentTaxPosition ? current : min;
+    }, this.first);
+  }
+
+  /**
+   * @TODO Nicole not needed anymore?
+   * Show best performance properties first
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677997/Property+Tank+Dashboard
+   */
+  sortByBestPerformance(transactions: TransactionCollection, depreciations: DepreciationCollection): this {
+    const activeProperties: PropertyCollection = this.getActive();
+
+    // nothing to sort when no active properties
+    if (!activeProperties.length) {
+      return this;
+    }
+
+    const bestProperties: Property[] = uniqBy(this.create([
+      activeProperties.getBestPerformanceGrowthProperty(),
+      activeProperties.getBestPerformanceTaxProperty(transactions, depreciations)
+    ]).toArray(), 'id');
+
+    const newItems: Property[] = this.diff(bestProperties).toArray();
+    newItems.unshift(...bestProperties);
+
+    return this.create(newItems);
+  }
+
+  get netMonthlyIncome(): number {
+    return this.sumBy('monthlyIncome') + this.sumBy('monthlyExpense');
+  }
+
+  getOwnerOccupiedProperties(): PropertyCollection {
+    return new PropertyCollection(
+      this.items.filter((property: Property): boolean => property.category.isOwnerOccupied())
+    );
+  }
+
+  /**
+   * Properties that are taxed and will be included in reports (Tax summary, My tax report, e.t.c.)
+   */
+  getTaxInclusive(): this {
+    return this.create(
+      this.items.filter((property: Property) => property.category.isTaxInclusive)
+    );
+  }
+
+  groupByCategory(categories: Collection<PropertyCategory>, movements: PropertyCategoryMovementCollection, allowEmpty = false): Map<PropertyCategory, PropertyCollection> {
+    const categoryById = categories.indexBy('id');
+    const movementsByCategory = movements.getCurrent().groupBy('propertyCategory.id');
+
+    const propertiesByCategory = new Map<PropertyCategory, PropertyCollection>;
+    movementsByCategory.keys.forEach(key => {
+      propertiesByCategory.set(
+        categoryById.get(key),
+        this.filterBy('id', movementsByCategory.get(key).map(movement => movement.property.id))
+      );
+    });
+
+    if (allowEmpty) {
+      categories.remove(Array.from(propertiesByCategory.keys())).toArray().forEach(category => {
+        propertiesByCategory.set(category, new PropertyCollection());
+      });
+    }
+
+    return propertiesByCategory;
+  }
+
+  getEquityPositionByProperty(bankAccounts: BankAccountCollection): Dictionary<number> {
+    const loanAccounts = bankAccounts.getOwn().getLoanAndOffsetAccounts();
+    const equityPositionByProperty = new Dictionary([]);
+    this.items.forEach(property => {
+      equityPositionByProperty.add(property.id, property.getEquityPosition(loanAccounts.getByPropertyId(property.id)));
+    });
+
+    return equityPositionByProperty;
+  }
+
+  getLvrByProperty(bankAccounts: BankAccountCollection): Dictionary<number> {
+    const loanAccounts = bankAccounts.getOwn().getLoanAndOffsetAccounts();
+    const lvrByProperty = new Dictionary([]);
+    this.items.forEach(property => {
+      lvrByProperty.add(property.id, property.getLvr(loanAccounts.getByPropertyId(property.id)));
+    });
+
+    return lvrByProperty;
+  }
+}

package/projects/tt-core/src/lib/collections/property/tax-exemption.collection.ts

@@ -0,0 +1,14 @@
+import { Collection } from '../collection';
+import { TaxExemption } from '../../models';
+import { TaxExemptionEnum } from '../../db/Enums/property/property-sale/tax-exemption.enum';
+
+export class TaxExemptionCollection extends Collection<TaxExemption> {
+  /**
+   * tax exemption eligible only for a resident
+   */
+  getResidentOnly(): this {
+    return this.filter(
+      (taxExemption) => ![TaxExemptionEnum.TRANSFER, TaxExemptionEnum.OTHER].includes(taxExemption.id)
+    );
+  }
+}

package/projects/tt-core/src/lib/collections/report/budget-report/budget-rule-item.collection.ts

@@ -0,0 +1,71 @@
+import { Collection } from '../../collection';
+import { TransactionCollection } from '../../transaction';
+import { BudgetRuleCollection } from '../../budget';
+import { BudgetRuleItem } from '../../../models/report';
+import round from 'lodash/round';
+import { FinancialYear } from '../../../models';
+import { MoneyCalendarEventCollection } from '../../money';
+
+export class BudgetRuleItemCollection extends Collection<BudgetRuleItem> {
+  isGross: boolean;
+
+  static create(rules: BudgetRuleCollection, transactions: TransactionCollection, dateFrom = new FinancialYear().startDate, dateTo = new FinancialYear().endDate, isGross = false) {
+    const collection = new BudgetRuleItemCollection();
+    const transactionsByChartAccounts = transactions.groupBy('chartAccounts.id');
+    rules.items.forEach(rule => {
+      collection.push(new BudgetRuleItem(rule, transactionsByChartAccounts.get(rule.chartAccounts.id), dateFrom, dateTo, isGross));
+    });
+    collection.isGross = isGross;
+
+    return collection;
+  }
+
+  get incomes(): BudgetRuleItemCollection {
+    return this.filter(item => item.rule.amount > 0);
+  }
+
+  get expenses(): BudgetRuleItemCollection {
+    return this.filter(item => item.rule.amount < 0);
+  }
+
+  isIncome(): boolean {
+    return this.first.isIncome();
+  }
+
+  get transactions(): TransactionCollection {
+    return new TransactionCollection(this.map(item => item.transactions.toArray()).flat());
+  }
+
+  get rules(): BudgetRuleCollection {
+    return new BudgetRuleCollection(this.mapBy('rule'));
+  }
+
+  getCalendarEvents(inCalendar = false): MoneyCalendarEventCollection {
+    return new MoneyCalendarEventCollection(this.map(item => item.rule.getCalendarEvents(inCalendar).toArray()).flat());
+  }
+
+  onTrack(): boolean {
+    return this.sumBy('variance') >= 0;
+  }
+
+  /**
+   * @TODO move to property to avoid recalculations?
+   */
+  getActualByMonth(month: number): number {
+    return this.transactions.getByMonth(month).sumBy(this.isGross ? 'grossAmount': 'amount');
+  }
+
+  /**
+   * @TODO move to property to avoid recalculations?
+   */
+  getForecastByMonth(month: number): number {
+    return this.getCalendarEvents().getByMonth(month).amount;
+  }
+
+  /**
+   * @TODO move to property to avoid recalculations?
+   */
+  get variancePercent(): number {
+    return round(this.sumBy('variance') * 100 / Math.abs(this.sumBy('forecast')), 2);
+  }
+}

package/projects/tt-core/src/lib/collections/report/budget-report/index.ts

@@ -0,0 +1 @@
+export * from './budget-rule-item.collection';

package/projects/tt-core/src/lib/collections/report/depreciation/depreciation-lvp-report-item.collection.ts

@@ -0,0 +1,17 @@
+import {
+  DepreciationLvpReportItem
+} from '../../../models/report/depreciation/depreciation-lvp-report-item';
+import { Depreciation } from '../../../models/depreciation/depreciation';
+import { plainToClass } from 'class-transformer';
+import { DepreciationCollection } from '../../depreciation.collection';
+
+/**
+ * Collection of depreciation Low Value Pool report items
+ */
+export class DepreciationLvpReportItemCollection extends DepreciationCollection {
+  static fromDepreciations(deprectiations: Depreciation[]): DepreciationLvpReportItemCollection {
+    return new DepreciationLvpReportItemCollection(
+      deprectiations.map((depreciation: Depreciation) => plainToClass(DepreciationLvpReportItem, depreciation))
+    );
+  }
+}

package/projects/tt-core/src/lib/collections/report/depreciation/depreciation-report-item.collection.ts

@@ -0,0 +1,15 @@
+import { Depreciation } from '../../../models/depreciation/depreciation';
+import { plainToClass } from 'class-transformer';
+import { DepreciationCollection } from '../../depreciation.collection';
+import { DepreciationReportItem } from '../../../models/report/depreciation/depreciation-report-item';
+
+export class DepreciationReportItemCollection extends DepreciationCollection {
+  /**
+   * Create new collection from provided depreciations list
+   */
+  static fromDepreciations(deprectiations: Depreciation[]): DepreciationReportItemCollection {
+    return new DepreciationReportItemCollection(
+      deprectiations.map((depreciation: Depreciation) => plainToClass(DepreciationReportItem, depreciation))
+    );
+  }
+}

package/projects/tt-core/src/lib/collections/report/income-expense/transaction-report-item.collection.ts

@@ -0,0 +1,38 @@
+import { Collection } from '../../collection';
+import { TransactionReportItem } from '../../../models/report';
+import { TransactionCollection } from '../../transaction';
+import { ChartAccountsCategoryEnum } from '../../../db/Enums';
+
+export class TransactionReportItemCollection extends Collection<TransactionReportItem> {
+  static fromTransactions(transactions: TransactionCollection, priorTransactions: TransactionCollection) {
+    const transactionsByChartAccounts = transactions.groupBy('chartAccounts.id');
+    const priorTransactionsByChartAccounts = priorTransactions.groupBy('chartAccounts.id');
+
+    const items = new TransactionReportItemCollection([...new Set([...transactionsByChartAccounts.keys, ...priorTransactionsByChartAccounts.keys])].map(
+      chartAccountsId => new TransactionReportItem(transactionsByChartAccounts.get(chartAccountsId), priorTransactionsByChartAccounts.get(chartAccountsId))
+    ));
+
+    const categoriesOrder = [
+      ChartAccountsCategoryEnum.PROPERTY_INCOME,
+      ChartAccountsCategoryEnum.WORK_INCOME,
+      ChartAccountsCategoryEnum.SOLE_INCOME,
+      ChartAccountsCategoryEnum.HOLDING_INCOME,
+      ChartAccountsCategoryEnum.OTHER_INCOME,
+      ChartAccountsCategoryEnum.PERSONAL_INCOME,
+      ChartAccountsCategoryEnum.PROPERTY_EXPENSE,
+      ChartAccountsCategoryEnum.WORK_EXPENSE,
+      ChartAccountsCategoryEnum.SOLE_EXPENSE,
+      ChartAccountsCategoryEnum.HOLDING_EXPENSE,
+      ChartAccountsCategoryEnum.OTHER_EXPENSE,
+      ChartAccountsCategoryEnum.PERSONAL_EXPENSE,
+    ];
+
+    items.sort((a, b) => categoriesOrder.indexOf(a.category) - categoriesOrder.indexOf(b.category));
+
+    return items;
+  }
+
+  sumBy(path: string, abs = false): number {
+    return super.sumBy(path, abs);
+  }
+}

package/projects/tt-core/src/lib/collections/report/index.ts

@@ -0,0 +1,8 @@
+export * from './depreciation/depreciation-lvp-report-item.collection';
+export * from './depreciation/depreciation-report-item.collection';
+export * from './property/property-report-item-depreciation.collection';
+export * from './property/property-report-item-transaction.collection';
+export * from './property/property-report-item.collection';
+export * from './vehicle-expense/vehicle-expense.collection';
+export * from './income-expense/transaction-report-item.collection';
+export * from './budget-report';

package/projects/tt-core/src/lib/collections/report/property/property-report-item-depreciation.collection.ts

@@ -0,0 +1,36 @@
+import { Collection } from '../../collection';
+import { ChartAccounts, Property } from '../../../models';
+import { DepreciationCollection } from '../../depreciation.collection';
+import { PropertyReportItemDepreciation } from '../../../models/report';
+import { PropertyReportItemCollection } from './property-report-item.collection';
+import { PropertyCollection } from '../../property';
+
+/**
+ * Collection to work with depreciation-based property report items
+ */
+export class PropertyReportItemDepreciationCollection extends PropertyReportItemCollection {
+  constructor(
+    depreciations: DepreciationCollection,
+    properties: PropertyCollection,
+    chartAccounts: Collection<ChartAccounts>
+  ) {
+    super();
+    this.setItems(depreciations, properties, chartAccounts)
+  }
+
+  private setItems(depreciations: DepreciationCollection, properties: PropertyCollection, chartAccounts: Collection<ChartAccounts>): void {
+    this.items = [];
+
+    properties.items.forEach((property: Property) => {
+      const depreciationsByType = depreciations.filterBy('property.id', property.id).groupBy('type');
+
+      depreciationsByType.keys.map((type: string) => {
+        this.items.push(new PropertyReportItemDepreciation(
+          depreciationsByType.get(type),
+          property,
+          chartAccounts.findBy('id', depreciationsByType.get(type).first.chartAccounts.id)
+        ));
+      });
+    });
+  }
+}

package/projects/tt-core/src/lib/collections/report/property/property-report-item-transaction.collection.ts

@@ -0,0 +1,35 @@
+import { Collection } from '../../collection';
+import { TransactionCollection } from '../../transaction';
+import { ChartAccounts, Property } from '../../../models';
+import { PropertyReportItemTransaction } from '../../../models/report';
+import { PropertyReportItemCollection } from './property-report-item.collection';
+import { PropertyCollection } from '../../property';
+
+/**
+ * Collection to work with transaction-based property report items
+ */
+export class PropertyReportItemTransactionCollection extends PropertyReportItemCollection {
+  constructor(
+    transactions: TransactionCollection,
+    properties: PropertyCollection,
+    chartAccounts: Collection<ChartAccounts>
+  ) {
+    super();
+    this.setItems(transactions, properties, chartAccounts);
+  }
+
+  private setItems(transactions: TransactionCollection, properties: PropertyCollection, chartAccounts: Collection<ChartAccounts>): void {
+    this.items = [];
+    properties.items.forEach((property: Property) => {
+      const transactionsDictionary = transactions.getByPropertiesIds([property.id]).groupBy('chartAccounts.id');
+
+      transactionsDictionary.keys.map((chartAccountId: string) => {
+        this.items.push(new PropertyReportItemTransaction(
+          transactionsDictionary.get(chartAccountId),
+          property,
+          chartAccounts.findBy('id', +chartAccountId)
+        ));
+      });
+    });
+  }
+}

package/projects/tt-core/src/lib/collections/report/property/property-report-item.collection.ts

@@ -0,0 +1,19 @@
+import { Collection } from '../../collection';
+import { PropertyReportItem } from '../../../models/report';
+
+/**
+ * Base collection to work with property report items
+ */
+export class PropertyReportItemCollection extends Collection<PropertyReportItem> {
+  getIncomes(): this {
+    return this.create(
+      this.items.filter((item: PropertyReportItem) => item.isIncome())
+    );
+  }
+
+  getExpenses(): this {
+    return this.create(
+      this.items.filter((item: PropertyReportItem) => item.isExpense())
+    );
+  }
+}

package/projects/tt-core/src/lib/collections/report/vehicle-expense/vehicle-expense.collection.ts

@@ -0,0 +1,32 @@
+import { Collection } from '../../collection';
+import { VehicleExpense } from '../../../models/report';
+import { TransactionCollection } from '../../transaction';
+import { DepreciationCollection } from '../../depreciation.collection';
+
+export class VehicleExpenseCollection extends Collection<VehicleExpense> {
+  constructor(transactions: TransactionCollection, depreciations: DepreciationCollection) {
+    super();
+    this.setItems(transactions, depreciations);
+  }
+
+  private setItems(transactions: TransactionCollection, depreciations: DepreciationCollection): void {
+    this.items = [];
+
+    const transactionsByChartAccounts = transactions.groupBy('chartAccounts.name');
+
+    const transactionExpenses: VehicleExpense[] = transactionsByChartAccounts.keys.map((chartAccountsName: string) => new VehicleExpense(
+      transactionsByChartAccounts.get(chartAccountsName).amount,
+      transactionsByChartAccounts.get(chartAccountsName).first.claimPercent,
+      chartAccountsName
+    ));
+
+    // group all depreciations into one expense item
+    const depreciationExpense: VehicleExpense = new VehicleExpense(
+      -depreciations.getCurrentYearForecastAmount(),
+      depreciations.first?.currentYearForecast?.claimPercent ?? 0,
+      'Depreciation'
+    );
+
+    this.items.push(...[depreciationExpense, ...transactionExpenses]);
+  }
+}

package/projects/tt-core/src/lib/collections/sole/index.ts

@@ -0,0 +1,3 @@
+export * from './sole-business-loss.collection';
+export * from './sole-invoice-item.collection';
+export * from './sole-invoice.collection';

package/projects/tt-core/src/lib/collections/sole/sole-business-loss.collection.ts

@@ -0,0 +1,52 @@
+import { Collection } from '../collection';
+import { SoleBusinessLoss, SoleBusinessLossOffsetRule } from '../../models';
+import { CollectionDictionary } from '../collection-dictionary';
+import { Dictionary } from '../../models';
+import { TransactionCollection } from '../transaction';
+
+export class SoleBusinessLossCollection extends Collection<SoleBusinessLoss> {
+  /**
+   * Business loss applied in current year, includes previous year losses and current year losses for businesses matching offset rule
+   */
+  calculateBusinessLossApplied(transactions: TransactionCollection): number {
+    // claim amounts for businesses that can be applied to be reduced by prior year business losses
+    const claimAmountsByBusinessId: Dictionary<number> = this.getClaimAmountsByBusinessId(transactions);
+
+    return Object.keys(claimAmountsByBusinessId.items).reduce((sum: number, businessId: string) => {
+      const loss: SoleBusinessLoss = this.findBy('business.id', +businessId);
+      const lossOpenBalance: number = loss?.openBalance || 0;
+
+      // business loss can be applied to business profit or other income types profit in case in offset rule met
+      return sum + (loss?.offsetRule ? lossOpenBalance : Math.min(lossOpenBalance, claimAmountsByBusinessId.get(businessId)));
+    }, 0)
+  }
+
+  /**
+   * Get business claim amounts that can be applied to be reduced by prior year business losses:
+   * businesses with income or businesses with a loss, but which met the non-commercial loss rules
+   * https://www.ato.gov.au/Business/Non-commercial-losses/
+   */
+  private getClaimAmountsByBusinessId(transactions: TransactionCollection): Dictionary<number> {
+    const claimAmountsByBusinessId: Dictionary<number> = new Dictionary<number>([]);
+
+    const transactionsByBusinessId: CollectionDictionary<TransactionCollection> = transactions.groupBy('business.id');
+
+    transactionsByBusinessId.keys.forEach((businessId: string) => {
+      // business loss may not exist if, when creating a business, user didn't add losses for previous years
+      const lossOffsetRule: SoleBusinessLossOffsetRule = this.findBy('business.id', +businessId)?.offsetRule;
+      const businessClaimAmount: number = transactionsByBusinessId
+        .get(businessId)
+        .getBusinessClaimAmount(+businessId);
+
+      // @TODO vik it has nothing to do with getClaimAmountsByBusinessId
+      // no way to apply loss for business without profit if offset rules not met
+      if (businessClaimAmount < 0 && !lossOffsetRule) {
+        return;
+      }
+
+      claimAmountsByBusinessId.add(businessId, businessClaimAmount);
+    });
+
+    return claimAmountsByBusinessId;
+  }
+}

package/projects/tt-core/src/lib/collections/sole/sole-invoice-item.collection.ts

@@ -0,0 +1,13 @@
+import { Collection } from '../collection';
+import { SoleInvoiceItem } from '../../models';
+import { SoleInvoiceTaxTypeEnum } from '../../db/Enums';
+
+export class SoleInvoiceItemCollection extends Collection<SoleInvoiceItem>{
+  get gstItems(): this {
+    return this.filterBy('isGST', true);
+  }
+
+  getTotalPrice(taxType: SoleInvoiceTaxTypeEnum, includeGST = false): number {
+    return this.reduce((sum, item) => sum + item.getTotalPrice(taxType, includeGST));
+  }
+}

package/projects/tt-core/src/lib/collections/sole/sole-invoice.collection.ts

@@ -0,0 +1,61 @@
+import { Collection } from '../collection';
+import { BankTransaction, SoleInvoice, Transaction } from '../../models';
+import flatten from 'lodash/flatten';
+import { TransactionCollection } from '../transaction';
+import { SoleInvoiceStateEnum, SoleInvoiceStatusesEnum } from '../../db/Enums';
+import { CollectionDictionary } from '../collection-dictionary';
+import round from 'lodash/round';
+
+export class SoleInvoiceCollection extends Collection<SoleInvoice> {
+  getOverdue(): this {
+    return this.filter((invoice: SoleInvoice) => invoice.isOverdue());
+  }
+
+  getPaid(transactions: TransactionCollection): this {
+    const amountPerInvoice = transactions.getAmountPerInvoice();
+    return this.filter(invoice => invoice.grossPrice > 0
+      && round(amountPerInvoice.get(invoice.id), 2) >= invoice.grossPrice.toFixed(2)
+    );
+  }
+
+  getUnpaid(transactions: TransactionCollection): this {
+    const amountPerInvoice = transactions.getAmountPerInvoice();
+    return this.getOpen().filter(invoice => round(amountPerInvoice.get(invoice.id), 2) < invoice.grossPrice.toFixed(2));
+  }
+
+  getOpen(): this {
+    return this.filter((invoice: SoleInvoice) => invoice.isOpen());
+  }
+
+  getInvoiceItemsIds(): number[] {
+    return flatten(
+      this.map(invoice => invoice.items.map(item => item.id))
+    );
+  }
+
+  groupByState(transactions: TransactionCollection): CollectionDictionary<SoleInvoiceCollection> {
+    const invoicesByState = this.groupBy('status');
+    const unpaidInvoices = this.getUnpaid(transactions);
+
+    invoicesByState.add(SoleInvoiceStateEnum.FULLY_PAID, this.getPaid(transactions));
+    invoicesByState.add(
+      SoleInvoiceStateEnum.PAID,
+      this.filterBy('id', transactions.filterByFinancialYear('date').map(transaction => transaction.invoiceId))
+    );
+    invoicesByState.add(
+      SoleInvoiceStatusesEnum.OPEN,
+      invoicesByState.get(SoleInvoiceStatusesEnum.OPEN).remove(invoicesByState.get(SoleInvoiceStateEnum.FULLY_PAID).toArray())
+    );
+    invoicesByState.add(SoleInvoiceStateEnum.OVERDUE, unpaidInvoices.getOverdue());
+
+    return invoicesByState
+  }
+
+  getUnpaidAmount(transactions: TransactionCollection): number {
+    return this.sumBy('grossPrice') - transactions.getByInvoices(this).sumBy('grossAmount');
+  }
+
+  allocate(bankTransaction: BankTransaction, amount?: number): Transaction[] {
+    return flatten(this.map(invoice => invoice.allocate(bankTransaction, amount)));
+  }
+}

package/projects/tt-core/src/lib/collections/subscription/index.ts

@@ -0,0 +1,4 @@
+export * from './service-price.collection';
+export * from './service-product.collection'
+export * from './service-subscription.collection';
+export * from './subscription-item.collection';

package/projects/tt-core/src/lib/collections/subscription/service-price.collection.ts

@@ -0,0 +1,36 @@
+import { Collection } from '../collection';
+import { ServicePrice } from '../../models';
+import { ServicePriceTypeEnum } from '../../db/Enums/subscription/service-price-type.enum';
+import { ServiceProductIdEnum } from '../../db/Enums/subscription/service-product-id.enum';
+import { ServiceProductCollection } from './service-product.collection';
+
+/**
+ * @TODO vik refactor
+ */
+export class ServicePriceCollection extends Collection<ServicePrice> {
+  getActive(): this {
+    return this.filterBy('isActive', true);
+  }
+
+  get monthly(): this {
+    return this.filterBy('type', ServicePriceTypeEnum.MONTHLY);
+  }
+
+  get annual(): this {
+    return this.filterBy('type', ServicePriceTypeEnum.ANNUAL);
+  }
+
+  get annualPackage(): this {
+    return this.filterBy('type', ServicePriceTypeEnum.YEARLY_PACKAGE);
+  }
+
+  getProperty(): ServicePrice {
+    return this
+      .filterBy('type', ServicePriceTypeEnum.ANNUAL)
+      .findBy('product.id', ServiceProductIdEnum.PROPERTIES);
+  }
+
+  get products(): ServiceProductCollection {
+    return new ServiceProductCollection(this.mapBy('product'));
+  }
+}