taxtank 0.1.0

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

@@ -0,0 +1,234 @@
+import { AbstractForm } from '../abstract.form';
+import { AllocationRule, AllocationRuleTransaction, CHART_ACCOUNTS_CATEGORIES, ChartAccounts } from '../../models';
+import { plainToClass } from 'class-transformer';
+import { FormArray, FormControl, Validators } from '@angular/forms';
+import { AllocationRuleCondition } from '../../models/transaction/allocation-rule-condition';
+import { AllocationRuleConditionForm } from './allocation-rule-condition.form';
+import { AllocationRuleTransactionForm } from './allocation-rule-transaction.form';
+import { AllocationRuleTypeEnum, ChartAccountsCategoryEnum } from '../../db/Enums';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import { IEventListener } from '../../interfaces';
+import intersection from 'lodash/intersection';
+import { RxwebValidators } from '@rxweb/reactive-form-validators';
+import { AllocationRuleCollection } from '../../collections';
+
+/**
+ * @TODO move aux methods like isSplittable/isTaxFieldHidden/etc (used in view with ngIf) to properties to improve perf
+ */
+export class AllocationRuleForm extends AbstractForm<AllocationRule> implements IEventListener {
+  chartAccountsCategories: ChartAccountsCategoryEnum[];
+
+  constructor(rule: AllocationRule, rules: AllocationRuleCollection, private isGST: boolean) {
+    super({
+      type: new FormControl(rule.type, Validators.required),
+      name: new FormControl(rule.name, [
+        Validators.required,
+        RxwebValidators.noneOf({ matchValues: rules.remove([rule]).mapBy('name') })
+      ]),
+      conditionOperator: new FormControl(rule.conditionOperator, Validators.required),
+      conditions: new FormArray(
+        (rule.conditions || [plainToClass(AllocationRuleCondition, {})])
+          .map((condition: AllocationRuleCondition) => new AllocationRuleConditionForm(condition))
+      ),
+      transaction: new AllocationRuleTransactionForm(rule.transaction || plainToClass(AllocationRuleTransaction, {}), isGST),
+      transferBankAccount: new FormControl(rule.transferBankAccount, Validators.required),
+      autoAllocate: new FormControl(rule.autoAllocate || false, Validators.required),
+    }, rule);
+
+    this.listenEvents();
+    this.setupFieldsByType(rule.type);
+    this.setupFieldsByTankType(rule.transaction?.tankType);
+    this.updateChartAccountsCategories();
+
+    if (!this.transactionFormGroup.get('chartAccounts').value?.isClaimPercentEditable()) {
+      this.transactionFormGroup.get('claimPercent').disable();
+    }
+
+    // Disable transaction amount field when transaction has no amount (non-split)
+    if (!rule.transaction?.isSplit()) {
+      this.transactionFormGroup.get(['amountPercent']).disable();
+    }
+  }
+
+  get conditionsArray(): FormArray {
+    return this.get('conditions') as FormArray;
+  }
+
+  get childTransactionsArray(): FormArray {
+    return this.transactionFormGroup.get('childTransactions') as FormArray;
+  }
+
+  get transactionFormGroup(): AllocationRuleTransactionForm {
+    return this.get('transaction') as AllocationRuleTransactionForm;
+  }
+
+  addConditionForm(): void {
+    this.conditionsArray.push(new AllocationRuleConditionForm());
+  }
+
+  isTaxFieldHidden(): boolean {
+    const chartAccounts: ChartAccounts = this.transactionFormGroup.get('chartAccounts').value;
+
+    return !chartAccounts || !chartAccounts.hasTaxField();
+  }
+
+  /**
+   * TODO Alex: disable sole tank in form control when income selected
+   */
+  isTransactionFieldsHidden(): boolean {
+    return this.transactionFormGroup.get('tankType').value === null || this.currentValue.isSoleIncome();
+  }
+
+  submit(): AllocationRule {
+    const data = {
+      conditions: this.conditionsArray.controls.map((conditionForm: AllocationRuleConditionForm) => conditionForm.submit()),
+      transaction: null,
+    };
+
+    if (!this.currentValue.isTransfer()) {
+      data.transaction = this.transactionFormGroup.submit();
+    }
+
+    return super.submit(data);
+  }
+
+  isSplittable(): boolean {
+    return this.get('type').value === AllocationRuleTypeEnum.EXPENSE || this.transactionFormGroup.isPersonal();
+  }
+
+  listenEvents(): void {
+    this.listenTankTypeChanges();
+    this.listenTypeChanges();
+  }
+
+  private listenTypeChanges(): void {
+    this.get('type').valueChanges.subscribe((type: AllocationRuleTypeEnum) => {
+      this.setupFieldsByType(type);
+      this.updateChartAccountsCategories();
+
+      // we have different fields for different types
+      // @TODO separated reinit method if we need it anywhere else
+      this.transactionFormGroup.setValue(
+        new AllocationRuleTransactionForm(plainToClass(AllocationRuleTransaction, {}), this.isGST).getRawValue()
+      );
+    });
+  }
+
+  private listenTankTypeChanges(): void {
+    this.transactionFormGroup.get('tankType').valueChanges.subscribe((tankType: TankTypeEnum) => {
+      this.updateChartAccountsCategories();
+      this.setupFieldsByTankType(tankType);
+    });
+  }
+
+  /**
+   * Update list of chart accounts categories allowed for transaction
+   * Depends on transaction type and tank type
+   */
+  private updateChartAccountsCategories(): void {
+    // We use unique one Chart Accounts for transfer
+    if (this.currentValue.isTransfer()) {
+      this.chartAccountsCategories = null;
+      return;
+    }
+
+    const excludedCategories: ChartAccountsCategoryEnum[] = [...CHART_ACCOUNTS_CATEGORIES.depreciation];
+
+    this.chartAccountsCategories = intersection(CHART_ACCOUNTS_CATEGORIES[this.currentValue.typeLabel], CHART_ACCOUNTS_CATEGORIES[this.tankTypeLabel])
+      .filter((category: ChartAccountsCategoryEnum) => !excludedCategories.includes(category));
+  }
+
+  get tankTypeLabel(): string {
+    switch (this.transactionFormGroup.get('tankType').value) {
+      case TankTypeEnum.WORK:
+        return 'work';
+
+      case TankTypeEnum.PROPERTY:
+        return 'property';
+
+      case TankTypeEnum.SOLE:
+        return 'sole';
+
+      case TankTypeEnum.HOLDING:
+        return 'holding';
+
+      default:
+        return 'personal';
+    }
+  }
+
+  private setupFieldsByType(type: AllocationRuleTypeEnum): void {
+    switch (type) {
+      case AllocationRuleTypeEnum.EXPENSE:
+      case AllocationRuleTypeEnum.INCOME:
+        this.get('transaction').enable({ emitEvent: false });
+        this.get('transferBankAccount').disable({ emitEvent: false });
+
+        // disable transaction amount field when value is empty
+        // disable manually because code above enables this field
+        if (!this.transactionFormGroup.get(['amountPercent']).value) {
+          this.transactionFormGroup.get(['amountPercent']).disable();
+        }
+        break;
+      case AllocationRuleTypeEnum.TRANSFER:
+        this.get('transaction').disable({ emitEvent: false });
+        this.get('transferBankAccount').enable({ emitEvent: false });
+        return;
+    }
+  }
+
+  private setupFieldsByTankType(tankType: TankTypeEnum): void {
+    // First disable tankType-related fields, second enable for selected tank type
+    this.transactionFormGroup.get('property').disable({ emitEvent: false });
+    this.transactionFormGroup.get('business').disable({ emitEvent: false });
+    this.transactionFormGroup.get('incomeSource').disable({ emitEvent: false });
+
+    switch (tankType) {
+      case TankTypeEnum.WORK:
+        this.transactionFormGroup.get('incomeSource').enable({ emitEvent: false });
+        break;
+      case TankTypeEnum.PROPERTY:
+        this.transactionFormGroup.get('property').enable({ emitEvent: false });
+        break;
+      case TankTypeEnum.SOLE:
+        this.transactionFormGroup.get('business').enable({ emitEvent: false });
+        break;
+    }
+  }
+
+  isIncome(): boolean {
+    return this.get('type').value === AllocationRuleTypeEnum.INCOME;
+  }
+
+  isExpense(): boolean {
+    return this.get('type').value === AllocationRuleTypeEnum.EXPENSE;
+  }
+
+  isTransfer(): boolean {
+    return this.get('type').value === AllocationRuleTypeEnum.TRANSFER;
+  }
+
+  isPropertyTank(): boolean {
+    return this.get('transaction').get('tankType').value === TankTypeEnum.PROPERTY;
+  }
+
+  isWorkTank(): boolean {
+    return this.get('transaction').get('tankType').value === TankTypeEnum.WORK;
+  }
+
+  isSoleTank(): boolean {
+    return this.get('transaction').get('tankType').value === TankTypeEnum.SOLE;
+  }
+
+  isPropertyIncome(): boolean {
+    return this.isIncome() && this.isPropertyTank();
+  }
+
+  isWorkIncome(): boolean {
+    return this.isIncome() && this.isWorkTank();
+  }
+
+  isSoleIncome(): boolean {
+    return this.isIncome() && this.isSoleTank();
+  }
+}

