taxtank 0.1.0

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

@@ -0,0 +1,228 @@
+import { AbstractForm } from '../abstract.form';
+import { Address, CorelogicSuggestion, Country } from '../../models';
+import { UntypedFormControl, Validators } from '@angular/forms';
+import { EventEmitter } from '@angular/core';
+import { IEventListener } from '../../interfaces';
+import { debounceTime, distinctUntilChanged, filter, map } from 'rxjs/operators';
+import { AddressTypeEnum } from '../../db/Enums/address-type.enum';
+import { merge } from 'rxjs';
+import { RxwebValidators } from '@rxweb/reactive-form-validators';
+
+/**
+ * Address form. Works with corelogic or manual address
+ */
+export class AddressForm extends AbstractForm<Address> implements IEventListener {
+  /**
+   * Min search query required length
+   */
+  static minSearchLength = 3;
+
+  /**
+   * Delay before corelogic request
+   */
+  static searchDelay = 500;
+
+  /**
+   * Regarding corelogic formatting, street number should not contain spaces
+   */
+  static streetNumberPattern = /^[^\s]+$/;
+
+  /**
+   * Manual mode flag
+   */
+  isManual: boolean;
+
+  /**
+   * Emit event to search address in corelogic when user filled enough data for corelogic
+   */
+  onSearch: EventEmitter<string> = new EventEmitter();
+
+  constructor(
+    // no default value because Address form is always a child form. That's mean address value always passed and then default value never work.
+    // even if null passed, default value will not work
+    address: Address | null
+  ) {
+    super({
+      // prefill search input with address string for edit case
+      searchQuery: new UntypedFormControl(address?.address ? address.nameLong : null, Validators.required),
+      type: new UntypedFormControl(address?.type || AddressTypeEnum.STREET, Validators.required),
+
+      // corelogic fields (required for Australia and disabled for other countries)
+      corelogicLocId: new UntypedFormControl({ value: address?.corelogicLocId, disabled: true }, Validators.required),
+      corelogicRefId: new UntypedFormControl({ value: address?.corelogicRefId, disabled: true }, [RxwebValidators.required({ message: 'The address is incomplete or incorrect. Please check and try again.' })]),
+
+      // manual fields (using when address not found in corelogic)
+      unitNumber: new UntypedFormControl({ value: address?.unitNumber, disabled: true }),
+      address: new UntypedFormControl({ value: address?.address, disabled: true }),
+      streetNumber: new UntypedFormControl({ value: address?.streetNumber, disabled: true }, [Validators.required, Validators.pattern(AddressForm.streetNumberPattern)]),
+      street: new UntypedFormControl({ value: address?.street, disabled: true }, Validators.required),
+      city: new UntypedFormControl({ value: address?.city, disabled: true }, Validators.required),
+      state: new UntypedFormControl({ value: address?.state, disabled: true }, Validators.required),
+      postcode: new UntypedFormControl({ value: address?.postcode, disabled: true }, Validators.required),
+      country: new UntypedFormControl({ value: address?.country || Country.australia, disabled: true }, Validators.required)
+    }, address);
+
+    if (this.isAustraliaSelected()) {
+      this.enableCorelogicFields();
+    }
+
+    this.listenEvents();
+  }
+
+  /**
+   * Get search query for corelogic location search based on manual fields values
+   */
+  get manualSearchQuery(): string {
+    // nothing to search when manual fields are invalid or when selected country is not Australia because we don't need to use corelogic for other countries
+    if (!this.isManualSearchAvailable() || !this.isAustraliaSelected()) {
+      return '';
+    }
+
+    // for manual mode we search corelogic for city (location) and ignore street
+    return `${this.get('city').value} ${this.get('state').value} ${this.get('postcode').value}`;
+  }
+
+  listenEvents(): void {
+    this.listenSearchQueryChanges();
+  }
+
+  /**
+   * Handle corelogic suggestion select
+   */
+  onSelectSuggestion(suggestion?: CorelogicSuggestion): void {
+    // if no suggestion then 'Add manually' option selected
+    if (!suggestion && !this.isManual) {
+      this.switchToManual();
+      return;
+    }
+
+    this.patchValue({
+      corelogicLocId: suggestion?.localityId ?? null,
+      corelogicRefId: suggestion?.propertyId ?? null
+    });
+  }
+
+  /**
+   * Check if Australia is selected in country field
+   */
+  isAustraliaSelected(): boolean {
+    return this.get('country').value?.id === Country.australia.id;
+  }
+
+  /**
+   * Enable manual mode
+   */
+  private switchToManual(): void {
+    this.isManual = true;
+    this.get('searchQuery').disable();
+
+    this.get('unitNumber').enable();
+    this.get('address').enable();
+    this.get('streetNumber').enable();
+    this.get('street').enable();
+    this.get('city').enable();
+    this.get('state').enable();
+    this.get('postcode').enable();
+    this.get('country').enable();
+    this.get('corelogicRefId').clearValidators();
+
+    this.listenManualFieldsChanges();
+    this.listenStreetFieldsChanges();
+    this.listenCountryChanges();
+  }
+
+  /**
+   * Emit event to search address in corelogic when search field changes
+   */
+  private listenSearchQueryChanges(): void {
+    this.get('searchQuery').valueChanges
+      .pipe(
+        // delay to avoid search request for each value change
+        debounceTime(AddressForm.searchDelay),
+        // skip when value not changed
+        distinctUntilChanged(),
+        // value could be a string when user search and suggestion when user select option from autocomplete
+        map((value: string | CorelogicSuggestion) => {
+          // no need to search when value is not actually search string
+          if (!value || value instanceof CorelogicSuggestion) {
+            return '';
+          }
+
+          // trim to avoid spaces in searchQuery, we should not send request started or finished with spaces
+          // uppercase to make search string similar to corelogic format
+          return value.trim();
+        }),
+        // do nothing when query is too short
+        filter((searchQuery: string) => searchQuery.length >= AddressForm.minSearchLength)
+      )
+      .subscribe((searchQuery: string) => {
+        this.onSearch.emit(searchQuery);
+      });
+  }
+
+  /**
+   * Check if all fields required for manual corelogic search are filled before request sending
+   */
+  private isManualSearchAvailable(): boolean {
+    return this.get('city').valid && this.get('state').valid && this.get('postcode').valid;
+  }
+
+  /**
+   * When corelogic is required we have to search address even for manual address
+   */
+  private listenManualFieldsChanges(): void {
+    // subscribe to whole form because no other fields may be changed in this case except manual address fields we need
+    this.valueChanges
+      .pipe(
+        // delay to avoid search request for each value change
+        debounceTime(AddressForm.searchDelay),
+        // do nothing when not all required fields filled
+        filter(() => this.isManualSearchAvailable() && this.isAustraliaSelected()),
+        map(() => this.manualSearchQuery),
+        // skip when value not changed
+        distinctUntilChanged()
+      )
+      .subscribe(() => {
+        this.onSearch.emit(this.manualSearchQuery);
+      });
+  }
+
+  /**
+   * Address model has common field 'address' for street name and number because Corelogic returns this data as one string,
+   * but we need separated fields in the form.
+   *
+   * Listen street and number changes and fill address with concatinated values
+   */
+  private listenStreetFieldsChanges(): void {
+    merge(
+      this.get('streetNumber').valueChanges,
+      this.get('street').valueChanges
+    ).subscribe(() => {
+      this.get('address').setValue(`${this.get('streetNumber').value} ${this.get('street').value}`);
+    })
+  }
+
+  private enableCorelogicFields(): void {
+    this.get('corelogicLocId').enable();
+    this.get('corelogicRefId').enable();
+  }
+
+  private disableCorelogicFields(): void {
+    this.get('corelogicLocId').disable();
+    this.get('corelogicRefId').disable();
+  }
+
+  /**
+   * Corelogic loc id is required for Australian addresses
+   */
+  private listenCountryChanges(): void {
+    this.get('country').valueChanges.subscribe(() => {
+      if (this.isAustraliaSelected()) {
+        this.enableCorelogicFields();
+        return;
+      }
+
+      this.disableCorelogicFields();
+    });
+  }
+}

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

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

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

