taxtank 0.1.0

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

@@ -0,0 +1,329 @@
+import {
+  CHART_ACCOUNTS_CATEGORIES,
+  Dictionary,
+  Transaction,
+  TransactionMetaField,
+  VehicleClaim
+} from '../../models';
+import { TransactionAllocationCollection } from './transaction-allocation.collection';
+import { BusinessChartAccountsEnum, ChartAccountsCategoryEnum, ChartAccountsListEnum } from '../../db/Enums';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import { plainToClass } from 'class-transformer';
+import { ExportCell } from '../../models/export/export-cell';
+import { ExportCellTypeEnum } from '../../models/export/export-cell-type.enum';
+import { Collection } from '../collection';
+import { ChartData } from '../../models/chart/chart-data';
+import { Depreciation, FinancialYear, MONTHS } from '../../models';
+import { SoleInvoiceCollection } from '../sole';
+import { TransactionBaseCollection } from './transaction-base.collection';
+import { BudgetRuleCollection } from '../budget';
+
+/**
+ * Collection of transactions
+ */
+export class TransactionCollection extends TransactionBaseCollection<Transaction> {
+  /**
+   * we use depreciations as expense transactions a lot
+   */
+  constructor(transactions: Transaction[] = [], depreciations: Depreciation[] = []) {
+    if (depreciations.length) {
+      transactions = transactions.filter(
+        transaction => !CHART_ACCOUNTS_CATEGORIES.depreciation.includes(transaction.chartAccounts.category)
+      );
+    }
+    super([...transactions, ...depreciations.map((depreciation) => depreciation.toTransaction())]);
+  }
+
+  getSoleTransactions(): this {
+    return this.filter((transaction: Transaction) => transaction.isSoleTank());
+  }
+
+  getFindAndMatch(allocations: TransactionAllocationCollection): this {
+    return this.filter((transaction) => transaction.canFindAndMatch(allocations));
+  }
+
+  getUnallocated(allocations: TransactionAllocationCollection): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => !transaction.isAllocated(allocations))
+    );
+  }
+
+  getUnallocatedAmount(allocations: TransactionAllocationCollection): number {
+    return this.items.reduce((sum: number, transaction: Transaction): number =>
+      sum + transaction.getUnallocatedAmount(allocations.filterBy('transaction.id', transaction.id)), 0);
+  }
+
+  /**
+   * get date of the last transaction
+   */
+  getLastTransactionDate(): Date {
+    return new Date(Math.max.apply(Math, this.items.map((transaction: Transaction) => transaction.date)));
+  }
+
+  get amount(): number {
+    return this.sumBy('amount');
+  }
+
+  get claimAmount(): number {
+    return this.items.reduce((sum: number, transaction: Transaction) => sum + transaction.claimAmount, 0);
+  }
+
+  get grossAmount(): number {
+    return this.items.reduce((sum: number, transaction: Transaction) => sum + transaction.grossAmount, 0);
+  }
+
+  get grossClaimAmount(): number {
+    return this.items.reduce((sum: number, transaction: Transaction) => sum + transaction.grossClaimAmount, 0);
+  }
+
+  getGrossClaimAmountWithoutGst(): number {
+    return this.items.reduce((sum: number, transaction: Transaction) => sum + transaction.grossClaimAmountWithoutGst, 0);
+  }
+
+  getByChartAccountsCategories(categories: ChartAccountsCategoryEnum[]): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => categories.includes(transaction.chartAccounts.category))
+    );
+  }
+
+  /**
+   * Get transactions by month
+   * @param monthIndex by which desired month should be taken
+   */
+  getByMonth(monthIndex: number): TransactionCollection {
+    return new TransactionCollection(this.items.filter((transaction: Transaction): boolean =>
+      transaction.date.getMonth() === monthIndex
+    ));
+  }
+
+  /**
+   * Get collection of transactions meta fields
+   */
+  getTransactionsMetaFields(): Collection<TransactionMetaField> {
+    const metaFieldsArray: TransactionMetaField[] = [];
+
+    this.items.forEach((transaction: Transaction) => {
+      metaFieldsArray.push(...transaction.metaFields);
+    });
+
+    return new Collection<TransactionMetaField>(metaFieldsArray);
+  }
+
+  getIncomeTransactions(): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.isIncome())
+    );
+  }
+
+  getExpenseTransactions(): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.isExpense() && !transaction.isInterest())
+    );
+  }
+
+  get grossClaimIncome(): number {
+    return this.getIncomeTransactions().grossClaimAmount;
+  }
+
+  get claimExpense(): number {
+    return this.getExpenseTransactions().claimAmount;
+  }
+
+  getInterestTransactions(): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.isInterest())
+    );
+  }
+
+  get claimInterest(): number {
+    return this.getInterestTransactions().claimAmount;
+  }
+
+  /**
+   * Get collection of transactions and properties filtered by properties ids
+   * @param ids Ids of properties for filter
+   */
+  getByPropertiesIds(ids: number[]): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => ids.includes(transaction.property?.id))
+    );
+  }
+
+  /**
+   * Get new collection filtered by income source id
+   * @param id id of income source for filter
+   */
+  getByIncomeSourceId(id: number): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.incomeSource?.id === id)
+    );
+  }
+
+  /**
+   * Get new collection filtered by chart accounts category
+   * @param category Chart accounts category value
+   */
+  getByChartAccountsCategory(category: ChartAccountsCategoryEnum): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.chartAccounts.category === category)
+    );
+  }
+
+  /**
+   * Get new collection of property transactions
+   */
+  getPropertyTransactions(): TransactionCollection {
+    return this.filterBy('tankType', TankTypeEnum.PROPERTY);
+  }
+
+  getDebitTransactions(): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.isDebit())
+    );
+  }
+
+  getCreditTransactions(): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.isCredit())
+    );
+  }
+
+  getByAllocations(allocations: TransactionAllocationCollection): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => allocations.hasTransaction(transaction))
+    );
+  }
+
+  getByInvoices(invoices: SoleInvoiceCollection): this {
+    return this.filterBy('invoiceItem.id', invoices.getInvoiceItemsIds());
+  }
+
+  getAmountPerInvoice(): Dictionary<number> {
+    // @TODO invoiceItem.invoice will be removed on backend
+    const transactionsByInvoice = this.groupBy('invoiceItem.invoice.id');
+    const dictionary: Dictionary<number> = new Dictionary([]);
+
+    transactionsByInvoice.keys.forEach((key) => {
+      dictionary.add(key, transactionsByInvoice.get(key).grossAmount);
+    });
+
+    return dictionary;
+  }
+
+  /**
+   * Get transactions related to Vehicle category
+   */
+  getVehicleTransactions(): this {
+    return this.create(
+      this.items.filter((transaction: Transaction): boolean => transaction.isVehicleTransaction())
+    );
+  }
+
+  /**
+   * Get new transaction collection filtered by tank type
+   */
+  getByTankType(tankType: TankTypeEnum): this {
+    return this.filterBy('tankType', tankType);
+  }
+
+  getExportHeader(): string[] {
+    return ['Date', 'Description', 'Debit', 'Credit'];
+  }
+
+  getExportFooter(): ExportCell[] {
+    return [
+      plainToClass(ExportCell, { value: 'Total', type: ExportCellTypeEnum.STRING }),
+      plainToClass(ExportCell, { value: '', type: ExportCellTypeEnum.STRING }),
+      plainToClass(ExportCell, { value: this.sumBy('debit'), type: ExportCellTypeEnum.CURRENCY }),
+      plainToClass(ExportCell, { value: this.sumBy('credit'), type: ExportCellTypeEnum.CURRENCY })
+    ];
+  }
+
+  getExportBody(): ExportCell[][] {
+    /**
+     * Description is not a required field for transactions.
+     * if there is no description, then add an empty line so that there are no errors when translated into a string.
+     */
+    return this.items.map((transaction: Transaction) => [
+      plainToClass(ExportCell, { value: transaction.date, type: ExportCellTypeEnum.DATE }),
+      plainToClass(ExportCell, { value: transaction.description ?? '-', type: ExportCellTypeEnum.STRING }),
+      plainToClass(ExportCell, { value: transaction.debit, type: ExportCellTypeEnum.CURRENCY }),
+      plainToClass(ExportCell, { value: transaction.credit, type: ExportCellTypeEnum.CURRENCY })
+    ]);
+  }
+
+  /**
+   * Get list of vehicle transactions filtered by vehicle claim
+   */
+  getByVehicleClaim(vehicleClaim?: VehicleClaim): this {
+    if (!vehicleClaim) {
+      return this.create([]);
+    }
+
+    return this.getVehicleTransactions()
+      .filterBy('tankType', vehicleClaim.tankType)
+      .filterBy('business.id', vehicleClaim.business?.id);
+  }
+
+  /**
+   * Get list of vehicle transactions except KMS transactions
+   */
+  getLogbookTransactions(): this {
+    return this
+      .getVehicleTransactions()
+      .removeBy('chartAccounts.id', [ChartAccountsListEnum.KMS_TRAVELLED, BusinessChartAccountsEnum.KMS_TRAVELLED]);
+  }
+
+  /**
+   * Build chart data with transactions cash position.
+   * Cash position = Income - Expenses (include depreciations)
+   * Chart data for each month from fin year start till current month
+   */
+  getCashPositionChartData(): ChartData[] {
+    const chartData: ChartData[] = [
+      plainToClass(ChartData, { name: 'Income', data: [] }),
+      plainToClass(ChartData, { name: 'Expense', data: [] })
+    ];
+
+    new FinancialYear().getPastMonths().forEach(month => {
+      chartData[0].data.push({
+        label: MONTHS[month],
+        value: this.getIncomeTransactions().getByMonth(month).claimAmount
+      });
+      chartData[1].data.push({
+        label: MONTHS[month],
+        value: Math.abs(this.getExpenseTransactions().getByMonth(month).claimAmount)
+      });
+    });
+
+    return chartData;
+  }
+
+  getAllocatedAmount(allocations: TransactionAllocationCollection): number {
+    return allocations.getByTransactionsIds(this.getIds()).sumBy('amount')
+  }
+
+  /**
+   * @TODO vik business transactions calculated differently, separated collection?
+   */
+  getBusinessClaimAmount(businessId: number = null): number {
+    const transactions = businessId ? this.filterBy('business.id', businessId) : this;
+    const expenses = transactions.getExpenseTransactions();
+    const incomes = transactions.getIncomeTransactions();
+
+    return incomes.sumBy('claimAmount') + expenses.sumBy('claimAmount');
+  }
+
+  getTaxable(): this {
+    return this.filter(transaction => transaction.claimPercent > 0);
+  }
+
+  filterByBudget(rules: BudgetRuleCollection): TransactionCollection {
+    const transactions = new TransactionCollection();
+    rules.items.forEach(rule => {
+      transactions.push(...this.filter(transaction => transaction.inBudget(rule)).items);
+    });
+
+    return transactions;
+  }
+}

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