package/projects/tt-core/src/lib/forms/transaction/holding/holding-expense.form.ts

@@ -0,0 +1,14 @@
+import { Transaction, TransactionAllocation } from '../../../models';
+import { AbstractControl } from '@angular/forms';
+import { TransactionForm } from '../transaction.form';
+
+export class HoldingExpenseForm extends TransactionForm {
+  constructor(
+    transaction: Transaction,
+    registeredForGst: boolean,
+    allocations: TransactionAllocation[],
+    controls: { [key: string]: AbstractControl } = {}
+  ) {
+    super(transaction, registeredForGst, allocations, controls);
+  }
+}

package/projects/tt-core/src/lib/forms/transaction/holding/holding-income.form.ts

@@ -0,0 +1,76 @@
+import { ChartAccounts, Transaction, TransactionAllocation } from '../../../models';
+import { AbstractControl, FormArray, FormGroup, UntypedFormControl, Validators } from '@angular/forms';
+import { IEventListener } from '../../../interfaces';
+import { autocompleteValidator, conditionalValidator, matchSumValidator } from '../../../validators';
+import { TransactionOperationEnum } from '../../../db/Enums/transaction-operation.enum';
+import { WorkTransactionForm } from '../work/work-transaction.form';
+import { ChartAccountsMetaFieldListEnum } from '../../../db/Enums';
+
+export class HoldingIncomeForm extends WorkTransactionForm implements IEventListener {
+  /**
+   * @TODO vik partial copyPast from workIncomeForm
+   */
+  constructor(transaction: Transaction, registeredForGst: boolean, allocations: TransactionAllocation[]) {
+    super(transaction, registeredForGst, allocations, {
+      tax: new UntypedFormControl(transaction.tax, Validators.required),
+      incomeSource: new UntypedFormControl(transaction.incomeSource, [Validators.required, autocompleteValidator()]),
+    });
+
+    // transactionAmount=frankedAmount + unfrankedAmount
+    this.get('amount').setValidators([Validators.required, conditionalValidator(
+      (): boolean => this.get('chartAccounts').value && this.get('chartAccounts').value.isDividends(),
+      matchSumValidator(this.getAmountComponents, 'The Franked and Unfranked amounts entered do not equal the total Amount received. Please check and try again.')
+    )]);
+
+    // forbid to edit some fields for allocated transaction
+    if (allocations.length) {
+      this.get('chartAccounts').disable();
+    }
+    this.get('transactions').disable();
+    // amount changes are not available for transactions with allocations or during allocate process
+    if (allocations.length || transaction.operation === TransactionOperationEnum.ALLOCATE) {
+      this.get('amount').disable();
+    }
+  }
+
+  /**
+   * metafields components of transactionAmount
+   */
+  getAmountComponents(): AbstractControl[] {
+    return this.metaFields.controls.filter((formGroup: FormGroup) =>
+      [ChartAccountsMetaFieldListEnum.FRANKED, ChartAccountsMetaFieldListEnum.UNFRANKED].includes(formGroup.get('chartAccountsMetaField').value.id)
+    ).map(formGroup => formGroup.get('value'));
+  }
+
+  listenEvents(): void {
+    this.listenChartAccountsChanges();
+  }
+
+  get metaFields(): FormArray {
+    return this.get('metaFields') as FormArray;
+  }
+
+  get frankingCredit(): AbstractControl {
+    return this.metaFields.controls.find(
+      (group: FormGroup) => group.get('chartAccountsMetaField').value.isFrankingCredit()
+    )?.get('value');
+  }
+
+  /**
+   * @TODO Alex/Vik: probably we need some database changes related to metafields.
+   * Now we have the following custom metafields behaviour:
+   * - % of share field should be 100 by default (now handled by WorkTransactionForm)
+   * - Franked and Unfranked sum should be equal to transaction amount
+   * - Franked field has custom message (mat-hint) (now handled by HoldingIncomeFormComponent)
+   * - some metafields required, but some not (now handled by HoldingIncomeForm)
+   */
+  private listenChartAccountsChanges(): void {
+    this.get('chartAccounts').valueChanges.subscribe((chartAccounts: ChartAccounts) => {
+      if (!chartAccounts.isDividends()) {
+        return;
+      }
+
+      this.frankingCredit.setValidators(Validators.required);
+    })
+  }
+}

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