@@ -0,0 +1,16 @@
+import { AbstractForm } from '../abstract.form';
+import { FormControl, Validators } from '@angular/forms';
+import { AussieAppointment } from '../../models';
+import { AussieService } from '../../services';
+import { phoneNumberValidator } from '../../validators/phone-number.validator';
+
+export class AussieAppointmentForm extends AbstractForm<AussieAppointment> {
+  constructor(private appointment: AussieAppointment, private aussieService: AussieService) {
+    super({
+      phone: new FormControl(null, [Validators.required, phoneNumberValidator()]),
+      interactionType: new FormControl('Phone', [Validators.required]),
+      date: new FormControl(null, [Validators.required]),
+      timeslot: new FormControl(null, [Validators.required]),
+    }, appointment);
+  }
+}

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

@@ -0,0 +1,13 @@
+import { AbstractForm } from '../abstract.form';
+import { FormControl, Validators } from '@angular/forms';
+import { AussieAppointment } from '../../models';
+import { AussieService } from '../../services';
+
+export class AussieConfirmationForm extends AbstractForm<AussieAppointment> {
+  constructor(private appointment: AussieAppointment) {
+    super({
+      otp: new FormControl(null, Validators.required),
+      inviteToShare: new FormControl(true, Validators.required),
+    }, appointment);
+  }
+}

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

