taxtank 0.1.0

package/projects/tt-core/src/lib/forms/budget/budget-rule.form.ts

@@ -0,0 +1,56 @@
+import { FormControl, Validators } from '@angular/forms';
+import { BudgetRule } from '../../models';
+import { AbstractForm } from '../abstract.form';
+import { RxwebValidators } from '@rxweb/reactive-form-validators';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import { conditionalValidator } from '../../validators';
+import { IEventListener } from '../../interfaces';
+
+export class BudgetRuleForm extends AbstractForm<BudgetRule> implements IEventListener {
+  constructor(rule: BudgetRule) {
+    super({
+      tankType: new FormControl(rule.chartAccounts?.tankType ?? TankTypeEnum.PERSONAL, [Validators.required]),
+      chartAccounts: new FormControl({ value: rule.chartAccounts, disabled: !!rule.chartAccounts?.category }, [Validators.required, RxwebValidators.unique()]),
+      amount: new FormControl(rule.amount, Validators.required),
+      startDate: new FormControl(rule.startDate, Validators.required),
+      endDate: new FormControl({ value: rule.endDate, disabled: !rule.frequency }),
+      inCalendar: new FormControl(rule.inCalendar),
+      frequency: new FormControl(rule.frequency),
+      description: new FormControl(rule.description),
+      bankAccount: new FormControl(rule.bankAccount, conditionalValidator(
+        (): boolean => !!this.value.inCalendar,
+        Validators.required
+      )),
+      property: new FormControl(rule.property, conditionalValidator(
+        (): boolean => this.value.tankType === TankTypeEnum.PROPERTY,
+        Validators.required
+      )),
+      business: new FormControl(rule.business, conditionalValidator(
+        (): boolean => this.value.tankType === TankTypeEnum.SOLE,
+        Validators.required
+      )),
+      incomeSource: new FormControl(rule.incomeSource, conditionalValidator(
+        (): boolean => this.value.chartAccounts?.isWorkIncome(),
+        Validators.required
+      )),
+    }, rule);
+
+    this.listenEvents();
+  }
+
+
+  listenEvents(): void {
+    this.listenFrequency();
+  }
+
+  listenFrequency(): void {
+    this.get('frequency').valueChanges.subscribe((value: number) => {
+      if (value) {
+        this.get('endDate').enable();
+      } else {
+        this.get('endDate').disable();
+      }
+    })
+  }
+}
+

package/projects/tt-core/src/lib/forms/budget/budget.form.ts

