taxtank 0.1.0

package/projects/tt-core/src/lib/models/tax-summary/report-item.ts

@@ -0,0 +1,36 @@
+import { AbstractModel, TaxReturnCategory } from '../../db/Models';
+import { ReportItemDetails } from './report-item-details';
+import { Transform, Type } from 'class-transformer';
+import { Collection, ReportItemCollection } from '../../collections';
+
+/**
+ * @Todo no base model - should be generated on backend side
+ * Used in tax summary reports to show amounts relating to a tax return category entity and details of what this
+ * amount is comprised of. Example here shows an amount of $951.96 and also details of what this amount is comprised of:
+ */
+export class ReportItem extends AbstractModel {
+  amount: number;
+  taxReturnCategory: TaxReturnCategory;
+  title: string;
+
+  @Type(() => ReportItem)
+  @Transform(({ value }) => new ReportItemCollection(value))
+  items: ReportItemCollection;
+
+  /**
+   * @Todo Alex: We need to apply this everywhere - transform an array into a collection,
+   * but at the moment we can't do this due to inheritance from the base model.
+   * Potential solution: Inherit Collection from Array
+   */
+  @Type(() => ReportItemDetails)
+  @Transform(({ value }) => new Collection<ReportItemDetails>(value))
+  details: Collection<ReportItemDetails>;
+
+  /**
+   * Get amount for one income source
+   * @param name Name of income source for filter
+   */
+  getAmountByIncomeSourceName(name: string): number {
+    return this.details.find((detail: ReportItemDetails): boolean => detail.name === name)?.amount || 0;
+  }
+}

package/projects/tt-core/src/lib/models/tax-summary/tax-summary-section.ts

@@ -0,0 +1,34 @@
+import { TaxSummarySectionEnum } from '../../db/Enums/tax-summary-section.enum';
+import { ReportItem } from './report-item';
+import { ReportItemCollection } from '../../collections';
+import { Transform, Type } from 'class-transformer';
+
+/**
+ * Base class for each sections of Tax Summary report, contains common properties/methods
+ * See also TaxSummary model
+ */
+export class TaxSummarySection {
+  section: TaxSummarySectionEnum;
+  netAmount: number;
+
+  @Type(() => ReportItem)
+  @Transform(({ value }) => new ReportItemCollection(value))
+  items: ReportItemCollection;
+
+  // id that will be added as HTML Id
+  @Transform(({ obj }) => {
+    switch (obj.section) {
+      case TaxSummarySectionEnum.WORK_TANK:
+        return 'taxSummaryWorkTank';
+      case TaxSummarySectionEnum.PROPERTY_TANK:
+        return 'taxSummaryPropertyTank';
+      case TaxSummarySectionEnum.HOLDINGS_TANK:
+        return 'taxSummaryOtherIncome';
+      case TaxSummarySectionEnum.SOLE_TANK:
+        return 'taxSummarySoleTank';
+      default:
+        return 'taxSummaryTotal';
+    }
+  })
+  id?: string;
+}

package/projects/tt-core/src/lib/models/tax-summary/tax-summary-type.enum.ts

@@ -0,0 +1,7 @@
+/**
+ * Enum for tax summary types
+ */
+export enum TaxSummaryTypeEnum {
+  ACTUALS = 'actuals',
+  FORECASTS = 'forecasts'
+}

package/projects/tt-core/src/lib/models/tax-summary/tax-summary.ts