@@ -0,0 +1,10 @@
+export * from './allocation-rule.form';
+export * from './transaction-base.form';
+export * from './transaction.form';
+export * from './sole/sole-income.form';
+export * from './work/work-income.form';
+export * from './work/work-expense.form';
+export * from './holding/holding-income.form';
+export * from './holding/holding-expense.form';
+export * from './transaction-base-filter.form';
+export * from './transaction-base-filter';

package/projects/tt-core/src/lib/forms/transaction/messages.enum.ts

@@ -0,0 +1,3 @@
+export enum MessagesEnum {
+  DATE_VALIDATION_ERROR = 'The transaction date is before the ownership date, please update the date to confirm'
+}

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

@@ -0,0 +1,22 @@
+import { Transaction, TransactionAllocation } from '../../../models';
+import { TransactionOperationEnum } from '../../../db/Enums/transaction-operation.enum';
+import { SoleTransactionForm } from './sole-transaction.form';
+
+export class SoleIncomeForm extends SoleTransactionForm {
+  constructor(transaction: Transaction, allocations: TransactionAllocation[], registeredForGst: boolean) {
+
+    super(transaction, registeredForGst, allocations, {});
+
+    // @TODO Alex: copypasted from work income form
+
+    // forbid to edit some fields for allocated transaction
+    if (allocations.length) {
+      this.get('chartAccounts').disable();
+    }
+
+    // amount changes are not available for transactions with allocations or during allocate process
+    if (allocations.length || transaction.operation === TransactionOperationEnum.ALLOCATE) {
+      this.get('amount').disable();
+    }
+  }
+}

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