@@ -0,0 +1,94 @@
+import { UntypedFormArray, UntypedFormControl, UntypedFormGroup, Validators } from '@angular/forms';
+import { Budget, BudgetRule, ChartAccounts } from '../../models';
+import { AbstractForm } from '../abstract.form';
+import { plainToClass } from 'class-transformer';
+import { ChartAccountsCategoryEnum } from '../../db/Enums';
+import { RxwebValidators } from '@rxweb/reactive-form-validators';
+import { combineLatest } from 'rxjs';
+import { startWith } from 'rxjs/operators';
+import { Collection } from '../../collections';
+
+/**
+ * @TODO TT-4522 remove after release
+ */
+export class BudgetForm extends AbstractForm<Budget> {
+  // @TODO uncomment when all properties exposed
+  // protected excludeExtraneousValues = true;
+  filteredRules: Map<number, UntypedFormGroup>;
+  total: number;
+
+  constructor(budget: Budget) {
+    super({
+      category: new UntypedFormControl(),
+      searchQuery: new UntypedFormControl(''),
+      rules: new UntypedFormArray((budget.rules || [plainToClass(BudgetRule, {})]).map(
+        (budgetRule: BudgetRule) => BudgetForm.createRuleFormGroup(budgetRule))
+      ),
+    }, budget);
+
+    combineLatest([
+      this.get('category').valueChanges.pipe(startWith(null)),
+      this.get('searchQuery').valueChanges.pipe(startWith(null))
+    ]).subscribe(() => this.filterRules());
+
+    this.total = budget.rulesCollection.sumBy('amount');
+    this.get('rules').valueChanges.subscribe((rules) => {
+      this.total = new Collection(rules).sumBy('amount');
+    });
+  }
+
+  get rulesArray(): UntypedFormArray {
+    return this.get('rules') as UntypedFormArray;
+  }
+
+  filterRules(): void {
+    const category: ChartAccountsCategoryEnum = this.get('category').value;
+    const searchQuery: string = this.get('searchQuery').value;
+    let filteredRules: UntypedFormGroup[] = this.rulesArray.controls as UntypedFormGroup[];
+
+    if (searchQuery) {
+      filteredRules = filteredRules.filter((ruleGroup: UntypedFormGroup) => {
+        if (ruleGroup.invalid) {
+          return true;
+        }
+
+        const ruleAmount: string = ruleGroup.get('amount').value?.toString();
+        const chartAccountsName: string = ruleGroup.get('chartAccounts').value?.name.toLowerCase();
+
+        return chartAccountsName.includes(searchQuery) || ruleAmount.includes(searchQuery);
+      });
+    }
+
+    if (category) {
+      filteredRules = filteredRules.filter((ruleGroup: UntypedFormGroup) => {
+        const chartAccounts: ChartAccounts = ruleGroup.get('chartAccounts').value;
+
+        if (!chartAccounts) {
+          return true;
+        }
+
+        return chartAccounts.category === category;
+      });
+    }
+
+    this.filteredRules = new Map(filteredRules.map((rule) => [this.rulesArray.controls.indexOf(rule), rule]));
+  }
+
+  static createRuleFormGroup(budgetRule: BudgetRule): UntypedFormGroup {
+    return new UntypedFormGroup({
+      chartAccounts: new UntypedFormControl(budgetRule.chartAccounts, [Validators.required, RxwebValidators.unique()]),
+      amount: new UntypedFormControl(budgetRule.amount, Validators.required)
+    });
+  }
+
+  addRule(budgetRule: BudgetRule = plainToClass(BudgetRule, {})): void {
+    const rule = BudgetForm.createRuleFormGroup(budgetRule);
+    this.rulesArray.push(rule);
+    this.filteredRules.set(this.rulesArray.controls.indexOf(rule), rule);
+  }
+
+  deleteRule(index: number): void {
+    this.rulesArray.removeAt(index);
+    this.filteredRules.delete(index);
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './budget.form';
+export * from './budget-rule.form';

package/projects/tt-core/src/lib/forms/chart-accounts/chart-accounts.form.ts

@@ -0,0 +1,26 @@
+import { AbstractForm } from '../abstract.form';
+import { FormArray, FormControl, FormGroup, Validators } from '@angular/forms';
+import { ChartAccounts } from '../../models';
+import { plainToClass } from 'class-transformer';
+
+export class ChartAccountsForm extends AbstractForm<ChartAccounts> {
+  constructor(private chartAccounts: ChartAccounts = plainToClass(ChartAccounts, {})) {
+    super({
+      name: new FormControl(chartAccounts.name, [Validators.required, Validators.maxLength(AbstractForm.inputMaxLength)]),
+      category: new FormControl(chartAccounts.category, [Validators.required]),
+      depreciations: new FormArray(
+        (chartAccounts.depreciations || []).map((depreciation) => new FormGroup({
+          effectiveLife: new FormControl(depreciation.effectiveLife),
+        }))
+      )
+    }, chartAccounts);
+  }
+
+  get depreciationsArray(): FormArray {
+    return this.get('depreciations') as FormArray;
+  }
+
+  addDepreciationGroup(): void {
+    this.depreciationsArray.push(new FormGroup({ effectiveLife: new FormControl() }));
+  }
+}

package/projects/tt-core/src/lib/forms/chart-accounts/index.ts

@@ -0,0 +1 @@
+export * from './chart-accounts.form';

package/projects/tt-core/src/lib/forms/chat/chat-filter.form.ts

@@ -0,0 +1,50 @@
+import { FormControl, FormGroup } from '@angular/forms';
+import { ControlsInterface } from '../abstract.form';
+import { ChatCollection } from '../../collections';
+import { IEventListener } from '../../interfaces';
+import { debounceTime, distinctUntilChanged } from 'rxjs/operators';
+import { ReplaySubject } from 'rxjs';
+import { Chat } from '../../models';
+
+interface IChatFilterControls extends ControlsInterface {
+  query: FormControl<string>;
+  myChats: FormControl<boolean>;
+}
+
+export class ChatFilterForm extends FormGroup<IChatFilterControls> implements IEventListener {
+  dataChanges: ReplaySubject<Chat[]> = new ReplaySubject(1);
+
+  constructor(private collection: ChatCollection) {
+    super({
+      query: new FormControl(),
+      myChats: new FormControl(true),
+    });
+
+    this.listenEvents();
+    this.updateValueAndValidity();
+  }
+
+  listenEvents() {
+    this.valueChanges.pipe(debounceTime(300), distinctUntilChanged())
+      .subscribe(() => {
+        this.filter();
+      });
+  }
+
+  filter(source?: ChatCollection): void {
+    if (source) {
+      this.collection = source;
+    }
+    const value = this.value;
+
+    let collection = this.collection;
+    if (value.query) {
+      collection = collection.filter(chat => chat.client.fullName.toLowerCase().includes(value.query));
+    }
+    if (value.myChats) {
+      collection = collection.filter(chat => chat.employee.id === +localStorage.getItem('userId'));
+    }
+
+    this.dataChanges.next(collection.toArray());
+  }
+}

package/projects/tt-core/src/lib/forms/chat/index.ts

@@ -0,0 +1 @@
+export * from './chat-filter.form';

package/projects/tt-core/src/lib/forms/client/annual-client-details.form.ts

@@ -0,0 +1,48 @@
+import { AbstractForm } from '../abstract.form';
+import { UntypedFormControl, Validators } from '@angular/forms';
+import { AnnualClientDetails } from '../../models';
+import { plainToClass } from 'class-transformer';
+import { conditionalValidator } from '../../validators';
+
+export class AnnualClientDetailsForm extends AbstractForm<AnnualClientDetails> {
+  constructor(private annualClientDetails: AnnualClientDetails = plainToClass(AnnualClientDetails, {})) {
+    super({
+      privateHealthCare: new UntypedFormControl(annualClientDetails.privateHealthCare, Validators.required),
+      spouse: new UntypedFormControl(annualClientDetails.spouse, Validators.required),
+      spouseAnnualIncome: new UntypedFormControl(annualClientDetails.spouseAnnualIncome, conditionalValidator(
+        (): boolean => this.get('spouse').value,
+        Validators.required
+      )),
+      hasDependants: new UntypedFormControl(!!annualClientDetails.dependants, Validators.required),
+      dependants: new UntypedFormControl(annualClientDetails.dependants, conditionalValidator(
+        (): boolean => this.get('hasDependants').value,
+        Validators.required
+      )),
+      hasStudentLoan: new UntypedFormControl(!!annualClientDetails.studentLoanAmount, Validators.required),
+      studentLoanAmount: new UntypedFormControl(annualClientDetails.studentLoanAmount, conditionalValidator(
+        (): boolean => this.get('hasStudentLoan').value,
+        Validators.required
+      )),
+      reportableFringeBenefits: new UntypedFormControl(annualClientDetails.reportableFringeBenefits || 0),
+      exemptForeignEmploymentIncome: new UntypedFormControl(annualClientDetails.exemptForeignEmploymentIncome || 0),
+    }, annualClientDetails);
+
+    this.watchFieldForToggle('spouse', 'spouseAnnualIncome');
+    this.watchFieldForToggle('hasDependants', 'dependants');
+    this.watchFieldForToggle('hasStudentLoan', 'studentLoanAmount');
+    this.emitValues();
+  }
+
+  private watchFieldForToggle(field: string, dependantField: string): void {
+    this.get(field).valueChanges.subscribe((value: boolean) => this.toggleField(dependantField, !!value))
+  }
+
+  private toggleField(field: string, enable: boolean): void {
+    if (enable) {
+      this.get(field).enable();
+    } else {
+      this.get(field).setValue(0);
+      this.get(field).disable();
+    }
+  }
+}

package/projects/tt-core/src/lib/forms/client/capital-loss.form.ts

@@ -0,0 +1,12 @@
+import { AbstractForm } from '../abstract.form';
+import { UntypedFormControl, Validators } from '@angular/forms';
+import { CapitalLoss } from '../../models';
+import { plainToClass } from 'class-transformer';
+
+export class CapitalLossForm extends AbstractForm<CapitalLoss> {
+  constructor(private capitalLoss: CapitalLoss = plainToClass(CapitalLoss, {})) {
+    super({
+      balance: new UntypedFormControl(capitalLoss.balance, Validators.required)
+    }, capitalLoss);
+  }
+}

package/projects/tt-core/src/lib/forms/client/index.ts

@@ -0,0 +1,2 @@
+export * from './annual-client-details.form';
+export * from './capital-loss.form';

package/projects/tt-core/src/lib/forms/collection.form.ts

@@ -0,0 +1,37 @@
+import { FormArray } from '@angular/forms';
+import { AbstractForm } from './';
+import { AbstractModel } from '../db/Models';
+
+export class CollectionForm<Form extends AbstractForm<Model>, Model extends AbstractModel> extends FormArray<Form> {
+  private args: any[];
+  includeDisabledFields = false;
+
+  constructor(private formConstructor: new (model?: Model, ...args: any[]) => Form, models: Model[] = [], ...args: any[]) {
+    super(models.map(model => new formConstructor(model, ...args)));
+    this.args = args;
+    if (!models.length) {
+      this.add();
+    }
+  }
+
+  createFormGroup(model?: Model): Form {
+    return new this.formConstructor(model, ...this.args);
+  }
+
+  add(model?: Model): void {
+    super.push(this.createFormGroup(model));
+  }
+
+  /**
+   * Submit form and return array of properties from form value
+   */
+  submit(data: object = {}): Model[] {
+    this.markAllAsTouched();
+    const controls = this.includeDisabledFields ? this.controls : this.controls.filter((form: Form) => form.enabled);
+    if (!this.valid || !controls.length) {
+      return null;
+    }
+
+    return controls.map((form: Form): Model => form.submit(data));
+  }
+}

package/projects/tt-core/src/lib/forms/depreciation/depreciation.form.ts

@@ -0,0 +1,50 @@
+import { FormControl, Validators } from '@angular/forms';
+import { TransactionBaseForm } from '../transaction';
+import { ChartAccounts, Depreciation, FinancialYear } from '../../models';
+
+export class DepreciationForm extends TransactionBaseForm<Depreciation> {
+  includeDisabledFields = true;
+
+  constructor(depreciation: Depreciation, registeredForGst: boolean) {
+    super(depreciation, registeredForGst, {
+      isCloseBalanceCorrect: new FormControl(true),
+      closeBalance: new FormControl({ value: depreciation.closeBalance || 0, disabled: true }, Validators.required),
+      financialYear: new FormControl(depreciation.financialYear || new FinancialYear().year),
+      claimStartDate: new FormControl({ value: depreciation.claimStartDate, disabled: !depreciation.chartAccounts?.isBuildingAtCost() }),
+    });
+
+    if (depreciation.id) {
+      // this.get('claimPercent').setValue(depreciation.currentYearForecast.claimPercent);
+    }
+
+    // forbid to change chartAccounts/claimPercent for existing depreciations
+    if (depreciation.id) {
+      this.get('chartAccounts').disable({ emitEvent: false });
+      this.get('claimPercent').disable({ emitEvent: false });
+    }
+
+    // @TODO should be watched?
+    // if depreciation has 'depreciationCapitalProject' value - set value and disable 'date' form control
+    if (depreciation.depreciationCapitalProject) {
+      this.get('date').setValue(depreciation.depreciationCapitalProject.effectiveDate);
+      this.get('date').disable();
+    } else {
+      this.get('date').setValue(depreciation.date);
+    }
+
+    this.get('isCloseBalanceCorrect').valueChanges.subscribe((isSelected: boolean) => {
+      if (isSelected) {
+        this.get('closeBalance').disable();
+      } else {
+        this.get('closeBalance').enable();
+      }
+    });
+  }
+
+  watchChartAccounts(): void {
+    super.watchChartAccounts();
+    this.get('chartAccounts').valueChanges.subscribe((chartAccounts: ChartAccounts) => {
+      this.setEnabledState(this.get('claimStartDate'), chartAccounts.isBuildingAtCost());
+    });
+  }
+}

package/projects/tt-core/src/lib/forms/depreciation/index.ts

@@ -0,0 +1 @@
+export * from './depreciation.form';

package/projects/tt-core/src/lib/forms/document-folder/document-folder.form.ts

@@ -0,0 +1,13 @@
+import { FormControl, Validators } from '@angular/forms';
+import { DocumentFolder } from '../../models';
+import { AbstractForm } from '../abstract.form';
+import { FormValidationsEnum } from '../form-validations.enum';
+
+export class DocumentFolderForm extends AbstractForm<DocumentFolder> {
+  constructor(folder: DocumentFolder) {
+    super({
+      name: new FormControl(folder.name, [Validators.required, Validators.maxLength(FormValidationsEnum.INPUT_MAX_LENGTH)]),
+      parent: new FormControl(folder.parent),
+    }, folder);
+  }
+}

package/projects/tt-core/src/lib/forms/document-folder/document.form.ts

@@ -0,0 +1,12 @@
+import { FormControl, Validators } from '@angular/forms';
+import { AbstractForm } from '../abstract.form';
+import { Document } from '../../models';
+
+export class DocumentForm extends AbstractForm<Document> {
+  constructor(document: Document) {
+    super({
+      folder: new FormControl(document.folder, Validators.required),
+      file: new FormControl(document.file, Validators.required),
+    }, document)
+  }
+}

package/projects/tt-core/src/lib/forms/document-folder/index.ts

@@ -0,0 +1,2 @@
+export * from './document-folder.form';
+export * from './document.form';

package/projects/tt-core/src/lib/forms/financial-goal/financial-goal-filter.form.ts

@@ -0,0 +1,57 @@
+import { FormControl } from '@angular/forms';
+import { AbstractForm, ControlsInterface } from '../abstract.form';
+import { BankAccount, FinancialGoal, Property } from '../../models';
+import { FinancialGoalCollection } from '../../collections';
+import differenceBy from 'lodash/differenceBy';
+
+interface FinancialGoalFilterControlsInterface extends ControlsInterface {
+  type: FormControl<number>,
+  bankAccount: FormControl<BankAccount>,
+  properties: FormControl<Property[]>,
+  inactiveHidden: FormControl<boolean>,
+}
+
+export class FinancialGoalFilterForm extends AbstractForm<FinancialGoal, FinancialGoalFilterControlsInterface> {
+  filteredGoals: FinancialGoalCollection;
+
+  constructor(private goals: FinancialGoalCollection) {
+    super({
+      inactiveHidden: new FormControl(true),
+      type: new FormControl(),
+      properties: new FormControl(),
+      bankAccount: new FormControl(),
+    });
+
+    this.filter(this.goals);
+    this.valueChanges.subscribe(() => {
+      this.filter(this.goals);
+    });
+  }
+
+  filter(goals: FinancialGoalCollection): FinancialGoalCollection {
+    this.filteredGoals = goals;
+    if (!goals.length) {
+      return goals;
+    }
+
+    const value = this.value;
+
+    if (value.inactiveHidden) {
+      this.filteredGoals = this.filteredGoals.getActive();
+    }
+
+    if (value.type) {
+      this.filteredGoals = this.filteredGoals.filterBy('type', value.type);
+    }
+
+    if (value.properties) {
+      this.filteredGoals = this.filteredGoals.filter(goal => differenceBy(value.properties, goal.properties, 'id').length === 0);
+    }
+
+    if (value.bankAccount) {
+      this.filteredGoals = this.filteredGoals.filter(goal => goal.bankAccount?.id === value.bankAccount.id);
+    }
+
+    return this.filteredGoals;
+  }
+}

package/projects/tt-core/src/lib/forms/financial-goal/financial-goal.form.ts

@@ -0,0 +1,167 @@
+import { AbstractForm } from '../index';
+import { Dictionary, FinancialGoal, FinancialGoalTypeEnum } from '../../models';
+import { FormControl, Validators } from '@angular/forms';
+import { BankAccount } from '../../db/Models';
+import { IEventListener } from '../../interfaces';
+import { conditionalValidator, greaterThanControlValidator, minDateValidator } from '../../validators';
+import moment from 'moment';
+import { BankAccountTypeEnum, DailyFrequencyEnum } from '../../db/Enums';
+import round from 'lodash/round';
+import { filter } from 'rxjs/operators';
+import { lessThanControlValidator } from '../../validators/less-than-control.validator';
+
+const END_DATE_VALIDATION_ERROR = 'Target date must be more than start date';
+
+export class FinancialGoalForm extends AbstractForm<FinancialGoal> implements IEventListener {
+  includeDisabledFields = true;
+  bankAccountTypes: BankAccountTypeEnum[] = [];
+
+  constructor(goal: FinancialGoal, private equityByProperty?: Dictionary<number>, private lvrByProperty?: Dictionary<number>) {
+    super({
+      type: new FormControl({ value: goal.type ?? FinancialGoalTypeEnum.DEBIT, disabled: !!goal.id }, Validators.required),
+      name: new FormControl(goal.name, Validators.required),
+      bankAccount: new FormControl({ value: goal.bankAccount, disabled: !!goal.id }, [
+        conditionalValidator((): boolean => !this.isPropertyType(), Validators.required),
+      ]),
+      targetValue: new FormControl(goal.targetValue, [
+        Validators.required,
+        conditionalValidator((): boolean => this.isLvrType(), lessThanControlValidator('initialValue', 'Start Value')),
+        conditionalValidator((): boolean => !this.isLvrType(), greaterThanControlValidator('initialValue', 'Start Value')),
+      ]),
+      initialValue: new FormControl({ value: goal.initialValue, disabled: true }, Validators.required),
+      startDate: new FormControl({ value: goal.startDate, disabled: true }),
+      endDate: new FormControl(goal.endDate, [Validators.required, minDateValidator(goal.startDate, END_DATE_VALIDATION_ERROR)]),
+      paymentFrequency: new FormControl(goal.paymentFrequency, [
+        conditionalValidator((): boolean => !this.isPropertyType(), Validators.required),
+      ]),
+      paymentAmount: new FormControl(goal.paymentAmount, [
+        conditionalValidator((): boolean => !this.isPropertyType(), Validators.required),
+      ]),
+      inCalendar: new FormControl(goal.inCalendar),
+      file: new FormControl(goal.file),
+      description: new FormControl(goal.description),
+      properties: new FormControl({ value: goal.properties, disabled: !!goal.id }, [
+        conditionalValidator((): boolean => this.isPropertyType(), Validators.required),
+      ]),
+    }, goal);
+
+    this.bankAccountTypes = this.getBankAccountTypes(goal.type);
+    this.listenEvents();
+  }
+
+  listenEvents(): void {
+    this.listenTypeChanges();
+    this.listenBankAccountChanges();
+    this.listenPaymentChanges();
+  }
+
+  listenTypeChanges(): void {
+    this.get('type').valueChanges.subscribe((type: FinancialGoalTypeEnum) => {
+      this.get('bankAccount').setValue(null, { onlySelf: true });
+      this.get('properties').setValue([], { onlySelf: true, emitEvent: false });
+      this.get('initialValue').setValue(null, { onlySelf: true, emitEvent: false });
+
+      if (this.isPropertyType()) {
+        this.get('inCalendar').setValue(false, { onlySelf: true, emitEvent: false });
+        this.get('paymentFrequency').setValue(null, { onlySelf: true, emitEvent: false });
+        this.get('paymentAmount').setValue(null, { onlySelf: true, emitEvent: false });
+      }
+
+      this.bankAccountTypes = this.getBankAccountTypes(type);
+    });
+  }
+
+  /**
+   * Watch payment fields and auto-recalculate endDate when form is valid
+   */
+  listenPaymentChanges(): void {
+    this.valueChanges.subscribe(() => {
+      const goal = this.getRawValue();
+
+      if (goal.targetValue === null || !goal.bankAccount || !goal.paymentFrequency || !goal.endDate
+        || (this.get('paymentAmount').dirty && this.get('endDate').dirty)) {
+        return;
+      }
+
+      this.get('paymentAmount').setValue(this.calculatePaymentAmount(), { emitEvent: false });
+    });
+
+    this.get('paymentAmount').valueChanges.subscribe(() => {
+      const goal = this.getRawValue();
+      if (goal.targetValue === null || !goal.bankAccount || !goal.paymentFrequency || !goal.paymentAmount) {
+        return;
+      }
+
+      this.get('endDate').setValue(this.calculateEndDate(), { emitEvent: false });
+    });
+  }
+
+  listenBankAccountChanges(): void {
+    this.get('bankAccount').valueChanges
+      .pipe(filter((bankAccount: BankAccount | null) => !!bankAccount))
+      .subscribe(bankAccount => {
+        this.get('initialValue').setValue(bankAccount.currentBalance);
+      });
+  }
+
+  /**
+   * requires targetValue/initialValue/paymentAmount/paymentFrequency fields to be filled
+   * Derives the final goal completion date by adding all payment periods to the start date.
+   */
+  calculateEndDate(): Date {
+    const goal = this.getRawValue();
+    const start = moment(goal.startDate);
+    const paymentsCount = this.calculatePaymentsByAmount();
+
+    switch (goal.paymentFrequency) {
+      case DailyFrequencyEnum.WEEKLY:
+        return start.add(paymentsCount, 'weeks').toDate();
+
+      case DailyFrequencyEnum.FORTNIGHTLY:
+        return start.add(paymentsCount * 2, 'weeks').toDate();
+
+      case DailyFrequencyEnum.MONTHLY:
+        return start.add(paymentsCount, 'month').toDate();
+
+      default:
+        return new Date();
+    }
+  }
+
+  /**
+   * Computes the recurring payment amount required to hit the target by the chosen end date.
+   */
+  calculatePaymentAmount(): number {
+    const goal = this.currentValue;
+
+    return round(goal.target / Math.max(1, goal.calculatePaymentsByDate(goal.endDate)), 2);
+  }
+
+  /**
+   * Returns total number of deposits needed to fully reach the goal at current paymentAmount.
+   */
+  calculatePaymentsByAmount(): number {
+    const goal = this.currentValue;
+
+    return Math.round(goal.target / goal.paymentAmount);
+  }
+
+  getBankAccountTypes(type: FinancialGoalTypeEnum): BankAccountTypeEnum[] {
+    switch (type) {
+      case FinancialGoalTypeEnum.CREDIT:
+        return [BankAccountTypeEnum.MORTGAGE, BankAccountTypeEnum.LOAN, BankAccountTypeEnum.CREDIT_CARD];
+      case FinancialGoalTypeEnum.DEBIT:
+        return [BankAccountTypeEnum.TRANSACTION, BankAccountTypeEnum.SAVINGS, BankAccountTypeEnum.OFFSET];
+      default:
+        return [];
+    }
+  }
+
+  isPropertyType(): boolean {
+    return [FinancialGoalTypeEnum.PROPERTY_EQUITY, FinancialGoalTypeEnum.PROPERTY_LVR].includes(this.getRawValue().type);
+  }
+
+  isLvrType(): boolean {
+    return this.getRawValue().type === FinancialGoalTypeEnum.PROPERTY_LVR;
+  }
+}

package/projects/tt-core/src/lib/forms/financial-goal/index.ts

@@ -0,0 +1,2 @@
+export * from './financial-goal.form';
+export * from './financial-goal-filter.form';