@@ -0,0 +1,237 @@
+import { TaxSummarySection } from './tax-summary-section';
+import { Type } from 'class-transformer';
+import { ReportItemCollection, TAX_RETURN_CATEGORIES } from '../../collections';
+import { TaxReturnCategoryListEnum } from '../../db/Enums';
+import { TaxSummarySectionEnum } from '../../db/Enums/tax-summary-section.enum';
+import { SoleBusiness } from '../sole';
+
+/**
+ * @Todo refactor with base model when it will be provided
+ * Tax summary report structure
+ */
+export class TaxSummary {
+  @Type(() => TaxSummarySection)
+  work: TaxSummarySection;
+
+  @Type(() => TaxSummarySection)
+  property: TaxSummarySection;
+
+  @Type(() => TaxSummarySection)
+  holdings: TaxSummarySection;
+
+  @Type(() => TaxSummarySection)
+  capitalGains: TaxSummarySection;
+
+  @Type(() => TaxSummarySection)
+  sole: TaxSummarySection;
+
+  @Type(() => TaxSummarySection)
+  summary: TaxSummarySection;
+
+  projectedTaxPosition: number;
+
+  get sections(): TaxSummarySection[] {
+    return [this.work, this.property, this.holdings, this.capitalGains, this.sole, this.summary];
+  }
+
+  getReportItems(sections: TaxSummarySection[]): ReportItemCollection {
+    return new ReportItemCollection([].concat(...sections.map((section) => section.items.toArray())));
+  }
+
+  get taxPercent(): number {
+    // Check if netAmount is not 0 to avoid division by zero
+    if (!this.summary.netAmount) {
+      return 0;
+    }
+
+    return this.summary.items.findByCategory(TaxReturnCategoryListEnum.GROSS_TAX_PAYABLE).amount / this.summary.netAmount;
+  }
+
+  /**
+   * Work Net Cash = Income - tax withheld - expenses - interest
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+   */
+  get workNetCash(): number {
+    return this.workNetTotal + this.workTaxCredits;
+  }
+
+  get workTaxCredits(): number {
+    const taxWithheld: number = this.summary.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.work.taxWithheld, TaxSummarySectionEnum.WORK_TANK);
+    const taxInstallments: number = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.WORK_TAX_INSTALMENTS], TaxSummarySectionEnum.SUMMARY);
+    const frankingCredits = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.FRANKING_CREDITS], TaxSummarySectionEnum.WORK_TANK);
+
+    return taxWithheld + taxInstallments + frankingCredits;
+  }
+
+  get soleTaxCredits(): number {
+    const taxOffsets: number = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.TAX_OFFSETS_SOLE], TaxSummarySectionEnum.SOLE_TANK);
+    const taxInstallments: number = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.SOLE_TAX_INSTALMENTS], TaxSummarySectionEnum.SUMMARY);
+
+    return taxOffsets + taxInstallments;
+  }
+
+  get income(): number {
+    return this.getReportItems([this.work, this.property, this.sole, this.holdings]).sumByCategories([
+      ...TAX_RETURN_CATEGORIES.work.income,
+      ...TAX_RETURN_CATEGORIES.property.income,
+      ...TAX_RETURN_CATEGORIES.sole.income,
+      ...TAX_RETURN_CATEGORIES.holdings.income,
+    ]);
+  }
+
+  get expense(): number {
+    return this.getReportItems([this.work, this.property, this.sole, this.holdings]).sumByCategories([
+      ...TAX_RETURN_CATEGORIES.work.expenses,
+      ...TAX_RETURN_CATEGORIES.property.expenses,
+      TaxReturnCategoryListEnum.BORROWING_EXPENSES,
+      ...TAX_RETURN_CATEGORIES.property.interest,
+      ...TAX_RETURN_CATEGORIES.property.depreciation,
+      ...TAX_RETURN_CATEGORIES.sole.expenses,
+      ...TAX_RETURN_CATEGORIES.sole.depreciation,
+      ...TAX_RETURN_CATEGORIES.holdings.expenses,
+    ]) - this.soleLossesApplied;
+  }
+
+  get taxCredits(): number {
+    return this.summary.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.summary.taxCredits, TaxSummarySectionEnum.SUMMARY)
+  }
+
+  get depreciation(): number {
+    return this.sole.items.sumByCategories(TAX_RETURN_CATEGORIES.sole.depreciation)
+      + this.property.items.sumByCategoriesAndSection(
+        TAX_RETURN_CATEGORIES.property.depreciation,
+        TaxSummarySectionEnum.PROPERTY_TANK
+      )
+      + this.workDepreciations;
+  }
+
+  get netCash(): number {
+    return this.netTotal + this.taxCredits - this.depreciation;
+  }
+
+  get netTotal(): number {
+    return this.income + this.expense;
+  }
+
+  /**
+   * Work Net Total = Income - expenses - interest
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+   */
+  get workNetTotal(): number {
+    const income: number = this.work.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.work.income, TaxSummarySectionEnum.WORK_TANK);
+    const expenses: number = this.work.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.work.expenses, TaxSummarySectionEnum.WORK_TANK);
+    const interest: number = this.summary.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.work.interest, TaxSummarySectionEnum.WORK_TANK);
+
+    return income - Math.abs(expenses) - Math.abs(interest);
+  }
+
+  get workDepreciations(): number {
+    return this.work.items
+      .findByCategory(TaxReturnCategoryListEnum.WORK_OTHER_EXPENSES)?.details?.items
+      .find(item => item.name === 'Depreciation')?.amount ?? 0;
+  }
+
+  /**
+   * Property Net Cash (Cash Position) = Rental Income - expenses - interest
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+   */
+  get propertyNetCash(): number {
+    const income: number = this.property.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.property.income, TaxSummarySectionEnum.PROPERTY_TANK);
+    const expenses: number = this.property.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.property.expenses, TaxSummarySectionEnum.PROPERTY_TANK);
+    const interest: number = this.property.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.property.interest, TaxSummarySectionEnum.PROPERTY_TANK);
+
+    return income - Math.abs(expenses) - Math.abs(interest);
+  }
+
+  /**
+   * Property Net Total (Tax Position) = Rental Income - expenses - interest - depreciation
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+   */
+  get propertyNetTotal(): number {
+    const depreciation: number = this.property.items.sumByCategoriesAndSection(
+      TAX_RETURN_CATEGORIES.property.depreciation,
+      TaxSummarySectionEnum.PROPERTY_TANK
+    );
+
+    const borrowingExpenses: number = this.property.items.sumByCategoriesAndSection(
+      [TaxReturnCategoryListEnum.BORROWING_EXPENSES],
+      TaxSummarySectionEnum.PROPERTY_TANK
+    );
+
+    return this.propertyNetCash - Math.abs(depreciation) - Math.abs(borrowingExpenses);
+  }
+
+  /**
+   * Holdings Net Cash = gross income – expenses – tax withheld - tax instalments
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+   */
+  get holdingsNetTotal(): number {
+    const income: number = this.holdings.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.holdings.income, TaxSummarySectionEnum.HOLDINGS_TANK);
+    const expenses: number = this.holdings.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.holdings.expenses, TaxSummarySectionEnum.HOLDINGS_TANK);
+
+    return income + expenses;
+  }
+
+  /**
+   * Holding Net Total = Gross income - expenses + tax offsets + tax instalments + franking credits
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+   */
+  get holdingsNetCash(): number {
+    return this.holdingsNetTotal + this.holdingsTaxCredits;
+  }
+
+  get holdingsTaxCredits(): number {
+    const frankingCredits = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.FRANKING_CREDITS], TaxSummarySectionEnum.HOLDINGS_TANK);
+    const taxWithheld: number = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.TAX_WITHHELD], TaxSummarySectionEnum.HOLDINGS_TANK);
+    const taxInstallments: number = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.HOLDINGS_TAX_INSTALMENTS], TaxSummarySectionEnum.SUMMARY);
+
+    return taxInstallments + frankingCredits + taxWithheld;
+  }
+
+  /**
+   * Sole Net Cash = gross income – expenses
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+   */
+  get soleNetCash(): number {
+    const income = this.sole.items.sumByCategories(TAX_RETURN_CATEGORIES.sole.income);
+    const expense = this.sole.items.sumByCategories(TAX_RETURN_CATEGORIES.sole.expenses);
+
+    return income + expense + this.soleTaxCredits;
+  }
+
+  get soleLossesApplied(): number {
+    return this.sole.items.sumByCategories([TaxReturnCategoryListEnum.BUSINESS_LOSSES_APPLIED]);
+  }
+
+  /**
+   * Sole Net Total = Gross income - expenses
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+   */
+  get soleNetTotal(): number {
+    return this.sole.netAmount;
+  }
+
+  getDeferredBusinessLoss(business: SoleBusiness): number {
+    return this.sole.items
+      .findByCategory(TaxReturnCategoryListEnum.DEFERRED_BUSINESS_LOSSES).items
+      .findBy('title', `Item 15c - ${business.name}`)?.amount;
+  }
+
+  getBusinessCloseBalance(business: SoleBusiness): number {
+    return this.sole.items
+      .findByCategory(TaxReturnCategoryListEnum.BUSINESS_INCOME_OR_LOSS).items
+      .findBy('title', `Item 15c - ${business.name}`)?.amount;
+  }
+
+  get capitalGainsProperty(): number {
+    return this.capitalGains.items.first.items.findBy('title', 'Property Tank')?.amount ?? 0;
+  }
+
+  get capitalGainsHoldings(): number {
+    return this.capitalGains.items.first.items.findBy('title', 'Holdings Tank')?.amount ?? 0;
+  }
+
+  get capitalGainsNetCash(): number {
+    return this.capitalGainsProperty + this.capitalGainsHoldings;
+  }
+}

