taxtank-core 0.32.89 → 0.33.2

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

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

package/esm2022/src/lib/forms/transaction/allocation-rule-condition.form.mjs

@@ -0,0 +1,16 @@
+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 {
+    constructor(condition = 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()));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/forms/transaction/allocation-rule-transaction-meta-field.form.mjs

@@ -0,0 +1,12 @@
+import { AbstractForm } from '../abstract.form';
+import { AllocationRuleTransactionMetaField } from '../../models';
+import { plainToClass } from 'class-transformer';
+import { UntypedFormControl } from '@angular/forms';
+export class AllocationRuleTransactionMetaFieldForm extends AbstractForm {
+    constructor(metaField = plainToClass(AllocationRuleTransactionMetaField, {})) {
+        super({
+            value: new UntypedFormControl(metaField.value)
+        }, metaField);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsb2NhdGlvbi1ydWxlLXRyYW5zYWN0aW9uLW1ldGEtZmllbGQuZm9ybS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9mb3Jtcy90cmFuc2FjdGlvbi9hbGxvY2F0aW9uLXJ1bGUtdHJhbnNhY3Rpb24tbWV0YS1maWVsZC5mb3JtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNoRCxPQUFPLEVBQUUsa0NBQWtDLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFDbEUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRXBELE1BQU0sT0FBTyxzQ0FBdUMsU0FBUSxZQUFnRDtJQUMxRyxZQUNFLFlBQWdELFlBQVksQ0FBQyxrQ0FBa0MsRUFBRSxFQUFFLENBQUM7UUFFcEcsS0FBSyxDQUFDO1lBQ0osS0FBSyxFQUFFLElBQUksa0JBQWtCLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQztTQUMvQyxFQUFFLFNBQVMsQ0FBQyxDQUFDO0lBQ2hCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFic3RyYWN0Rm9ybSB9IGZyb20gJy4uL2Fic3RyYWN0LmZvcm0nO1xuaW1wb3J0IHsgQWxsb2NhdGlvblJ1bGVUcmFuc2FjdGlvbk1ldGFGaWVsZCB9IGZyb20gJy4uLy4uL21vZGVscyc7XG5pbXBvcnQgeyBwbGFpblRvQ2xhc3MgfSBmcm9tICdjbGFzcy10cmFuc2Zvcm1lcic7XG5pbXBvcnQgeyBVbnR5cGVkRm9ybUNvbnRyb2wgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5cbmV4cG9ydCBjbGFzcyBBbGxvY2F0aW9uUnVsZVRyYW5zYWN0aW9uTWV0YUZpZWxkRm9ybSBleHRlbmRzIEFic3RyYWN0Rm9ybTxBbGxvY2F0aW9uUnVsZVRyYW5zYWN0aW9uTWV0YUZpZWxkPiB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIG1ldGFGaWVsZDogQWxsb2NhdGlvblJ1bGVUcmFuc2FjdGlvbk1ldGFGaWVsZCA9IHBsYWluVG9DbGFzcyhBbGxvY2F0aW9uUnVsZVRyYW5zYWN0aW9uTWV0YUZpZWxkLCB7fSlcbiAgKSB7XG4gICAgc3VwZXIoe1xuICAgICAgdmFsdWU6IG5ldyBVbnR5cGVkRm9ybUNvbnRyb2wobWV0YUZpZWxkLnZhbHVlKVxuICAgIH0sIG1ldGFGaWVsZCk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/src/lib/forms/transaction/allocation-rule-transaction.form.mjs

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

package/esm2022/src/lib/forms/transaction/allocation-rule.form.mjs

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