@@ -0,0 +1,14 @@
+import { AbstractControl } from '@angular/forms';
+import { Transaction, TransactionAllocation } from '../../../models';
+import { TransactionForm } from '../transaction.form';
+
+export class SoleTransactionForm extends TransactionForm {
+  constructor(
+    transaction: Transaction,
+    registeredForGst: boolean,
+    allocations: TransactionAllocation[],
+    controls: { [key: string]: AbstractControl } = {}
+  ) {
+    super(transaction, registeredForGst, allocations, Object.assign(controls, {}));
+  }
+}

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

@@ -0,0 +1,100 @@
+import { FormControl, FormGroup } from '@angular/forms';
+import { ControlsInterface } from '../abstract.form';
+import { BudgetRuleCollection, Collection } from '../../collections';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import { Property, SoleBusiness } from '../../models';
+import { IEventListener } from '../../interfaces';
+import { TransactionBase } from '../../db/Models';
+import { TransactionBaseFilter } from './transaction-base-filter';
+import { plainToClass } from 'class-transformer';
+
+interface ITransactionBaseFilterControls extends ControlsInterface {
+  tankType: FormControl<TankTypeEnum>;
+  business: FormControl<SoleBusiness>;
+  properties: FormControl<Property[]>;
+  dateRange: FormControl<Date[]>;
+  chartAccounts: FormControl<string>;
+}
+
+export class TransactionBaseFilterForm extends FormGroup<ITransactionBaseFilterControls> implements IEventListener {
+  constructor(model = plainToClass(TransactionBaseFilter, {})) {
+    super({
+      tankType: new FormControl(model.tankType),
+      business: new FormControl({ value: model.business, disabled: true }),
+      properties: new FormControl({ value: model.properties, disabled: true }),
+      dateRange: new FormControl(model.dateRange),
+      chartAccounts: new FormControl(model.chartAccounts),
+    });
+
+    this.listenEvents();
+  }
+
+  listenEvents(): void {
+    this.get('tankType').valueChanges.subscribe(tankType => {
+      if (tankType === TankTypeEnum.SOLE) {
+        this.get('business').enable();
+      } else {
+        this.get('business').disable();
+      }
+
+      if (tankType === TankTypeEnum.PROPERTY) {
+        this.get('properties').enable();
+      } else {
+        this.get('properties').disable();
+      }
+    });
+  }
+
+  filter<ModelClass extends TransactionBase, CollectionClass extends Collection<ModelClass>>(collection: CollectionClass): CollectionClass {
+    if (!collection.length) {
+      return collection;
+    }
+    const value = this.value;
+    const [dateFrom, dateTo] = value.dateRange || [];
+
+    if (dateFrom) {
+      collection = collection.filter(transaction => transaction.date >= dateFrom);
+    }
+    if (dateTo) {
+      collection = collection.filter(transaction => transaction.date <= dateTo);
+    }
+    if (value.tankType) {
+      collection = collection.filterBy('tankType', value.tankType);
+    }
+    if (value.business) {
+      collection = collection.filterBy('business.id', value.business.id);
+    }
+    if (value.properties?.length) {
+      collection = collection.filterBy('property.id', value.properties.map(property => property.id));
+    }
+    if (value.chartAccounts) {
+      const searchQuery: string = value.chartAccounts.toLowerCase().trim();
+      collection = collection.filter(transaction => transaction.chartAccounts.name.toLowerCase().includes(searchQuery));
+    }
+
+    return collection;
+  }
+
+  filterBudgetRules(rules: BudgetRuleCollection): BudgetRuleCollection {
+    const value = this.value;
+    const [dateFrom, dateTo] = value.dateRange || [];
+
+    if (value.tankType) {
+      rules = rules.filterBy('chartAccounts.tankType', value.tankType);
+    }
+    if (value.chartAccounts) {
+      rules = rules.getByChartAccountsName(value.chartAccounts);
+    }
+    if (dateFrom || dateTo) {
+      rules = rules.getByDate(dateFrom, dateTo);
+    }
+    if (value.properties?.length) {
+      rules = rules.filterByProperties(value.properties);
+    }
+    if (value.business) {
+      rules = rules.filterBy('business.id', value.business.id);
+    }
+
+    return rules;
+  }
+}