package/projects/tt-core/src/lib/models/toast/toast-type.enum.ts

@@ -0,0 +1,6 @@
+export enum ToastTypeEnum {
+  INFO,
+  SUCCESS,
+  WARNING,
+  ERROR
+}

package/projects/tt-core/src/lib/models/toast/toast.ts

@@ -0,0 +1,15 @@
+import { ToastTypeEnum } from './toast-type.enum';
+
+/**
+ * Common toast message class
+ */
+export class Toast {
+  type: ToastTypeEnum;
+  title: string;
+  message: string;
+  duration = 3000;
+  autoClose = true;
+  date: Date;
+  onCloseClick: () => {};
+  onCTAClick: () => {};
+}

package/projects/tt-core/src/lib/models/transaction/allocation-rule-condition.ts

@@ -0,0 +1,48 @@
+import {
+  AllocationRuleCondition as AllocationRuleConditionBase
+} from '../../db/Models/transaction/allocation-rule-condition';
+import { BankTransaction } from '../bank';
+import { AllocationRuleConditionComparisonOperatorEnum, AllocationRuleConditionFieldEnum } from '../../db/Enums';
+import { Transform } from 'class-transformer';
+
+export class AllocationRuleCondition extends AllocationRuleConditionBase {
+  @Transform(({ value }) => value.toString(), { toPlainOnly: true })
+  value: string;
+
+  matchBankTransaction(bankTransaction: BankTransaction): boolean {
+    return this.field === AllocationRuleConditionFieldEnum.AMOUNT ? this.matchBankTransactionByAmount(bankTransaction) : this.matchBankTransactionByDescription(bankTransaction);
+  }
+
+  matchBankTransactionByAmount(bankTransaction: BankTransaction): boolean {
+    // Amount should be compared as number
+    const value: number = +this.value;
+
+    switch (this.comparisonOperator) {
+      case AllocationRuleConditionComparisonOperatorEnum.EQUALS:
+        return bankTransaction.amount === value;
+      case AllocationRuleConditionComparisonOperatorEnum.EQUALS_OR_LESS:
+        return bankTransaction.amount <= value;
+      case AllocationRuleConditionComparisonOperatorEnum.EQUALS_OR_GREATER:
+        return bankTransaction.amount >= value;
+    }
+
+    return false;
+  }
+
+  matchBankTransactionByDescription(bankTransaction: BankTransaction): boolean {
+    // Prepare value and description for comparison
+    const description: string = bankTransaction.description.toLowerCase();
+    const value: string = this.value.trim().toLowerCase();
+
+    switch (this.comparisonOperator) {
+      case AllocationRuleConditionComparisonOperatorEnum.EQUALS:
+        return description === value;
+      case AllocationRuleConditionComparisonOperatorEnum.CONTAINS:
+        return description.includes(value);
+      case AllocationRuleConditionComparisonOperatorEnum.STARTS:
+        return description.startsWith(value);
+    }
+
+    return false;
+  }
+}

