taxtank 0.1.0

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

@@ -0,0 +1,15 @@
+import { AbstractForm } from '../abstract.form';
+import { SoleDetails } from '../../models';
+import { UntypedFormControl, Validators } from '@angular/forms';
+import { requiredLengthValidator } from '../../validators/required-length.validator';
+
+export class SoleDetailsForm extends AbstractForm<SoleDetails> {
+  constructor(
+    soleDetails: SoleDetails
+  ) {
+    super({
+      abn: new UntypedFormControl(soleDetails.abn, [Validators.required, requiredLengthValidator(11)]),
+      isGST: new UntypedFormControl(soleDetails.isGST || false)
+    }, soleDetails);
+  }
+}

package/projects/tt-core/src/lib/forms/sole/sole-invoice-item.form.ts

@@ -0,0 +1,20 @@
+import { AbstractForm } from '../abstract.form';
+import { SoleInvoiceItem } from '../../models';
+import { UntypedFormControl, Validators } from '@angular/forms';
+
+export class SoleInvoiceItemForm extends AbstractForm<SoleInvoiceItem> {
+  static maxDescriptionLength = 255;
+
+  constructor(item: SoleInvoiceItem) {
+    super({
+      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);
+  }
+}

package/projects/tt-core/src/lib/forms/sole/sole-invoice-template.form.ts

@@ -0,0 +1,18 @@
+import { AbstractForm } from '../abstract.form';
+import { SoleInvoiceTemplate } from '../../models';
+import { UntypedFormControl, Validators } from '@angular/forms';
+
+export class SoleInvoiceTemplateForm extends AbstractForm<SoleInvoiceTemplate> {
+  constructor(
+    invoiceTemplate: SoleInvoiceTemplate
+  ) {
+    super({
+      name: new UntypedFormControl(invoiceTemplate.name, Validators.required),
+      // taxType is always 'No Tax' when soleDetails.isGST === false
+      taxType: new UntypedFormControl(invoiceTemplate.taxType, Validators.required),
+      // 32767 - max value because we have small int data type in database for this field, but we don't have actual max validation for term
+      term: new UntypedFormControl(invoiceTemplate.term, [Validators.required, Validators.min(0), Validators.max(32767)]),
+      bankAccount: new UntypedFormControl(invoiceTemplate.bankAccount, [Validators.required]),
+    }, invoiceTemplate);
+  }
+}

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

@@ -0,0 +1,192 @@
+import { AbstractForm } from '../abstract.form';
+import { SoleInvoice, SoleInvoiceItem, SoleInvoiceTemplate } from '../../models';
+import { UntypedFormArray, UntypedFormControl, UntypedFormGroup, Validators } from '@angular/forms';
+import { SoleInvoiceItemForm } from './sole-invoice-item.form';
+import { plainToClass } from 'class-transformer';
+import { IEventListener } from '../../interfaces';
+import { SoleInvoiceTaxTypeEnum } from '../../db/Enums';
+import { ChartAccounts } from '../../models';
+
+/**
+ * Form is divided into two groups, since the creation of Sole invoice takes place in two steps:
+ * a common invoice data and sole invoice items.
+ */
+export class SoleInvoiceForm extends AbstractForm<SoleInvoice> implements IEventListener {
+  constructor(
+    private invoice: SoleInvoice,
+    private soleDetailsGST: boolean,
+    // default template to be preselected
+    private defaultTemplate: SoleInvoiceTemplate,
+  ) {
+    super({
+      // @TODO refactor, no need for nested level
+      commonData: new UntypedFormGroup({
+        dateFrom: new UntypedFormControl(invoice.dateFrom || new Date(), Validators.required),
+        dateTo: new UntypedFormControl(invoice.dateTo, Validators.required),
+        payer: new UntypedFormControl(invoice.payer, Validators.required),
+        taxType: new UntypedFormControl(invoice.taxType, Validators.required),
+        bankAccount: new UntypedFormControl(invoice.bankAccount, Validators.required),
+        reference: new UntypedFormControl(invoice.reference),
+        number: new UntypedFormControl(invoice.number, [Validators.required]),
+      }),
+      items: new UntypedFormArray((invoice.items || [plainToClass(SoleInvoiceItem, {})])
+        .map((item: SoleInvoiceItem) => new SoleInvoiceItemForm(item))),
+    }, invoice);
+
+    // we need invoice template only for new invoices
+    if (!invoice.id) {
+      (this.commonData).addControl('template', new UntypedFormControl(this.defaultTemplate));
+
+      // user can have no template, but he can add it from this form
+      if (this.defaultTemplate) {
+        this.updateTemplateRelatedFields(this.defaultTemplate);
+      }
+
+      // set tax exclusive by default if user is registered for gst
+      if (this.soleDetailsGST) {
+        this.commonData.get('taxType').setValue(SoleInvoiceTaxTypeEnum.TAX_EXCLUSIVE);
+      }
+    }
+
+    // invoice.taxType is always NONE ('No Tax') when soleDetails.isGST === false
+    if (!this.soleDetailsGST) {
+      this.commonData.get('taxType').setValue(SoleInvoiceTaxTypeEnum.NO_TAX);
+      this.commonData.get('taxType').disable();
+
+      // Items isGST is not available when invoice.taxType === NONE ('No Tax')
+      this.items.controls.forEach((itemForm: SoleInvoiceItemForm) => {
+        this.disableItemGST(itemForm);
+      });
+    }
+
+    this.listenEvents();
+  }
+
+  get items(): UntypedFormArray {
+    return this.get('items') as UntypedFormArray;
+  }
+
+  listenEvents(): void {
+    // no need to listen tax type and items chart accounts changes when soleDetails.isGST === false
+    // because invoice tax type always 'No Tax' in this case and not available for changing
+    if (this.soleDetailsGST) {
+      this.listenTaxTypeChanges();
+
+      this.items.controls.forEach((itemForm: SoleInvoiceItemForm) => {
+        this.listenItemChartAccountsChanges(itemForm);
+      });
+    }
+
+    // nothing to listen if template field is not exist (edit invoice case)
+    if ((this.commonData).contains('template')) {
+      this.listenTemplateChanges();
+    }
+  }
+
+  addItem(): void {
+    const itemForm: SoleInvoiceItemForm = new SoleInvoiceItemForm(plainToClass(SoleInvoiceItem, {}));
+    // no need to listen items chart accounts changes when soleDetails.isGST === false
+    // because invoice tax type always 'No Tax' in this case and not available for changing
+    if (this.soleDetailsGST) {
+      this.listenItemChartAccountsChanges(itemForm);
+    }
+
+    this.items.push(itemForm);
+  }
+
+  removeItem(index: number): void {
+    this.items.removeAt(index);
+  }
+
+  submit(): SoleInvoice {
+    return super.submit({ ...this.getRawValue().commonData });
+  }
+
+  /**
+   * Update default values from selected invoice template
+   */
+  private listenTemplateChanges(): void {
+    this.commonData.get('template').valueChanges.subscribe((template: SoleInvoiceTemplate) => {
+      this.updateTemplateRelatedFields(template);
+    });
+  }
+
+  /**
+   * GST is not available for items when invoice.taxType === NONE
+   */
+  private listenTaxTypeChanges(): void {
+    this.commonData.get('taxType').valueChanges.subscribe((type: SoleInvoiceTaxTypeEnum) => {
+      this.items.controls.forEach((itemForm: SoleInvoiceItemForm) => {
+        const chartAccounts: ChartAccounts = itemForm.get('chartAccounts').value;
+
+        // Item GST is available when invoice.taxType !== NONE ('No Tax')
+        if (type !== SoleInvoiceTaxTypeEnum.NO_TAX && chartAccounts?.isGST ) {
+          this.enableItemGST(itemForm);
+          return;
+        }
+
+        this.disableItemGST(itemForm);
+      })
+    })
+  }
+
+  private updateTemplateRelatedFields(template: SoleInvoiceTemplate): void {
+    this.commonData.get('bankAccount').setValue(template.bankAccount);
+
+    const dateFrom: Date = this.commonData.get('dateFrom').value;
+    if (dateFrom) {
+      this.commonData.get('dateTo').setValue(new Date(dateFrom.getTime() + template.termTime));
+    }
+
+    // invoice.taxType is always 'No Tax' when soleDetails.isGST = false and not available for changing
+    if (this.soleDetailsGST) {
+      this.commonData.get('taxType').setValue(template.taxType);
+    }
+  }
+
+  /**
+   * GST availability depends on chart accounts isGST flag
+   */
+  private listenItemChartAccountsChanges(itemForm: SoleInvoiceItemForm): void {
+    itemForm.get('chartAccounts').valueChanges.subscribe((chartAccounts: ChartAccounts) => {
+      // item.isGST is available only when item.chartAccounts.isGST === true, soleDetails.isGST === true and invoice.taxType !== NONE ('No Tax')
+      if (this.soleDetailsGST && chartAccounts.isGST && !this.currentValue.isNoTax()) {
+        this.enableItemGST(itemForm);
+        return;
+      }
+
+      this.disableItemGST(itemForm);
+    });
+  }
+
+  private disableItemGST(itemForm: SoleInvoiceItemForm): void {
+    itemForm.get('isGST').setValue(false);
+    itemForm.get('isGST').disable();
+  }
+
+  /**
+   * Enable GST field for passed item form. Value is always true by default because only case when this field is enabled is
+   * when ChartAccounts.isGST === true, so we just use default value from chartAccounts.isGST
+   */
+  private enableItemGST(itemForm: SoleInvoiceItemForm): void {
+    itemForm.get('isGST').setValue(true);
+    itemForm.get('isGST').enable();
+  }
+
+  get commonData(): UntypedFormGroup {
+    return this.get('commonData') as UntypedFormGroup;
+  }
+
+  /**
+   * Rewrite abstract form getter to flat "commonData" field, which is not in the class
+   */
+  get currentValue(): SoleInvoice {
+    const formRawValue: any = this.getRawValue();
+
+    return this.createModelInstance(Object.assign(
+      {},
+      this.model,
+      { ...formRawValue.commonData, items: formRawValue.items }
+    ));
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './tax-review-filter.form';
+export * from './tax-review-filter-status.enum';

package/projects/tt-core/src/lib/forms/tax-review/tax-review-filter-status.enum.ts

@@ -0,0 +1,4 @@
+export enum TaxReviewFilterStatusEnum {
+  ACTIVE = 1,
+  INACTIVE = 2
+}

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

@@ -0,0 +1,65 @@
+import { FormControl, FormGroup } from '@angular/forms';
+import { ControlsInterface } from '../abstract.form';
+import { TaxReviewCollection } from '../../collections';
+import { IEventListener } from '../../interfaces';
+import { TaxReviewFilterStatusEnum } from './tax-review-filter-status.enum';
+import { debounceTime, distinctUntilChanged } from 'rxjs/operators';
+import { ReplaySubject } from 'rxjs';
+import { TaxReview } from '../../models/tax-review/tax-review';
+
+interface ITaxReviewFilterControls extends ControlsInterface {
+  query: FormControl<string>;
+  dateFrom: FormControl<Date>;
+  dateTo: FormControl<Date>;
+  status: FormControl<TaxReviewFilterStatusEnum>;
+}
+
+export class TaxReviewFilterForm extends FormGroup<ITaxReviewFilterControls> implements IEventListener {
+  dataChanges: ReplaySubject<TaxReview[]> = new ReplaySubject(1);
+
+  constructor(private collection: TaxReviewCollection) {
+    super({
+      query: new FormControl(),
+      dateFrom: new FormControl(),
+      dateTo: new FormControl(),
+      status: new FormControl(TaxReviewFilterStatusEnum.ACTIVE),
+    });
+
+    this.listenEvents();
+    this.updateValueAndValidity();
+  }
+
+  listenEvents() {
+    this.valueChanges.pipe(debounceTime(300), distinctUntilChanged())
+      .subscribe(() => {
+        this.filter();
+      });
+  }
+
+  filter(source?: TaxReviewCollection): void {
+    if (source) {
+      this.collection = source;
+    }
+    const value = this.value;
+    let collection = this.collection;
+    if (value.query) {
+      collection = collection.filter(taxReview =>
+        taxReview.client.fullName.toLowerCase().includes(value.query)
+        || taxReview.employee.fullName.toLowerCase().includes(value.query))
+    }
+    if (value.dateFrom) {
+      collection = collection.filter(taxReview => taxReview.createdAt >= value.dateFrom);
+    }
+    if (value.dateTo) {
+      collection = collection.filter(taxReview => taxReview.createdAt <= value.dateTo);
+    }
+    if (value.status === TaxReviewFilterStatusEnum.ACTIVE) {
+      collection = collection.filter(taxReview => taxReview.isActive());
+    }
+    if (value.status === TaxReviewFilterStatusEnum.INACTIVE) {
+      collection = collection.filter(taxReview => taxReview.isInactive());
+    }
+
+    this.dataChanges.next(collection.toArray());
+  }
+}

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

@@ -0,0 +1,18 @@
+import { AbstractForm } from '../abstract.form';
+import { AllocationRuleCondition } from '../../models/transaction/allocation-rule-condition';
+import { plainToClass } from 'class-transformer';
+import { UntypedFormControl, Validators } from '@angular/forms';
+import { RxwebValidators } from '@rxweb/reactive-form-validators';
+import { groupValidator } from '../../validators/group.validator';
+
+export class AllocationRuleConditionForm extends AbstractForm<AllocationRuleCondition> {
+  constructor(
+    condition: AllocationRuleCondition = plainToClass(AllocationRuleCondition, {})
+  ) {
+    super({
+      field: new UntypedFormControl(condition.field, Validators.required),
+      comparisonOperator: new UntypedFormControl(condition.comparisonOperator, Validators.required),
+      value: new UntypedFormControl(condition.value, Validators.required)
+    }, condition, groupValidator(RxwebValidators.unique()));
+  }
+}

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

@@ -0,0 +1,14 @@
+import { AbstractForm } from '../abstract.form';
+import { AllocationRuleTransactionMetaField } from '../../models';
+import { plainToClass } from 'class-transformer';
+import { UntypedFormControl } from '@angular/forms';
+
+export class AllocationRuleTransactionMetaFieldForm extends AbstractForm<AllocationRuleTransactionMetaField> {
+  constructor(
+    metaField: AllocationRuleTransactionMetaField = plainToClass(AllocationRuleTransactionMetaField, {})
+  ) {
+    super({
+      value: new UntypedFormControl(metaField.value)
+    }, metaField);
+  }
+}

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

@@ -0,0 +1,194 @@
+import { AbstractForm } from '../abstract.form';
+import {
+  AllocationRuleTransaction,
+  AllocationRuleTransactionMetaField,
+  ChartAccounts,
+  ChartAccountsMetaField,
+  IncomeSource,
+} from '../../models';
+import { UntypedFormArray, UntypedFormControl, UntypedFormGroup, Validators } from '@angular/forms';
+import { conditionalValidator } from '../../validators';
+import { AllocationRuleTransactionMetaFieldForm } from './allocation-rule-transaction-meta-field.form';
+import { IEventListener } from '../../interfaces';
+import { plainToClass } from 'class-transformer';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+
+/**
+ * @TODO Alex: extend transaction form(s) when transaction forms refactored
+ */
+export class AllocationRuleTransactionForm extends AbstractForm<AllocationRuleTransaction> implements IEventListener {
+  includeDisabledFields = true;
+  constructor(
+    transaction: AllocationRuleTransaction,
+    // Flag to enable transaction GST field
+    private isGST: boolean
+  ) {
+    super({
+      amount: new UntypedFormControl(transaction.amount),
+      amountPercent: new UntypedFormControl(transaction.amountPercent, Validators.required),
+      tax: new UntypedFormControl(transaction.tax, Validators.required),
+      claimPercent: new UntypedFormControl(transaction.claimPercent, [Validators.required, Validators.min(0), Validators.max(100)]),
+      chartAccounts: new UntypedFormControl(transaction.chartAccounts, Validators.required),
+      isGST: new UntypedFormControl({ value: transaction.isGST || false, disabled: !isGST }),
+      loan: new UntypedFormControl(transaction.loan),
+      incomeSource: new UntypedFormControl(transaction.incomeSource, conditionalValidator(() => transaction.chartAccounts?.isWorkIncome(), Validators.required)),
+      metaFields: new UntypedFormArray((transaction.metaFields || []).map((metaField: AllocationRuleTransactionMetaField) => new AllocationRuleTransactionMetaFieldForm(metaField))),
+      business: new UntypedFormControl(transaction.business, Validators.required),
+      property: new UntypedFormControl(transaction.property, Validators.required),
+      // Show null as default value for new transaction to avoid preselecting of not allowed tank types
+      tankType: new UntypedFormControl(transaction.id ? transaction.tankType : null, Validators.required),
+      childTransactions: new UntypedFormArray((transaction.childTransactions || []).map((childTransaction: AllocationRuleTransaction) => new UntypedFormGroup({
+        chartAccounts: new UntypedFormControl(childTransaction.chartAccounts, Validators.required),
+        amount: new UntypedFormControl(childTransaction.amount, Validators.required)
+      })))
+    }, transaction);
+
+    this.listenEvents();
+  }
+
+  /**
+   * @TODO Alex: move to abstract form, universal method getArray(arrayName)
+   */
+  get metaFieldsArray(): UntypedFormArray {
+    return this.get('metaFields') as UntypedFormArray;
+  }
+
+  get childTransactionsArray(): UntypedFormArray {
+    return this.get('childTransactions') as UntypedFormArray;
+  }
+
+  get isSplit(): boolean {
+    return this.get('amountPercent').enabled;
+  }
+
+  isPersonal(): boolean {
+    return this.get('tankType').value === TankTypeEnum.PERSONAL;
+  }
+
+  addChildTransactionForm(): void {
+    this.childTransactionsArray.push(
+      new UntypedFormGroup({
+        chartAccounts: new UntypedFormControl(null, Validators.required),
+        amount: new UntypedFormControl(null, Validators.required)
+      })
+    );
+  }
+
+  buildTransactions(transaction: AllocationRuleTransaction): AllocationRuleTransaction[] {
+    return transaction.childTransactions.map(childTransaction => Object.assign(
+      childTransaction,
+      { claimPercent: (transaction.claimPercent * childTransaction.chartAccounts?.taxablePercent) / 100 },
+    ));
+  }
+
+  submit(): AllocationRuleTransaction {
+    const data = {
+      metaFields: this.metaFieldsArray.controls.map((metaFieldForm: AllocationRuleTransactionMetaFieldForm) => metaFieldForm.submit()),
+      childTransactions: this.buildTransactions(this.currentValue)
+    };
+
+    return super.submit(data);
+  }
+
+  listenEvents(): void {
+    this.listenChartAccountsChanges();
+    this.listenTankTypeChanges();
+    this.listenIncomeSourceChanges();
+    this.listenPropertyChanges();
+  }
+
+  private listenChartAccountsChanges(): void {
+    this.get('chartAccounts').valueChanges.subscribe((chartAccounts: ChartAccounts) => {
+      this.get('incomeSource').removeValidators(Validators.required);
+
+      if (!chartAccounts) {
+        return;
+      }
+
+      this.updateClaimPercent();
+
+      // User have to select income source for work income
+      if (chartAccounts.isWorkIncome()) {
+        this.get('incomeSource').setValidators(Validators.required);
+      }
+
+      // Rebuild meta fields
+      this.metaFieldsArray.clear();
+      chartAccounts.metaFields.forEach((chartAccountsMetaField: ChartAccountsMetaField) => {
+        this.metaFieldsArray.push(
+          new AllocationRuleTransactionMetaFieldForm(
+            plainToClass(AllocationRuleTransactionMetaField, { chartAccountsMetaField })
+          )
+        );
+      });
+
+      // sole trader registered and chartAccounts is eligible for gst
+      if (this.isGST && chartAccounts.isGST) {
+        this.get('isGST').enable();
+        this.get('isGST').setValue(true);
+      } else {
+        this.get('isGST').disable();
+        this.get('isGST').setValue(false);
+      }
+    })
+  }
+
+  /**
+   * Child transaction allowance depends on tank type.
+   * Also chart accounts are different, so we just reset child transactions when tank type changed
+   */
+  private listenTankTypeChanges(): void {
+    this.get('tankType').valueChanges.subscribe(() => {
+      this.get('chartAccounts').reset();
+      this.get('property').reset();
+      this.get('business').reset();
+      this.childTransactionsArray.clear();
+    })
+  }
+
+  /**
+   * Set tax automatically when salary income source selected
+   */
+  private listenIncomeSourceChanges(): void {
+    this.get('incomeSource').valueChanges.subscribe((incomeSource?: IncomeSource) => {
+      if (!incomeSource) {
+        this.get('tax').setValue(0);
+
+        return;
+      }
+
+      // prefill salary tax with its income source forecast in case if we have at least 1 salaryForecasts
+      if (incomeSource instanceof IncomeSource && incomeSource.isWorkIncome() && !this.get('tax').value
+        && incomeSource.salaryForecasts.length) {
+        this.get('tax').setValue(incomeSource.salaryForecasts[0].taxWithheld);
+      }
+    });
+  }
+
+
+  private listenPropertyChanges(): void {
+    this.get('property').valueChanges.subscribe(() => {
+      this.updateClaimPercent();
+    });
+  }
+
+  /**
+   * Update claim percent value and state depends on business logic
+   */
+  private updateClaimPercent(): void {
+    const claimPercentControl: UntypedFormControl = this.get('claimPercent') as UntypedFormControl;
+
+    // claim percent is changeable only for work and sole expenses except vehicle and personal
+    claimPercentControl.disable();
+
+    if (!this.currentValue.chartAccounts) {
+      return;
+    }
+
+    if (this.currentValue.chartAccounts.isClaimPercentEditable()) {
+      claimPercentControl.enable();
+    }
+
+    claimPercentControl.setValue(this.currentValue.calculateClaimPercent());
+  }
+}