taxtank-core 0.31.61 → 0.32.1

package/esm2022/lib/forms/address/address.form.mjs

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

package/esm2022/lib/forms/bank/bank-account/bank-account-add-manual.form.mjs

@@ -0,0 +1,46 @@
+import { UntypedFormControl, Validators } from '@angular/forms';
+import { LoanForm } from '../../loan';
+import { BankAccountTypeEnum } from '../../../db/Enums/bank/bank-account-type.enum';
+import { BankAccountAllocationForm } from './bank-account-allocation.form';
+import { plainToClass } from 'class-transformer';
+import { Loan } from '../../../models/loan/loan';
+/**
+ * Form is using for single manual bank account creation (not Basiq)
+ */
+export class BankAccountAddManualForm extends BankAccountAllocationForm {
+    static { this.accountNumberPattern = '^[0-9]{6}[ ]{1}[0-9]{1,}$'; }
+    constructor(connection) {
+        super(null, {
+            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)])
+        });
+        this.connection = connection;
+    }
+    listenEvents() {
+        super.listenEvents();
+        this.listenTypeChanges();
+    }
+    /**
+     * Add/Remove loan form depends on selected bank account type
+     */
+    listenTypeChanges() {
+        this.get('type').valueChanges.subscribe((type) => {
+            if (type === BankAccountTypeEnum.LOAN) {
+                // 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() {
+        return super.submit({ bankConnection: this.connection });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/forms/bank/bank-account/bank-accounts-import.form.mjs

@@ -0,0 +1,50 @@
+import { UntypedFormArray, UntypedFormControl, Validators } from '@angular/forms';
+import { dateRangeValidator } from '../../../validators/date-range.validator';
+import { FinancialYear } from '../../../models/financial-year/financial-year';
+import { AbstractForm } from '../../abstract.form';
+import { BankAccountImportForm } from './bank-account-import.form';
+import { atLeastOneEnabledValidator } from '../../../validators/at-least-one-enabled.validator';
+/**
+ * Form for import multiple basiq bank accounts
+ */
+export class BankAccountsImportForm extends AbstractForm {
+    static { this.minDate = new FinancialYear().prevFinYear.startDate; }
+    static { this.maxDate = new Date(); }
+    constructor(bankAccounts) {
+        super({
+            migrateFrom: new UntypedFormControl(BankAccountsImportForm.minDate, [Validators.required, dateRangeValidator(BankAccountsImportForm.minDate, BankAccountsImportForm.maxDate)]),
+            migrateTo: new UntypedFormControl(BankAccountsImportForm.maxDate, [Validators.required, dateRangeValidator(BankAccountsImportForm.minDate, BankAccountsImportForm.maxDate)]),
+            bankAccounts: new UntypedFormArray(bankAccounts.map((bankAccount) => new BankAccountImportForm(bankAccount)))
+        }, [], {
+            validators: [atLeastOneEnabledValidator('bankAccounts')]
+        });
+        this.bankAccounts = bankAccounts;
+    }
+    submit() {
+        this.submitted = true;
+        if (this.invalid) {
+            return null;
+        }
+        const bankAccounts = [];
+        // form is valid when all selected bank accounts forms are valid
+        for (const bankAccountImportForm of this.get('bankAccounts').controls) {
+            // skip disabled forms
+            if (bankAccountImportForm.disabled) {
+                continue;
+            }
+            const bankAccount = bankAccountImportForm.submit({
+                migrateFrom: this.value.migrateFrom,
+                migrateTo: this.value.migrateTo
+            });
+            if (!bankAccount) {
+                return null;
+            }
+            bankAccounts.push(bankAccount);
+        }
+        if (!bankAccounts.length) {
+            return null;
+        }
+        return bankAccounts;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/forms/loan/loan.form.mjs

@@ -0,0 +1,90 @@
+import { AbstractForm } from '../abstract.form';
+import { UntypedFormControl, Validators } from '@angular/forms';
+import { Loan } from '../../models/loan/loan';
+import { LoanRepaymentFrequencyEnum } from '../../db/Enums/bank/loan/loan-repayment-frequency.enum';
+import { LoanMaxNumberOfPaymentsEnum } from '../../models/loan/loan-max-number-of-payments.enum';
+import { plainToClass } from 'class-transformer';
+import { LoanRepaymentTypeEnum } from '../../db/Enums/bank/loan/loan-repayment-type.enum';
+import { LoanInterestTypeEnum } from '../../db/Enums/bank/loan/loan-interest-type.enum';
+import { LoanTypeEnum } from '../../db/Enums/bank/loan/loan-type.enum';
+/**
+ * Form with loan details.
+ * Loan could be created from bank account (Bank Loan) or directly from loan page (Vehicle Loan)
+ */
+export class LoanForm extends AbstractForm {
+    static { this.mortgageLoanTypes = [LoanTypeEnum.MORTGAGE, LoanTypeEnum.HOME_EQUITY_LINE_OF_CREDIT, LoanTypeEnum.HOME_LOAN]; }
+    constructor(loan = plainToClass(Loan, {})) {
+        super({
+            type: new UntypedFormControl(loan.type, Validators.required),
+            amount: new UntypedFormControl(loan.amount, Validators.required),
+            interestRate: new UntypedFormControl(loan.interestRate, [Validators.required, Validators.min(0), Validators.max(100)]),
+            commencementDate: new UntypedFormControl(loan.commencementDate, Validators.required),
+            repaymentAmount: new UntypedFormControl(loan.repaymentAmount),
+            repaymentFrequency: new UntypedFormControl(loan.repaymentFrequency, Validators.required),
+            term: new UntypedFormControl(loan.term, Validators.required),
+            // interestType is predefined for vehicle loans
+            interestType: new UntypedFormControl({ value: loan.interestType, disabled: !loan.bankAccount }, Validators.required),
+            // availableRedraw is predefined for vehicle loans
+            availableRedraw: new UntypedFormControl({ value: loan.availableRedraw, disabled: !loan.bankAccount }, Validators.required),
+            // repaymentType is predefined for vehicle loans
+            repaymentType: new UntypedFormControl({ value: loan.repaymentType, disabled: !loan.bankAccount }, Validators.required),
+        }, loan);
+        this.loan = loan;
+        // Set data which always the same for vehicle loans
+        if (!loan.bankAccount) {
+            Object.assign(this.model, {
+                repaymentType: LoanRepaymentTypeEnum.PRINCIPAL_AND_INTEREST,
+                availableRedraw: 0,
+                interestType: LoanInterestTypeEnum.FIXED_RATE
+            });
+        }
+        this.updateTermValidation();
+        this.listenEvents();
+    }
+    listenEvents() {
+        // We need to set term automatically only for bank loans.
+        // For vehicle loans user should fill it manually with validation depended of frequency
+        if (this.loan.bankAccount) {
+            this.listenTypeChanges();
+        }
+        else {
+            this.listenRepaymentFrequencyChanges();
+        }
+    }
+    /**
+     * Set term automatically by loan type changes
+     */
+    listenTypeChanges() {
+        this.get('type').valueChanges.subscribe((type) => {
+            this.get('term').setValue(LoanForm.mortgageLoanTypes.includes(type) ? Loan.mortgageDefaultTerm : Loan.loanDefaultTerm);
+        });
+    }
+    /**
+     * term validation depends on selected repaymentFrequency
+     */
+    listenRepaymentFrequencyChanges() {
+        this.get('repaymentFrequency').valueChanges.subscribe(() => {
+            this.updateTermValidation();
+        });
+    }
+    /**
+     * For vehicle loans term has a maximum value depended of repayment frequency
+     */
+    updateTermValidation() {
+        // no need terms for bank loans
+        if (this.loan.bankAccount) {
+            return;
+        }
+        const currentRepaymentFrequency = this.get('repaymentFrequency').value;
+        // term validation depends on selected repayment frequency, so can not validate when frequency is empty
+        // repaymentType is required field, so we don't need to clear validation
+        if (!currentRepaymentFrequency) {
+            return;
+        }
+        const termControl = this.get('term');
+        const maxTermValue = LoanMaxNumberOfPaymentsEnum[LoanRepaymentFrequencyEnum[currentRepaymentFrequency]];
+        termControl.setValidators([Validators.max(maxTermValue)]);
+        termControl.updateValueAndValidity();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loan.form.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/forms/loan/loan.form.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractForm } from '../abstract.form';\nimport { UntypedFormControl, Validators } from '@angular/forms';\nimport { Loan } from '../../models/loan/loan';\nimport { LoanRepaymentFrequencyEnum } from '../../db/Enums/bank/loan/loan-repayment-frequency.enum';\nimport { LoanMaxNumberOfPaymentsEnum } from '../../models/loan/loan-max-number-of-payments.enum';\nimport { plainToClass } from 'class-transformer';\nimport { LoanRepaymentTypeEnum } from '../../db/Enums/bank/loan/loan-repayment-type.enum';\nimport { LoanInterestTypeEnum } from '../../db/Enums/bank/loan/loan-interest-type.enum';\nimport { LoanTypeEnum } from '../../db/Enums/bank/loan/loan-type.enum';\n\n/**\n * Form with loan details.\n * Loan could be created from bank account (Bank Loan) or directly from loan page (Vehicle Loan)\n */\nexport class LoanForm extends AbstractForm<Loan> {\n  static mortgageLoanTypes: LoanTypeEnum[] = [LoanTypeEnum.MORTGAGE, LoanTypeEnum.HOME_EQUITY_LINE_OF_CREDIT, LoanTypeEnum.HOME_LOAN];\n\n  constructor(\n    private loan: Loan = plainToClass(Loan, {}),\n  ) {\n    super({\n      type: new UntypedFormControl(loan.type, Validators.required),\n      amount: new UntypedFormControl(loan.amount, Validators.required),\n      interestRate: new UntypedFormControl(loan.interestRate, [Validators.required, Validators.min(0), Validators.max(100)]),\n      commencementDate: new UntypedFormControl(loan.commencementDate, Validators.required),\n      repaymentAmount: new UntypedFormControl(loan.repaymentAmount),\n      repaymentFrequency: new UntypedFormControl(loan.repaymentFrequency, Validators.required),\n      term: new UntypedFormControl(loan.term, Validators.required),\n      // interestType is predefined for vehicle loans\n      interestType: new UntypedFormControl({value: loan.interestType, disabled: !loan.bankAccount}, Validators.required),\n      // availableRedraw is predefined for vehicle loans\n      availableRedraw: new UntypedFormControl({value: loan.availableRedraw, disabled: !loan.bankAccount}, Validators.required),\n      // repaymentType is predefined for vehicle loans\n      repaymentType: new UntypedFormControl({value: loan.repaymentType, disabled: !loan.bankAccount}, Validators.required),\n    }, loan);\n\n    // Set data which always the same for vehicle loans\n    if (!loan.bankAccount) {\n      Object.assign(this.model, {\n        repaymentType: LoanRepaymentTypeEnum.PRINCIPAL_AND_INTEREST,\n        availableRedraw: 0,\n        interestType: LoanInterestTypeEnum.FIXED_RATE\n      });\n    }\n\n    this.updateTermValidation();\n    this.listenEvents();\n  }\n\n  listenEvents(): void {\n    // We need to set term automatically only for bank loans.\n    // For vehicle loans user should fill it manually with validation depended of frequency\n    if (this.loan.bankAccount) {\n      this.listenTypeChanges();\n    } else {\n      this.listenRepaymentFrequencyChanges();\n    }\n  }\n\n  /**\n   * Set term automatically by loan type changes\n   */\n  listenTypeChanges(): void {\n    this.get('type').valueChanges.subscribe((type: LoanTypeEnum) => {\n      this.get('term').setValue(\n        LoanForm.mortgageLoanTypes.includes(type) ? Loan.mortgageDefaultTerm : Loan.loanDefaultTerm\n      );\n    })\n  }\n\n  /**\n   * term validation depends on selected repaymentFrequency\n   */\n  listenRepaymentFrequencyChanges(): void {\n    this.get('repaymentFrequency').valueChanges.subscribe(() => {\n      this.updateTermValidation();\n    });\n  }\n\n  /**\n   * For vehicle loans term has a maximum value depended of repayment frequency\n   */\n  private updateTermValidation(): void {\n    // no need terms for bank loans\n    if (this.loan.bankAccount) {\n      return;\n    }\n\n    const currentRepaymentFrequency: LoanRepaymentFrequencyEnum = this.get('repaymentFrequency').value;\n    // term validation depends on selected repayment frequency, so can not validate when frequency is empty\n    // repaymentType is required field, so we don't need to clear validation\n    if (!currentRepaymentFrequency) {\n      return;\n    }\n\n    const termControl: UntypedFormControl = this.get('term') as UntypedFormControl;\n    const maxTermValue: number = LoanMaxNumberOfPaymentsEnum[LoanRepaymentFrequencyEnum[currentRepaymentFrequency]];\n\n    termControl.setValidators([Validators.max(maxTermValue)]);\n    termControl.updateValueAndValidity();\n  }\n}\n"]}

package/esm2022/lib/forms/sole/sole-invoice-item.form.mjs

@@ -0,0 +1,16 @@
+import { AbstractForm } from '../abstract.form';
+import { UntypedFormControl, Validators } from '@angular/forms';
+export class SoleInvoiceItemForm extends AbstractForm {
+    static { this.maxDescriptionLength = 255; }
+    constructor(item, isExpense) {
+        super({
+            isExpense: new UntypedFormControl(isExpense),
+            description: new UntypedFormControl(item.description, [Validators.required, Validators.maxLength(SoleInvoiceItemForm.maxDescriptionLength)]),
+            quantity: new UntypedFormControl(item.quantity, Validators.required),
+            price: new UntypedFormControl(item.price, Validators.required),
+            isGST: new UntypedFormControl({ value: item.isGST || false, disabled: !item.chartAccounts?.isGST }),
+            chartAccounts: new UntypedFormControl(item.chartAccounts, Validators.required),
+        }, item);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/forms/vehicle/vehicle-logbook.form.mjs

@@ -0,0 +1,63 @@
+import { AbstractForm } from '../abstract.form';
+import { UntypedFormControl, Validators } from '@angular/forms';
+import { FinancialYear } from '../../models/financial-year/financial-year';
+import { dateRangeValidator } from '../../validators/date-range.validator';
+/**
+ * Add/Edit vehicle logbook form.
+ * Behavior cases:
+ * 1) Create the first logbook OR Edit the single logbook: all fields enabled
+ * 2) Create the non-first logbook OR Edit the last logbook: odometerStart disabled
+ * 3) Edit the non-last logbook: odometerStart, odometerEnd, date disabled
+ */
+export class VehicleLogbookForm extends AbstractForm {
+    static { this.maxDescriptionLength = 60; }
+    /**
+     * @param logbook required because we need to set vehicle allocation and we can not set in in the form
+     * @param logbooks list of all logbooks related to current logbook's vehicle. Required for form fields validation and disabled state management
+     */
+    constructor(logbook, logbooks) {
+        super({
+            description: new UntypedFormControl(logbook.description, [Validators.required, Validators.maxLength(VehicleLogbookForm.maxDescriptionLength)]),
+            isPersonal: new UntypedFormControl(logbook.isPersonal),
+            date: new UntypedFormControl(logbook.date, Validators.required),
+            odometerStart: new UntypedFormControl(logbook.odometerStart, Validators.required),
+            odometerEnd: new UntypedFormControl(logbook.odometerEnd, Validators.required),
+            business: new UntypedFormControl(logbook.business)
+        }, logbook);
+        this.logbook = logbook;
+        this.logbooks = logbooks;
+        this.updateStateAndValidators();
+    }
+    /**
+     * Set logbook validators and disable state depends of initial logbook and its place in the whole list
+     */
+    updateStateAndValidators() {
+        switch (true) {
+            // Create the first or edit the single logbook
+            case !this.logbook.id && !this.logbooks.length:
+            case !!this.logbook.id && this.logbooks.length === 1:
+                this.get('odometerStart').setValidators(Validators.min(0));
+                this.get('date').setValidators(dateRangeValidator(new FinancialYear().startDate, new FinancialYear().endDate));
+                break;
+            // Create the non-first
+            case !this.logbook.id && !!this.logbooks.length:
+                this.get('odometerStart').disable();
+                this.get('odometerEnd').setValidators(Validators.min(this.logbooks.last.odometerEnd));
+                this.get('date').setValidators(dateRangeValidator(this.logbooks.last.date, new FinancialYear().endDate));
+                break;
+            // Edit the last logbook
+            case !!this.logbook.id && this.logbook.id === this.logbooks.last.id && this.logbooks.length > 1:
+                this.get('odometerStart').disable();
+                this.get('odometerEnd').setValidators(Validators.min(this.logbooks.last.odometerEnd));
+                const preLastDate = this.logbooks.toArray()[this.logbooks.length - 1].date;
+                this.get('date').setValidators(dateRangeValidator(preLastDate, new FinancialYear().endDate));
+                break;
+            // Edit the non-last logbook
+            case !!this.logbook.id && this.logbook.id !== this.logbooks.last.id && this.logbooks.length > 1:
+                this.get('odometerStart').disable();
+                this.get('odometerEnd').disable();
+                this.get('date').disable();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vehicle-logbook.form.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/forms/vehicle/vehicle-logbook.form.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractForm } from '../abstract.form';\nimport { VehicleLogbook } from '../../models';\nimport { UntypedFormControl, Validators } from '@angular/forms';\nimport { FinancialYear } from '../../models/financial-year/financial-year';\nimport { VehicleLogbookCollection } from '../../collections';\nimport { dateRangeValidator } from '../../validators/date-range.validator';\n\n/**\n * Add/Edit vehicle logbook form.\n * Behavior cases:\n * 1) Create the first logbook OR Edit the single logbook: all fields enabled\n * 2) Create the non-first logbook OR Edit the last logbook: odometerStart disabled\n * 3) Edit the non-last logbook: odometerStart, odometerEnd, date disabled\n */\nexport class VehicleLogbookForm extends AbstractForm<VehicleLogbook> {\n  static maxDescriptionLength = 60;\n\n  /**\n   * @param logbook required because we need to set vehicle allocation and we can not set in in the form\n   * @param logbooks list of all logbooks related to current logbook's vehicle. Required for form fields validation and disabled state management\n   */\n  constructor(\n    private logbook: VehicleLogbook,\n    private logbooks: VehicleLogbookCollection\n  ) {\n    super({\n      description: new UntypedFormControl(logbook.description, [Validators.required, Validators.maxLength(VehicleLogbookForm.maxDescriptionLength)]),\n      isPersonal: new UntypedFormControl(logbook.isPersonal),\n      date: new UntypedFormControl(logbook.date, Validators.required),\n      odometerStart: new UntypedFormControl(logbook.odometerStart, Validators.required),\n      odometerEnd: new UntypedFormControl(logbook.odometerEnd, Validators.required),\n      business: new UntypedFormControl(logbook.business)\n    }, logbook);\n\n    this.updateStateAndValidators();\n  }\n\n  /**\n   * Set logbook validators and disable state depends of initial logbook and its place in the whole list\n   */\n  private updateStateAndValidators(): void {\n    switch (true) {\n      // Create the first or edit the single logbook\n      case !this.logbook.id && !this.logbooks.length:\n      case !!this.logbook.id && this.logbooks.length === 1:\n        this.get('odometerStart').setValidators(Validators.min(0));\n        this.get('date').setValidators(dateRangeValidator(new FinancialYear().startDate, new FinancialYear().endDate))\n        break;\n      // Create the non-first\n      case !this.logbook.id && !!this.logbooks.length:\n        this.get('odometerStart').disable();\n        this.get('odometerEnd').setValidators(Validators.min(this.logbooks.last.odometerEnd));\n        this.get('date').setValidators(dateRangeValidator(this.logbooks.last.date, new FinancialYear().endDate));\n        break;\n      // Edit the last logbook\n      case !!this.logbook.id && this.logbook.id === this.logbooks.last.id && this.logbooks.length > 1:\n        this.get('odometerStart').disable();\n        this.get('odometerEnd').setValidators(Validators.min(this.logbooks.last.odometerEnd));\n        const preLastDate: Date = this.logbooks.toArray()[this.logbooks.length - 1].date;\n        this.get('date').setValidators(dateRangeValidator(preLastDate, new FinancialYear().endDate));\n        break;\n      // Edit the non-last logbook\n      case !!this.logbook.id && this.logbook.id !== this.logbooks.last.id && this.logbooks.length > 1:\n        this.get('odometerStart').disable();\n        this.get('odometerEnd').disable();\n        this.get('date').disable();\n    }\n  }\n}\n"]}

package/esm2022/lib/forms/vehicle/vehicle.form.mjs

@@ -0,0 +1,17 @@
+import { AbstractForm } from '../abstract.form';
+import { UntypedFormControl, Validators } from '@angular/forms';
+import { Vehicle } from '../../models';
+import { plainToClass } from 'class-transformer';
+/**
+ * Add/Edit Vehicle form
+ */
+export class VehicleForm extends AbstractForm {
+    static { this.maxNameLength = 60; }
+    constructor(vehicle = plainToClass(Vehicle, {})) {
+        super({
+            name: new UntypedFormControl(vehicle.name, [Validators.required, Validators.maxLength(VehicleForm.maxNameLength)])
+        }, vehicle);
+        this.vehicle = vehicle;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVoaWNsZS5mb3JtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL2Zvcm1zL3ZlaGljbGUvdmVoaWNsZS5mb3JtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNoRCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsVUFBVSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDaEUsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUN2QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFakQ7O0dBRUc7QUFDSCxNQUFNLE9BQU8sV0FBWSxTQUFRLFlBQXFCO2FBQzdDLGtCQUFhLEdBQUcsRUFBRSxDQUFDO0lBRTFCLFlBQ1UsVUFBbUIsWUFBWSxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUM7UUFFcEQsS0FBSyxDQUFDO1lBQ0osSUFBSSxFQUFFLElBQUksa0JBQWtCLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDLFVBQVUsQ0FBQyxRQUFRLEVBQUUsVUFBVSxDQUFDLFNBQVMsQ0FBQyxXQUFXLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQztTQUNuSCxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBSkosWUFBTyxHQUFQLE9BQU8sQ0FBcUM7SUFLdEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFic3RyYWN0Rm9ybSB9IGZyb20gJy4uL2Fic3RyYWN0LmZvcm0nO1xuaW1wb3J0IHsgVW50eXBlZEZvcm1Db250cm9sLCBWYWxpZGF0b3JzIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuaW1wb3J0IHsgVmVoaWNsZSB9IGZyb20gJy4uLy4uL21vZGVscyc7XG5pbXBvcnQgeyBwbGFpblRvQ2xhc3MgfSBmcm9tICdjbGFzcy10cmFuc2Zvcm1lcic7XG5cbi8qKlxuICogQWRkL0VkaXQgVmVoaWNsZSBmb3JtXG4gKi9cbmV4cG9ydCBjbGFzcyBWZWhpY2xlRm9ybSBleHRlbmRzIEFic3RyYWN0Rm9ybTxWZWhpY2xlPiB7XG4gIHN0YXRpYyBtYXhOYW1lTGVuZ3RoID0gNjA7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHJpdmF0ZSB2ZWhpY2xlOiBWZWhpY2xlID0gcGxhaW5Ub0NsYXNzKFZlaGljbGUsIHt9KVxuICApIHtcbiAgICBzdXBlcih7XG4gICAgICBuYW1lOiBuZXcgVW50eXBlZEZvcm1Db250cm9sKHZlaGljbGUubmFtZSwgW1ZhbGlkYXRvcnMucmVxdWlyZWQsIFZhbGlkYXRvcnMubWF4TGVuZ3RoKFZlaGljbGVGb3JtLm1heE5hbWVMZW5ndGgpXSlcbiAgICB9LCB2ZWhpY2xlKTtcbiAgfVxufVxuIl19

package/esm2022/lib/interceptors/basiq-client-id.interceptor.mjs

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { mergeMap } from 'rxjs/operators';
+import { BasiqService } from '../services/http/bank/basiq/basiq.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/http/user/user.service";
+/**
+ * Interceptor which check if client's basiq id exist and request it if not
+ */
+export class BasiqClientIdInterceptor {
+    constructor(userService) {
+        this.userService = userService;
+    }
+    intercept(request, next) {
+        // Check if 'client id' URL segment contains null instead of id
+        if (!request.url.startsWith(`${BasiqService.basiqApiUrl}/users/null`)) {
+            return next.handle(request);
+        }
+        return this.userService.createBasiq().pipe(mergeMap((basiqClientId) => next.handle(this.addId(request, basiqClientId))));
+    }
+    addId(request, basiqClientId) {
+        return request.clone({
+            url: request.url.replace('null', basiqClientId)
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BasiqClientIdInterceptor, deps: [{ token: i1.UserService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BasiqClientIdInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BasiqClientIdInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.UserService }]; } });
+//# sourceMappingURL=data:application/json;base64,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