package/projects/tt-core/src/lib/models/transaction/allocation-rule-transaction-meta-field.ts

@@ -0,0 +1,4 @@
+import { AllocationRuleTransactionMetaField as AllocationRuleTransactionMetaFieldBase } from '../../db/Models/transaction/allocation-rule-transaction-meta-field';
+
+export class AllocationRuleTransactionMetaField extends AllocationRuleTransactionMetaFieldBase {
+}

package/projects/tt-core/src/lib/models/transaction/allocation-rule-transaction.ts

@@ -0,0 +1,115 @@
+import {
+  AllocationRuleTransaction as AllocationRuleTransactionBase
+} from '../../db/Models/transaction/allocation-rule-transaction';
+import { ChartAccounts } from '../chart-accounts';
+import { Transform, Type, plainToClass } from 'class-transformer';
+import { AllocationRuleTransactionMetaField } from './allocation-rule-transaction-meta-field';
+import { BankTransaction, Loan, Property, SoleBusiness, Transaction, TransactionAllocation } from '../../models';
+import { IncomeSource } from '../income-source';
+import { ChartAccountsListEnum } from '../../db/Enums';
+import merge from 'lodash/merge';
+import { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';
+import { TransactionTypeEnum } from '../../db/Enums/transaction-type.enum';
+import { TransactionSourceEnum } from '../../db/Enums/transaction-source.enum';
+
+export class AllocationRuleTransaction extends AllocationRuleTransactionBase {
+  @Type(() => ChartAccounts)
+  // @TODO Alex: Create custom decorator for this transform
+  @Transform(({ value }) => ({ id: value.id }), { toPlainOnly: true })
+  chartAccounts: ChartAccounts;
+
+  @Type(() => Property)
+  @Transform(({ value }) => value ? { id: value.id } : null, { toPlainOnly: true })
+  property: Property;
+
+  @Type(() => Loan)
+  @Transform(({ value }) => value ? { id: value.id } : null, { toPlainOnly: true })
+  loan: Loan;
+
+  @Type(() => IncomeSource)
+  @Transform(({ value }) => value ? { id: value.id } : null, { toPlainOnly: true })
+  incomeSource?: IncomeSource;
+
+  @Type(() => SoleBusiness)
+  @Transform(({ value }) => value ? { id: value.id } : null, { toPlainOnly: true })
+  business: SoleBusiness;
+
+  @Type(() => AllocationRuleTransactionMetaField)
+  metaFields: AllocationRuleTransactionMetaField[];
+
+  @Type(() => AllocationRuleTransaction)
+  parentTransaction: AllocationRuleTransaction;
+
+  @Type(() => AllocationRuleTransaction)
+  childTransactions: AllocationRuleTransaction[];
+
+  @Type(() => Number) claimPercent = 100;
+  @Type(() => Number) tax = 0;
+
+  amount: number = null;
+
+  get amountPercentCoefficient(): number {
+    return this.amountPercent ? this.amountPercent / 100 : 1;
+  }
+
+  calculateClaimPercent(): number {
+    if (!this.chartAccounts) {
+      return null;
+    }
+
+    let claimPercent = this.chartAccounts.taxablePercent;
+
+    // Property claim (ownership% x shared%) for property expenses, taxable percent for others
+    if (this.chartAccounts?.isProperty() && this.property) {
+      if (this.chartAccounts.isPropertyExpense() && this.chartAccounts.id !== ChartAccountsListEnum.PLATFORM_FEES) {
+        claimPercent *= this.property?.claimCoefficient;
+      }
+    }
+
+    return claimPercent;
+  }
+
+  /**
+   * If rule transaction has amount then split enabled. There is 0 when split disabled
+   */
+  isSplit(): boolean {
+    return !!this.amountPercent;
+  }
+
+  /**
+   * Create Transaction instance based on passed bank transaction and rule transaction
+   */
+  toTransaction(bankTransaction: BankTransaction = null): Transaction {
+    const transaction = bankTransaction ? bankTransaction.toTransaction(this.isGST) : plainToClass(Transaction, {});
+    Object.assign(transaction, {
+      isGST: this.isGST,
+      tax: this.tax,
+      claimPercent: this.claimPercent,
+      chartAccounts: this.chartAccounts,
+      property: this.property,
+      loan: this.loan,
+      incomeSource: this.incomeSource,
+      metaFields: this.metaFields,
+      business: this.business,
+      source: TransactionSourceEnum.BANK_TRANSACTION,
+      operation: TransactionOperationEnum.ALLOCATE,
+      transactions: [],
+    });
+
+    // split allocation
+    if (this.amountPercent) {
+      transaction.amount = bankTransaction.amount * this.amountPercentCoefficient / this.gstCoefficient;
+    }
+
+    // child transactions inherit most of the fields from parent transaction
+    this.childTransactions.forEach((childRuleTransaction: AllocationRuleTransaction) => {
+      const childTransaction = childRuleTransaction.toTransaction();
+      childTransaction.amount = childRuleTransaction.amount;
+      childTransaction.setParent(transaction);
+
+      transaction.transactions.push(childTransaction);
+    });
+
+    return transaction;
+  }
+}

package/projects/tt-core/src/lib/models/transaction/allocation-rule.ts

@@ -0,0 +1,156 @@
+import { AllocationRule as AllocationRuleBase } from '../../db/Models/transaction/allocation-rule';
+import { BankAccount, BankTransaction } from '../bank';
+import { Transform, Type, plainToClass } from 'class-transformer';
+import { AllocationRuleCondition } from './allocation-rule-condition';
+import { AllocationRuleTransaction } from './allocation-rule-transaction';
+import {
+  AllocationRuleConditionComparisonOperatorEnum,
+  AllocationRuleConditionFieldEnum,
+  AllocationRuleConditionOperatorEnum,
+  AllocationRuleTypeEnum, ChartAccountsListEnum
+} from '../../db/Enums';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import { Transaction } from './transaction';
+import { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';
+import { ChartAccounts } from '../chart-accounts';
+import { TransactionAllocation } from './transaction-allocation';
+
+export class AllocationRule extends AllocationRuleBase {
+  @Type(() => BankAccount)
+  @Transform(({ value }) => ({ id: value.id }), { toPlainOnly: true })
+  bankAccount?: BankAccount;
+
+  @Type(() => AllocationRuleCondition)
+  conditions?: AllocationRuleCondition[];
+
+  @Type(() => AllocationRuleTransaction)
+  transaction?: AllocationRuleTransaction;
+
+  @Type(() => BankAccount)
+  transferBankAccount?: BankAccount;
+
+  type: AllocationRuleTypeEnum = AllocationRuleTypeEnum.EXPENSE;
+  conditionOperator: AllocationRuleConditionOperatorEnum = AllocationRuleConditionOperatorEnum.OR;
+  autoAllocate = false;
+
+  get typeLabel(): string {
+    switch (this.type) {
+      case AllocationRuleTypeEnum.EXPENSE:
+        return 'expense';
+
+      case AllocationRuleTypeEnum.INCOME:
+        return 'income';
+
+      default:
+        return 'transfer';
+    }
+  }
+
+  isIncome(): boolean {
+    return this.type === AllocationRuleTypeEnum.INCOME;
+  }
+
+  isExpense(): boolean {
+    return this.type === AllocationRuleTypeEnum.EXPENSE;
+  }
+
+  isTransfer(): boolean {
+    return this.type === AllocationRuleTypeEnum.TRANSFER;
+  }
+
+  isPropertyTank(): boolean {
+    return this.transaction.tankType === TankTypeEnum.PROPERTY;
+  }
+
+  isWorkTank(): boolean {
+    return this.transaction.tankType === TankTypeEnum.WORK;
+  }
+
+  isSoleTank(): boolean {
+    return this.transaction.tankType === TankTypeEnum.SOLE;
+  }
+
+  isPropertyIncome(): boolean {
+    return this.isIncome() && this.isPropertyTank();
+  }
+
+  isWorkIncome(): boolean {
+    return this.isIncome() && this.isWorkTank();
+  }
+
+  isSoleIncome(): boolean {
+    return this.isIncome() && this.isSoleTank();
+  }
+
+  /**
+   * @TODO Alex: move to collection
+   */
+  matchBankTransaction(bankTransaction: BankTransaction): boolean {
+    return this.conditionOperator === AllocationRuleConditionOperatorEnum.AND ? this.checkAnd(bankTransaction) : this.checkOr(bankTransaction);
+  }
+
+  createTransaction(bankTransaction: BankTransaction): Transaction {
+    if (this.isTransfer()) {
+      const transaction: Transaction = bankTransaction.toTransaction();
+
+      transaction.operation = TransactionOperationEnum.TRANSFER;
+      transaction.chartAccounts = plainToClass(ChartAccounts, { id: ChartAccountsListEnum.TRANSFER });
+
+      return transaction;
+    }
+
+    const transaction = this.transaction.toTransaction(bankTransaction);
+    transaction.allocations = [TransactionAllocation.create(transaction.amountWithGst, bankTransaction)];
+
+    return transaction;
+  }
+
+  /**
+   * Rule is matched when all conditions matched
+   */
+  private checkAnd(bankTransaction: BankTransaction): boolean {
+    for (const condition of this.conditions) {
+      if (!condition.matchBankTransaction(bankTransaction)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Rule is matched when at least one condition matched
+   */
+  private checkOr(bankTransaction: BankTransaction): boolean {
+    for (const condition of this.conditions) {
+      if (condition.matchBankTransaction(bankTransaction)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Create allocation rule based on bank transaction (just prefill rule fields with bank transaction values)
+   */
+  static fromBankTransaction(bankTransaction: BankTransaction): AllocationRule {
+    return plainToClass(AllocationRule, {
+      type: bankTransaction.isDebit() ? AllocationRuleTypeEnum.EXPENSE : AllocationRuleTypeEnum.INCOME,
+      bankAccount: bankTransaction.bankAccount,
+      conditionOperator: AllocationRuleConditionOperatorEnum.AND,
+      conditions: [
+        plainToClass(AllocationRuleCondition, {
+          field: AllocationRuleConditionFieldEnum.AMOUNT,
+          comparisonOperator: AllocationRuleConditionComparisonOperatorEnum.EQUALS,
+          value: bankTransaction.amount
+        }),
+        plainToClass(AllocationRuleCondition, {
+          field: AllocationRuleConditionFieldEnum.DESCRIPTION,
+          comparisonOperator: AllocationRuleConditionComparisonOperatorEnum.EQUALS,
+          value: bankTransaction.description
+        })
+      ]
+    });
+  }
+}

package/projects/tt-core/src/lib/models/transaction/income-amount-type.enum.ts

@@ -0,0 +1,7 @@
+/**
+ * Enum with income amount types (Net or Gross)
+ */
+export enum IncomeAmountTypeEnum {
+  NET,
+  GROSS
+}

package/projects/tt-core/src/lib/models/transaction/index.ts

@@ -0,0 +1,8 @@
+export * from './allocation-rule';
+export * from './allocation-rule-transaction';
+export * from './allocation-rule-transaction-meta-field';
+export * from './income-amount-type.enum';
+export * from './transaction';
+export * from './transaction-allocation';
+export * from './transaction-category.enum';
+export * from './transaction-meta-field';