@@ -0,0 +1,32 @@
+import { AbstractForm } from '../abstract.form';
+import { FormControl, Validators } from '@angular/forms';
+import { AussieAppointment, AussieStore } from '../../models';
+import { AussieService } from '../../services';
+import { IEventListener } from '../../interfaces';
+import { combineLatest } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+
+export class AussieStoreForm extends AbstractForm<AussieAppointment> implements IEventListener {
+  constructor(appointment: AussieAppointment, private aussieService: AussieService) {
+    super({
+      // @TODO set to null
+      suburb: new FormControl('Malvern', [Validators.required, Validators.maxLength(AbstractForm.inputMaxLength)]),
+      postcode: new FormControl('3144', [Validators.required]),
+      store: new FormControl('', [Validators.required]),
+    }, appointment);
+
+    this.listenEvents();
+  }
+
+  listenEvents(): void {
+    combineLatest([this.get('suburb').valueChanges, this.get('postcode').valueChanges]).pipe(debounceTime(1000)).subscribe(() => {
+      this.aussieService.fetchFirst(this.aussieService.apiUrl, true, { postcode: this.value.postcode, suburb: this.value.suburb }).subscribe(store => {
+        this.patchField('store', store);
+      });
+    });
+  }
+
+  get store(): AussieStore {
+    return this.get('store').value;
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from './aussie-store.form';
+export * from './aussie-appointment.form';
+export * from './aussie-confirmation.form';

package/projects/tt-core/src/lib/forms/bank/bank-account/bank-account-add-manual.form.ts

@@ -0,0 +1,57 @@
+import { BankAccount, BankConnection, Loan, TYPE_LOAN } from '../../../models';
+import { UntypedFormControl, Validators } from '@angular/forms';
+import { LoanForm } from '../../loan';
+import { BankAccountTypeEnum } from '../../../db/Enums';
+import { BankAccountAllocationForm } from './bank-account-allocation.form';
+import { plainToClass } from 'class-transformer';
+import { IEventListener } from '../../../interfaces';
+import { BankAccountsImportForm } from './bank-accounts-import.form';
+
+
+/**
+ * Form is using for single manual bank account creation (not Basiq)
+ */
+export class BankAccountAddManualForm extends BankAccountAllocationForm implements IEventListener {
+  static accountNumberPattern = '^[0-9]{6}[ ]{1}[0-9]{1,}$';
+
+  constructor(private connection: BankConnection) {
+    super(null, {
+      // @TODO: taxtankit TT-5555 remove migrateFrom, migrateTo when back fix this
+      migrateFrom : new UntypedFormControl(BankAccountsImportForm.minDate),
+      migrateTo : new UntypedFormControl(BankAccountsImportForm.maxDate),
+      type: new UntypedFormControl(null, Validators.required),
+      accountName: new UntypedFormControl(null, Validators.required),
+      currentBalance: new UntypedFormControl(null, Validators.required),
+      accountNumber: new UntypedFormControl(
+        null,
+        [Validators.required, Validators.pattern(BankAccountAddManualForm.accountNumberPattern)]
+      )
+    });
+  }
+
+  listenEvents() {
+    super.listenEvents();
+    this.listenTypeChanges();
+  }
+
+  /**
+   * Add/Remove loan form depends on selected bank account type
+   */
+  private listenTypeChanges(): void {
+    this.get('type').valueChanges.subscribe((type: BankAccountTypeEnum) => {
+      if (TYPE_LOAN.includes(type)) {
+        // Set prefilled term for bank account loan
+        this.addControl('loan', new LoanForm(plainToClass(Loan, { bankAccount: this.model })));
+      } else {
+        this.removeControl('loan');
+      }
+    });
+  }
+
+  /**
+   * Attach bank connection to manual bank account
+   */
+  submit(): BankAccount {
+    return super.submit({ bankConnection: this.connection });
+  }
+}

package/projects/tt-core/src/lib/forms/bank/bank-account/bank-account-allocation.form.ts

@@ -0,0 +1,60 @@
+import { AbstractForm } from '../../abstract.form';
+import { BankAccount } from '../../../models';
+import { AbstractControl, UntypedFormControl, Validators } from '@angular/forms';
+import { plainToClass } from 'class-transformer';
+import { TankTypeEnum } from '../../../db/Enums/tank-type.enum';
+import { BankAccountPropertiesForm } from './bank-account-properties.form';
+import { SoleBusinessAllocationsForm } from '../../sole';
+import { IEventListener } from '../../../interfaces';
+import merge from 'lodash/merge';
+
+export class BankAccountAllocationForm extends AbstractForm<BankAccount> implements IEventListener {
+  constructor(
+    private bankAccount?: BankAccount,
+    controls?: {
+      [key: string]: AbstractControl
+    }) {
+    super(
+      merge(
+        controls,
+        {
+          tankType: new UntypedFormControl(bankAccount ? bankAccount.tankType : null, Validators.required)
+        }
+      ), plainToClass(BankAccount, bankAccount || {}));
+
+    if (bankAccount?.isPropertyTank()) {
+      this.addControl('bankAccountProperties', new BankAccountPropertiesForm(bankAccount.bankAccountProperties));
+    }
+
+    if (bankAccount?.isSoleTank()) {
+      this.addControl('businessAllocations', new SoleBusinessAllocationsForm(bankAccount.businessAllocations))
+    }
+
+    this.listenEvents();
+  }
+
+  listenEvents(): void {
+    this.listenTankTypeChanges();
+  }
+
+  listenTankTypeChanges(): void {
+    this.get('tankType').valueChanges.subscribe((tankType: TankTypeEnum) => {
+      this.removeControl('bankAccountProperties');
+      this.removeControl('businessAllocations');
+
+      switch (tankType) {
+        case TankTypeEnum.PROPERTY:
+          this.addControl('bankAccountProperties', new BankAccountPropertiesForm(this.bankAccount?.bankAccountProperties));
+          break;
+        case TankTypeEnum.SOLE:
+          this.addControl('businessAllocations', new SoleBusinessAllocationsForm(this.bankAccount?.businessAllocations))
+          break;
+      }
+    })
+  }
+
+  submit(data: object = {}): BankAccount {
+    // remove property/business allocations if empty
+    return super.submit(Object.assign(data, { bankAccountProperties: [], businessAllocations: [] }, this.value));
+  }
+}

package/projects/tt-core/src/lib/forms/bank/bank-account/bank-account-import.form.ts

@@ -0,0 +1,31 @@
+import { LoanForm } from '../../loan';
+import { BankAccount, Loan } from '../../../models';
+import { BankAccountAllocationForm } from './bank-account-allocation.form';
+import { plainToClass } from 'class-transformer';
+
+/**
+ * Form is using for import basiq bank accounts.
+ * Basiq accounts has all data except tank type, properties and loan partially
+ */
+export class BankAccountImportForm extends BankAccountAllocationForm {
+
+  constructor(
+    bankAccount: BankAccount
+  ) {
+    super(bankAccount);
+
+    if (bankAccount.isLoan()) {
+      // Attach bank account to loan for LoanForm's logic
+      // @TODO Alex/Vik: we should use separated API for bank accounts and loans
+      const loan: Loan = plainToClass(Loan, Object.assign(bankAccount.loan, { bankAccount: { accountId: bankAccount.accountId } }));
+
+      this.addControl('loan', new LoanForm(loan));
+    }
+
+    // don't preselect tank type by default
+    this.get('tankType').setValue(null);
+
+    // basiq account import form should be disabled (unchecked) by default
+    this.disable();
+  }
+}

package/projects/tt-core/src/lib/forms/bank/bank-account/bank-account-properties.form.ts

@@ -0,0 +1,78 @@
+import { AbstractControl, UntypedFormArray, UntypedFormControl, UntypedFormGroup, Validators } from '@angular/forms';
+import { BankAccountProperty } from '../../../models';
+import { plainToClass } from 'class-transformer';
+import { TankTypeEnum } from '../../../db/Enums/tank-type.enum';
+import { conditionalValidator, fieldsSumValidator } from '../../../validators';
+
+/**
+ * Form array with bank account properties
+ * @TODO create AbstractFormArray
+ */
+export class BankAccountPropertiesForm extends UntypedFormArray {
+  constructor(bankAccountProperties?: BankAccountProperty[]) {
+    super(
+      (bankAccountProperties?.length ? bankAccountProperties : [plainToClass(BankAccountProperty, {})])
+        .map((bankAccountProperty: BankAccountProperty) => new UntypedFormGroup({
+          property: new UntypedFormControl(bankAccountProperty?.property, Validators.required),
+          percent: new UntypedFormControl(bankAccountProperty.percent, Validators.required)
+        })),
+      [
+        conditionalValidator(
+          (control: AbstractControl): boolean => control.get('tankType').value === TankTypeEnum.PROPERTY,
+          Validators.required
+        ),
+        fieldsSumValidator('percent', 100)
+      ]
+    );
+  }
+
+  add(): void {
+    this.push(new UntypedFormGroup({
+      property: new UntypedFormControl(null, Validators.required),
+      // @TODO disable for loans
+      percent: new UntypedFormControl(
+        { value: this.getRemainingPercent(), disabled: !(this.at(0) as UntypedFormGroup).contains('percent') },
+        Validators.required
+      ),
+      // @TODO enable for loans
+      // amount: new FormControl(
+      //   {value: this.bankAccount.currentBalance * bankAccountProperty.percent / 100},
+      //   [Validators.required, Validators.max(Math.abs(this.bankAccount.currentBalance))]
+      // ),
+    }));
+  }
+
+  // @TODO enable for loans
+  // /**
+  //  * Recalculate property percentage for current property form group and round to no more than 3 decimal places
+  //  * @param amount: new control value
+  //  * @param currentPropertyGroup for which amount will be recalculated
+  //  */
+  // recalculatePropertyPercentage(amount: number, currentPropertyGroup: FormGroup): void {
+  //   currentPropertyGroup.get('percent').setValue(
+  //     roundTo(amount / this.bankAccount.currentBalance, 3)
+  //   );
+  // }
+
+  enablePercent(): void {
+    this.controls.forEach((propertyFormGroup: UntypedFormGroup) => {
+      propertyFormGroup.get('percent').enable();
+    });
+  }
+
+  disablePercent(): void {
+    this.controls.forEach((propertyFormGroup: UntypedFormGroup) => {
+      propertyFormGroup.get('percent').disable();
+    });
+  }
+
+  /**
+   * Percentage available for adding a new bank account property.
+   * Remaining percent can't be more than 100 and less than 0
+   */
+  private getRemainingPercent(): number {
+    const currentTotalPercent: number = this.controls.reduce((sum: number, control: UntypedFormGroup) => sum + control.get('percent').value, 0);
+
+    return currentTotalPercent < 100 ? 100 - currentTotalPercent : 0;
+  }
+}

package/projects/tt-core/src/lib/forms/bank/bank-account/bank-accounts-import.form.ts

@@ -0,0 +1,82 @@
+import { BankAccount, FinancialYear } from '../../../models';
+import { UntypedFormArray, UntypedFormControl, Validators } from '@angular/forms';
+import { dateRangeValidator } from '../../../validators/date-range.validator';
+import { AbstractForm } from '../../abstract.form';
+import { BankAccountImportForm } from './bank-account-import.form';
+import { atLeastOneEnabledValidator } from '../../../validators/at-least-one-enabled.validator';
+import { notGreaterThanControlValidator } from '../../../validators/not-greater-than-control.validator';
+
+/**
+ * Form for import multiple basiq bank accounts
+ */
+export class BankAccountsImportForm extends AbstractForm<BankAccount[]> {
+  // start of the previous financial year
+  static minDate: Date = new FinancialYear(new Date(new Date().setFullYear(new Date().getFullYear() - 1))).startDate;
+  static maxDate: Date = new Date();
+
+  constructor(protected bankAccounts: BankAccount[]) {
+    super({
+      // @TODO should be part of each bankAccount model
+      migrateFrom: new UntypedFormControl(
+        BankAccountsImportForm.minDate, [
+          Validators.required,
+          dateRangeValidator(BankAccountsImportForm.minDate, BankAccountsImportForm.maxDate),
+          notGreaterThanControlValidator('migrateTo', 'Import transactions to')
+        ]
+      ),
+      migrateTo: new UntypedFormControl(
+        BankAccountsImportForm.maxDate,
+        [Validators.required, dateRangeValidator(BankAccountsImportForm.minDate, BankAccountsImportForm.maxDate)]
+      ),
+      bankAccounts: new UntypedFormArray(bankAccounts.map((bankAccount: BankAccount) => new BankAccountImportForm(bankAccount)))
+    }, [],
+    {
+      validators: [atLeastOneEnabledValidator('bankAccounts')]
+    });
+
+    this.listenEvents();
+  }
+
+  listenEvents(): void {
+    this.get('migrateTo').valueChanges.subscribe(() => {
+      this.get('migrateFrom').updateValueAndValidity({ emitEvent: false });
+    });
+  }
+
+  submit(): BankAccount[] {
+    this.submitted = true;
+
+    if (this.invalid) {
+      return null;
+    }
+
+    const bankAccounts: BankAccount[] = [];
+
+    // form is valid when all selected bank accounts forms are valid
+    for (const bankAccountImportForm of (this.get('bankAccounts') as UntypedFormArray).controls) {
+      // skip disabled forms
+      if (bankAccountImportForm.disabled) {
+        continue;
+      }
+
+      const bankAccount: BankAccount = (bankAccountImportForm as BankAccountImportForm).submit(
+        {
+          migrateFrom: this.value.migrateFrom,
+          migrateTo: this.value.migrateTo
+        }
+      );
+
+      if (!bankAccount) {
+        return null;
+      }
+
+      bankAccounts.push(bankAccount);
+    }
+
+    if (!bankAccounts.length) {
+      return null;
+    }
+
+    return bankAccounts;
+  }
+}

package/projects/tt-core/src/lib/forms/bank/bank-transaction-comment.form.ts

@@ -0,0 +1,12 @@
+import { AbstractForm } from '../abstract.form';
+import { FormControl, Validators } from '@angular/forms';
+import { BankTransactionComment } from '../../models';
+import { plainToClass } from 'class-transformer';
+
+export class BankTransactionCommentForm extends AbstractForm<BankTransactionComment> {
+  constructor(private comment: BankTransactionComment = plainToClass(BankTransactionComment, {})) {
+    super({
+      content: new FormControl(comment.content, [Validators.required, Validators.maxLength(255)]),
+    }, comment);
+  }
+}

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

@@ -0,0 +1,6 @@
+export * from './bank-transaction-comment.form';
+export * from './bank-account/bank-account-add-manual.form';
+export * from './bank-account/bank-account-allocation.form';
+export * from './bank-account/bank-accounts-import.form';
+export * from './bank-account/bank-account-properties.form';
+export * from './bank-account/bank-account-import.form';