package/projects/tt-core/src/lib/forms/transaction/transaction-base-filter.ts

@@ -0,0 +1,10 @@
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import { Property, SoleBusiness } from '../../models';
+
+export class TransactionBaseFilter {
+  tankType: TankTypeEnum;
+  business: SoleBusiness;
+  properties: Property[];
+  dateRange: Date[];
+  chartAccounts: string;
+}

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

@@ -0,0 +1,117 @@
+import { AbstractControl, UntypedFormControl, Validators } from '@angular/forms';
+import { autocompleteValidator } from '../../validators';
+import { AbstractForm } from '../abstract.form';
+import { TransactionBase } from '../../db/Models';
+import { ChartAccountsListEnum } from '../../db/Enums';
+import { ChartAccounts } from '../../models';
+import { FormValidationsEnum } from '../form-validations.enum';
+
+/**
+ * @TODO refactor, move specific fields like property in separated forms
+ * @TODO remove useless getters
+ */
+export class TransactionBaseForm<Model extends TransactionBase> extends AbstractForm<Model> {
+  registeredForGst: boolean;
+
+  constructor(transaction: Model, registeredForGst: boolean, controls: { [key: string]: AbstractControl } = {}) {
+    super(
+      Object.assign({
+        chartAccounts: new UntypedFormControl(transaction.chartAccounts, [Validators.required, autocompleteValidator()]),
+        claimPercent: new UntypedFormControl(
+          { value: transaction.claimPercent, disabled: true },
+          [Validators.required, Validators.min(0), Validators.max(100)]
+        ),
+        amount: new UntypedFormControl(transaction.amount, Validators.required),
+        amountWithGST: new UntypedFormControl(transaction.amountWithGst, Validators.required),
+        isGST: new UntypedFormControl({ value: transaction.isGST, disabled: !transaction.chartAccounts?.isGST || !registeredForGst }),
+        gstAmount: new UntypedFormControl({ value: transaction.gstAmount, disabled: true }, Validators.required),
+        date: new UntypedFormControl(transaction.date, [Validators.required]),
+        description: new UntypedFormControl(transaction.description, Validators.maxLength(FormValidationsEnum.TEXT_MAX_LENGTH)),
+        file: new UntypedFormControl(transaction.file),
+        property: new UntypedFormControl({ value: transaction.property, disabled: transaction.chartAccounts }),
+      }, controls),
+      transaction
+    );
+
+    this.registeredForGst = registeredForGst;
+    this.watchChartAccounts();
+    this.watchAmountWithGST();
+    this.watchIsGst();
+  }
+
+  private watchIsGst(): void {
+    this.get('isGST').valueChanges.subscribe((isGST: boolean) => {
+      this.updateAmount();
+      this.updateGstAmount();
+    });
+  }
+
+  private watchAmountWithGST(): void {
+    this.get('amountWithGST').valueChanges.subscribe(() => {
+      this.updateAmount();
+      this.updateGstAmount();
+    });
+  }
+
+  watchChartAccounts(): void {
+    this.get('chartAccounts').valueChanges.subscribe((chartAccounts: ChartAccounts) => {
+      // recalculate claim percent for selected chart accounts
+      this.updateClaimPercent(chartAccounts);
+      if (!this.isGstApplicable()) {
+        return;
+      }
+      // update gst if applicable
+      if (chartAccounts.isGST) {
+        this.get('isGST').enable();
+        this.get('isGST').patchValue(true);
+      } else {
+        this.get('isGST').patchValue(false);
+        this.get('isGST').disable();
+      }
+    });
+  }
+
+  private updateGstAmount(): void {
+    this.get('gstAmount').patchValue(this.amountWithGST - this.amount);
+  }
+
+  private updateAmount(): void {
+    this.patchField('amount', this.isGST ? this.amountWithGST / ChartAccounts.GSTCoefficient : this.amountWithGST);
+  }
+
+  private isGstApplicable(): boolean {
+    return !!this.registeredForGst && !!this.model.business;
+  }
+
+  private get amount(): number {
+    return this.get('amount').value;
+  }
+
+  private get amountWithGST(): number {
+    return this.get('amountWithGST').value;
+  }
+
+  private get isGST(): number {
+    return this.get('isGST').value;
+  }
+
+  /**
+   * propertyClaimPercent for propertyExpense (except platform fees, which already include claimPercent),
+   * taxablePercent for others
+   * can be adjusted only for property/sole expenses
+   */
+  private updateClaimPercent(chartAccounts: ChartAccounts): void {
+    if (chartAccounts.isClaimPercentEditable()) {
+      this.get('claimPercent').enable();
+    } else {
+      this.get('claimPercent').disable();
+    }
+
+    // property claim (ownership% x shared%) for property expenses, taxable percent for others
+    let claimPercent = chartAccounts.taxablePercent;
+    if (chartAccounts.isPropertyExpense() && chartAccounts.id !== ChartAccountsListEnum.PLATFORM_FEES) {
+      claimPercent *= this.get('property').value.claimCoefficient;
+    }
+    this.get('claimPercent').setValue(claimPercent);
+  }
+}