@@ -0,0 +1,4 @@
+import { User } from '../../models';
+import { Collection } from '../collection';
+
+export class UserCollection extends Collection<User> {}

package/projects/tt-core/src/lib/collections/user-event-setting.collection.ts

@@ -0,0 +1,11 @@
+import { Collection } from './collection';
+import { UserEventSetting } from '../models/user-event/user-event-setting';
+
+/**
+ * Collection of user event settings
+ */
+export class UserEventSettingCollection extends Collection<UserEventSetting> {
+  getConfigurableBy(field: string): UserEventSettingCollection {
+    return new UserEventSettingCollection(this.items.filter((setting: UserEventSetting) => setting[field] !== null));
+  }
+}

package/projects/tt-core/src/lib/collections/user-event-type-collection.ts

@@ -0,0 +1,12 @@
+import { Collection } from './collection';
+import { UserEventType } from '../models/user-event/user-event-type';
+import { UserEventSettingCollection } from './user-event-setting.collection';
+
+/**
+ * Collection of user event settings
+ */
+export class UserEventTypeCollection extends Collection<UserEventType> {
+  toSettings(): UserEventSettingCollection {
+    return new UserEventSettingCollection(this.map((type) => type.toSetting()));
+  }
+}

package/projects/tt-core/src/lib/collections/vehicle/best-vehicle-logbook.collection.ts

@@ -0,0 +1,116 @@
+import { FinancialYear, VehicleLogbook } from '../../models';
+import { VehicleLogbookCollection } from './vehicle-logbook.collection';
+import { DateRange } from 'moment-range';
+
+/**
+ * Special logbook collection that contains logbooks from date period with the highest work usage percent
+ * Docs: https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/211517441/Logbook+Vehicle
+ */
+export class BestVehicleLogbookCollection extends VehicleLogbookCollection {
+  /**
+   * Logbook claimable period duration in milliseconds.
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/211517441/Logbook+Vehicle
+   */
+  static periodDuration = 12 * 7 * 24 * 3600 * 1000;
+
+  /**
+   * Date range with the biggest work usage percent
+   */
+  period: DateRange;
+
+  /**
+   * constructor is private because we want to prevent collection initialization via 'new' operator.
+   * We should create instances only with fromLogbooks method
+   */
+  private constructor(logbooks: VehicleLogbook[]) {
+    super(logbooks);
+  }
+
+  /**
+   * Best period may be calculated only when user has logbooks minimum for VehicleLogbook.bestPeriodWeeks
+   * and has at least one work/business trip
+   */
+  static isBestPeriodExist(logbooks: VehicleLogbookCollection): boolean {
+    if (logbooks.length < 2 || !logbooks.getClaimable().length) {
+      return false;
+    }
+
+    if (!(logbooks instanceof VehicleLogbookCollection)) {
+      logbooks = new VehicleLogbookCollection(logbooks);
+    }
+
+    return this.periodDuration < (logbooks.last.date.getTime() - logbooks.first.date.getTime());
+  }
+
+  // get list of date ranges for each of passed logbook
+  static getPeriods(logbooks: VehicleLogbookCollection): DateRange[] {
+    const claimable = logbooks.getClaimable();
+
+    if (!claimable.length) {
+      return [];
+    }
+
+    // get a list of date ranges that could potentially be the best
+    const periods: DateRange[] = claimable
+      // skip logbooks whose range ends after the last logbook
+      .filter((logbook: VehicleLogbook) => this.getPeriodByLogbook(logbook).end.toDate() < logbooks.last.date)
+      .map((logbook: VehicleLogbook) => this.getPeriodByLogbook(logbook));
+
+    const last = this.getPeriodByLogbook(claimable.last, true);
+    if (FinancialYear.toFinYear(last.start.toDate()) === FinancialYear.year) {
+      periods.push(last);
+    }
+
+    return periods;
+  }
+
+  /**
+   * Get claimable date range for passed logbook
+   * @param logbook logbook instance for range calculation
+   * @param isBackward Flag false - range for logbook + duration; flag true - range for logbook - duration. Used for extra case, when we should add an extra date range for the last logbook
+   */
+  static getPeriodByLogbook(logbook: VehicleLogbook, isBackward = false): DateRange {
+    if (isBackward) {
+      return new DateRange([new Date(logbook.date.getTime() - this.periodDuration), logbook.date]);
+    }
+
+    return new DateRange([logbook.date, new Date(logbook.date.getTime() + this.periodDuration)]);
+  }
+
+  /**
+   * Set Date Range with the biggest work usage percent
+   * Range duration is defined as BestVehicleLogbookCollection.periodDuration by the ATO
+   *
+   * Algorithm:
+   * Claimable logbooks or claimable trips - work/business logbook items.
+   * We should work with dates from the first to the last trip (include personal trips).
+   * Get date ranges starts on each claimable trip, all other ranges are definetily worst.
+   * Also get extra date range which ends with the last claimable trip.
+   * Get all trips included to each date range.
+   * Find and return range with the biggest workUsage percent.
+   */
+  private calculateBestPeriod(logbooks: VehicleLogbookCollection): void {
+    // get a list of date ranges that could potentially be the best
+    const periods: DateRange[] = BestVehicleLogbookCollection.getPeriods(logbooks);
+
+    periods.forEach((period: DateRange) => {
+      const logbooksInPeriod: VehicleLogbookCollection = logbooks.filterByRange('date', period.start.toDate(), period.end.toDate());
+
+      if (!this.period || (this.getWorkUsage() < logbooksInPeriod.getWorkUsage())) {
+        this.period = period;
+        this.items = logbooksInPeriod.toArray();
+      }
+    });
+  }
+
+  static fromLogbooks(logbooks: VehicleLogbookCollection): BestVehicleLogbookCollection | null {
+    if (!this.isBestPeriodExist(logbooks)) {
+      return null;
+    }
+
+    const collection = new BestVehicleLogbookCollection(logbooks.toArray());
+    collection.calculateBestPeriod(logbooks);
+
+    return collection;
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from './best-vehicle-logbook.collection';
+export * from './vehicle-claim.collection';
+export * from './vehicle-logbook.collection';

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

@@ -0,0 +1,30 @@
+import { Collection } from '../collection';
+import { VehicleClaim } from '../../models';
+
+export class VehicleClaimCollection extends Collection<VehicleClaim> {
+  /**
+   * Get remaining kilometers limit. Total limit ({@link VehicleClaim.totalKmsLimit}) - claimed kilometers from other vehicle claims
+   */
+  getKmsLimitForClaim(claim?: VehicleClaim): number {
+    let collection: VehicleClaimCollection = this;
+
+    if (claim) {
+      collection = collection.removeBy('id', claim.id);
+    }
+
+    return VehicleClaim.totalKmsLimit - collection.sumBy('kilometers');
+  }
+
+  /**
+   * Get remaining work usage limit. Total limit ({@link VehicleClaim.totalWorkUsagePercent}) - claimed percent from other vehicle claims
+   */
+  getWorkUsageLimitForClaim(claim?: VehicleClaim): number {
+    let collection: VehicleClaimCollection = this;
+
+    if (claim) {
+      collection = collection.removeBy('id', claim.id);
+    }
+
+    return VehicleClaim.totalWorkUsagePercent - collection.sumBy('workUsage');
+  }
+}

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

@@ -0,0 +1,51 @@
+import { Collection } from '../collection';
+import { VehicleClaim, VehicleLogbook } from '../../models';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import { BestVehicleLogbookCollection } from './best-vehicle-logbook.collection';
+
+/**
+ * this collection sorted by date desc, that's why first/last methods works different
+ */
+export class VehicleLogbookCollection extends Collection<VehicleLogbook> {
+  /**
+   * Calculate total kilometers traveled
+   */
+  get kilometers(): number {
+    return this.sumBy('kilometers');
+  }
+
+  getWorkUsage(vehicleClaim?: VehicleClaim): number {
+    return +(this.getClaimable(vehicleClaim).kilometers / this.kilometers * 100).toFixed(10);
+  }
+
+  getClaimable(vehicleClaim?: VehicleClaim): this {
+    if (!vehicleClaim) {
+      return this.filter((logbook: VehicleLogbook) => !logbook.isPersonal);
+    }
+
+    return vehicleClaim.isSoleTank()
+      // sole tank may have multiple vehicle claims, so we need to filter by business.id
+      ? this.filterBy('business.id', vehicleClaim.business.id)
+      // work tank may have only one vehicle claim, so we need to filter by tank type
+      : this.filterBy('tankType', TankTypeEnum.WORK);
+  }
+
+  /**
+   * get collection of logbooks with the biggest work usage for {@link BestVehicleLogbookCollection.periodDuration}
+   */
+  getBest(): BestVehicleLogbookCollection | null {
+    return BestVehicleLogbookCollection.fromLogbooks(this);
+  }
+
+  get first(): VehicleLogbook {
+    return super.last;
+  }
+
+  get last(): VehicleLogbook {
+    return super.first;
+  }
+
+  get preLast(): VehicleLogbook {
+    return this.items[1];
+  }
+}

package/projects/tt-core/src/lib/core.module.ts

@@ -0,0 +1,15 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { InterceptorsModule } from './interceptors/interceptors.module';
+
+/**
+ * https://angular.io/guide/creating-libraries
+ */
+@NgModule({
+  declarations: [],
+  imports: [
+    CommonModule,
+    InterceptorsModule
+  ]
+})
+export class CoreModule {}

package/projects/tt-core/src/lib/db/Enums/address-type.enum.ts

@@ -0,0 +1,4 @@
+export enum AddressTypeEnum {
+	STREET = 1,
+	POSTAL = 2,
+}

package/projects/tt-core/src/lib/db/Enums/annual-frequency.enum.ts

@@ -0,0 +1,7 @@
+export enum AnnualFrequencyEnum {
+  ANNUAL = 1,
+  QUARTERLY = 3,
+  MONTHLY = 12,
+  FORTNIGHTLY = 26,
+  WEEKLY = 52,
+}

package/projects/tt-core/src/lib/db/Enums/bank/allocation-rule/allocation-rule-condition-comparison-operator.enum.ts

@@ -0,0 +1,7 @@
+export enum AllocationRuleConditionComparisonOperatorEnum {
+	EQUALS = 1,
+	CONTAINS = 2,
+	STARTS = 3,
+	EQUALS_OR_GREATER = 4,
+	EQUALS_OR_LESS = 5,
+}

package/projects/tt-core/src/lib/db/Enums/bank/allocation-rule/allocation-rule-condition-field.enum.ts

@@ -0,0 +1,4 @@
+export enum AllocationRuleConditionFieldEnum {
+	AMOUNT = 1,
+	DESCRIPTION = 2,
+}

package/projects/tt-core/src/lib/db/Enums/bank/allocation-rule/allocation-rule-condition-operator.enum.ts

@@ -0,0 +1,4 @@
+export enum AllocationRuleConditionOperatorEnum {
+	AND = 1,
+	OR = 2,
+}

package/projects/tt-core/src/lib/db/Enums/bank/allocation-rule/allocation-rule-type.enum.ts

@@ -0,0 +1,5 @@
+export enum AllocationRuleTypeEnum {
+	EXPENSE = 1,
+	INCOME = 2,
+	TRANSFER = 3,
+}

package/projects/tt-core/src/lib/db/Enums/bank/allocation-rule/index.ts

@@ -0,0 +1,4 @@
+export * from './allocation-rule-condition-comparison-operator.enum';
+export * from './allocation-rule-condition-field.enum';
+export * from './allocation-rule-condition-operator.enum';
+export * from './allocation-rule-type.enum';

package/projects/tt-core/src/lib/db/Enums/bank/bank-account-status.enum.ts

@@ -0,0 +1,7 @@
+export enum BankAccountStatusEnum {
+	INACTIVE = 0,
+	ACTIVE = 1,
+  DISCONNECTED = 2,
+  // manual moved to basiq, but saved as backup
+  REPLACED = 3
+}

package/projects/tt-core/src/lib/db/Enums/bank/bank-account-type.enum.ts

@@ -0,0 +1,11 @@
+export enum BankAccountTypeEnum {
+  TRANSACTION = 1,
+  SAVINGS = 2,
+  CREDIT_CARD = 3,
+  // @TODO Alex: should be removed by backend (TT-2107)
+  MORTGAGE = 4,
+  LOAN = 5,
+  INVESTMENT = 6,
+  TERM_DEPOSIT = 7,
+  OFFSET = 10,
+}

package/projects/tt-core/src/lib/db/Enums/bank/bank-connection-status.enum.ts

@@ -0,0 +1,6 @@
+export enum BankConnectionStatusEnum {
+	PENDING = 1,
+	ACTIVE = 2,
+  INVALID = 3,
+  RECONNECTING = 4,
+}

package/projects/tt-core/src/lib/db/Enums/bank/bank-popular.enum.ts

@@ -0,0 +1,12 @@
+export enum BankPopularEnum {
+  BANKWEST = 'Bank of Western Australia trading as BankWest',
+  ANZ = 'Australia and New Zealand Banking Group Limited',
+  CBA = 'Commonwealth Bank Australia',
+  WESTPAC = 'Westpac Banking Corporation',
+  BENDIGO = 'Bendigo and Adelaide Bank Limited',
+  ING_DIRECT = 'ING Bank (Australia) Limited (trading as ING Direct)',
+  ST_GEORGE = 'St. George Bank (a subsidiary of Westpac)',
+  SUNCORP = 'Suncorp-Metway Limited',
+  CITIBANK = 'Citibank',
+  BOQ = 'Bank of Queensland Limited',
+}

package/projects/tt-core/src/lib/db/Enums/bank/bank-provider.enum.ts

@@ -0,0 +1,5 @@
+export enum BankProviderEnum {
+	MANUAL = 0,
+	WEB_SCRAPPER = 1,
+	OPEN_BANKING = 2,
+}