taxtank-core 0.30.18 → 0.30.19

package/fesm2020/taxtank-core.mjs

@@ -18,8 +18,8 @@ import uniqBy from 'lodash/uniqBy';
 import differenceBy from 'lodash/differenceBy';
 import moment from 'moment';
 import { DateRange } from 'moment-range';
-import { Validators, UntypedFormGroup, UntypedFormControl, UntypedFormArray, FormArray, FormGroup, FormControl } from '@angular/forms';
 import intersection from 'lodash/intersection';
+import { Validators, UntypedFormGroup, UntypedFormControl, UntypedFormArray, FormArray, FormGroup, FormControl } from '@angular/forms';
 import compact from 'lodash/compact';
 import concat from 'lodash/concat';
 import cloneDeep$1 from 'lodash/cloneDeep';
@@ -3024,6 +3024,9 @@ class ChartAccounts extends ChartAccounts$1 {
     isTaxable() {
         return !this.isNRAS() && this.isWorkIncome();
     }
+    isTransfer() {
+        return this.id === ChartAccountsListEnum.TRANSFER;
+    }
 }
 /**
  * Australian GST percent value (VAT)
@@ -3063,6 +3066,36 @@ let AllocationRuleCondition$1 = class AllocationRuleCondition extends AbstractMo
 };
 
 class AllocationRuleCondition extends AllocationRuleCondition$1 {
+    matchBankTransaction(bankTransaction) {
+        return this.field === AllocationRuleConditionFieldEnum.AMOUNT ? this.matchBankTransactionByAmount(bankTransaction) : this.matchBankTransactionByDescription(bankTransaction);
+    }
+    matchBankTransactionByAmount(bankTransaction) {
+        // Amount should be compared as number
+        const value = +this.value;
+        switch (this.comparisonOperator) {
+            case AllocationRuleConditionComparisonOperatorEnum.EQUALS:
+                return bankTransaction.amount === value;
+            case AllocationRuleConditionComparisonOperatorEnum.EQUALS_OR_LESS:
+                return bankTransaction.amount <= value;
+            case AllocationRuleConditionComparisonOperatorEnum.EQUALS_OR_GREATER:
+                return bankTransaction.amount >= value;
+        }
+        return false;
+    }
+    matchBankTransactionByDescription(bankTransaction) {
+        // Prepare value and description for comparison
+        const description = bankTransaction.description.toLowerCase();
+        const value = this.value.trim().toLowerCase();
+        switch (this.comparisonOperator) {
+            case AllocationRuleConditionComparisonOperatorEnum.EQUALS:
+                return description === value;
+            case AllocationRuleConditionComparisonOperatorEnum.CONTAINS:
+                return description.includes(value);
+            case AllocationRuleConditionComparisonOperatorEnum.STARTS:
+                return description.startsWith(value);
+        }
+        return false;
+    }
 }
 
 let AllocationRuleTransaction$1 = class AllocationRuleTransaction extends TransactionBase {
@@ -3239,6 +3272,12 @@ __decorate([
     Type(() => Date)
 ], IncomeSource.prototype, "dateTo", void 0);
 
+var TransactionSourceEnum;
+(function (TransactionSourceEnum) {
+    TransactionSourceEnum[TransactionSourceEnum["CASH"] = 1] = "CASH";
+    TransactionSourceEnum[TransactionSourceEnum["BANK_TRANSACTION"] = 2] = "BANK_TRANSACTION";
+})(TransactionSourceEnum || (TransactionSourceEnum = {}));
+
 class AllocationRuleTransaction extends AllocationRuleTransaction$1 {
     calculateClaimPercent() {
         if (!this.chartAccounts) {
@@ -3253,26 +3292,63 @@ class AllocationRuleTransaction extends AllocationRuleTransaction$1 {
         }
         return claimPercent;
     }
+    /**
+     * Create Transaction instance based on passed bank transaction and rule transaction
+     */
+    toTransaction(bankTransaction) {
+        return plainToClass(Transaction, {
+            amount: bankTransaction.amount,
+            description: bankTransaction.description,
+            type: bankTransaction.type,
+            date: bankTransaction.date,
+            source: TransactionSourceEnum.BANK_TRANSACTION,
+            tax: this.tax,
+            claimPercent: this.claimPercent,
+            isGST: this.isGST,
+            chartAccounts: this.chartAccounts,
+            property: this.property,
+            loan: this.loan,
+            incomeSource: this.incomeSource,
+            metaFields: this.metaFields,
+            parentTransaction: this.parentTransaction,
+            childTransactions: this.childTransactions,
+            business: this.business,
+            operation: TransactionOperationEnum.ALLOCATE,
+            allocations: [TransactionAllocation.create(bankTransaction.amount, bankTransaction)],
+        });
+    }
 }
 __decorate([
-    Type(() => ChartAccounts),
-    Transform(({ value }) => { return { id: value.id }; }, { toPlainOnly: true })
+    Type(() => ChartAccounts)
+    // @TODO Alex: Create custom decorator for this transform
+    ,
+    Transform(({ value }) => {
+        return { id: value.id };
+    }, { toPlainOnly: true })
 ], AllocationRuleTransaction.prototype, "chartAccounts", void 0);
 __decorate([
     Type(() => Property),
-    Transform(({ value }) => { return value ? { id: value.id } : null; }, { toPlainOnly: true })
+    Transform(({ value }) => {
+        return value ? { id: value.id } : null;
+    }, { toPlainOnly: true })
 ], AllocationRuleTransaction.prototype, "property", void 0);
 __decorate([
     Type(() => Loan),
-    Transform(({ value }) => { return value ? { id: value.id } : null; }, { toPlainOnly: true })
+    Transform(({ value }) => {
+        return value ? { id: value.id } : null;
+    }, { toPlainOnly: true })
 ], AllocationRuleTransaction.prototype, "loan", void 0);
 __decorate([
     Type(() => IncomeSource),
-    Transform(({ value }) => { return value ? { id: value.id } : null; }, { toPlainOnly: true })
+    Transform(({ value }) => {
+        return value ? { id: value.id } : null;
+    }, { toPlainOnly: true })
 ], AllocationRuleTransaction.prototype, "incomeSource", void 0);
 __decorate([
     Type(() => SoleBusiness),
-    Transform(({ value }) => { return value ? { id: value.id } : null; }, { toPlainOnly: true })
+    Transform(({ value }) => {
+        return value ? { id: value.id } : null;
+    }, { toPlainOnly: true })
 ], AllocationRuleTransaction.prototype, "business", void 0);
 __decorate([
     Type(() => AllocationRuleTransactionMetaField)
@@ -3342,6 +3418,65 @@ class AllocationRule extends AllocationRule$1 {
     isSoleIncome() {
         return this.isIncome() && this.isSoleTank();
     }
+    /**
+     * @TODO Alex: move to collection
+     */
+    matchBankTransaction(bankTransaction) {
+        return this.conditionOperator === AllocationRuleConditionOperatorEnum.AND ? this.checkAnd(bankTransaction) : this.checkOr(bankTransaction);
+    }
+    createTransaction(bankTransaction) {
+        if (this.isTransfer()) {
+            const transaction = bankTransaction.toTransaction();
+            transaction.operation = TransactionOperationEnum.TRANSFER;
+            transaction.chartAccounts = plainToClass(ChartAccounts, { id: ChartAccountsListEnum.TRANSFER });
+            return transaction;
+        }
+        return this.transaction.toTransaction(bankTransaction);
+    }
+    /**
+     * Rule is matched when all conditions matched
+     */
+    checkAnd(bankTransaction) {
+        for (let condition of this.conditions) {
+            if (!condition.matchBankTransaction(bankTransaction)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Rule is matched when at least one condition matched
+     */
+    checkOr(bankTransaction) {
+        for (let condition of this.conditions) {
+            if (condition.matchBankTransaction(bankTransaction)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Create allocation rule based on bank transaction (just prefill rule fields with bank transaction values)
+     */
+    static fromBankTransaction(bankTransaction) {
+        return plainToClass(AllocationRule, {
+            type: bankTransaction.isDebit() ? AllocationRuleTypeEnum.EXPENSE : AllocationRuleTypeEnum.INCOME,
+            bankAccount: bankTransaction.bankAccount,
+            conditionOperator: AllocationRuleConditionOperatorEnum.AND,
+            conditions: [
+                plainToClass(AllocationRuleCondition, {
+                    field: AllocationRuleConditionFieldEnum.AMOUNT,
+                    comparisonOperator: AllocationRuleConditionComparisonOperatorEnum.EQUALS,
+                    value: bankTransaction.amount
+                }),
+                plainToClass(AllocationRuleCondition, {
+                    field: AllocationRuleConditionFieldEnum.DESCRIPTION,
+                    comparisonOperator: AllocationRuleConditionComparisonOperatorEnum.EQUALS,
+                    value: bankTransaction.description
+                })
+            ]
+        });
+    }
 }
 __decorate([
     Type(() => BankAccount),
@@ -3372,12 +3507,6 @@ var TransactionTypeEnum;
     TransactionTypeEnum[TransactionTypeEnum["CREDIT"] = 2] = "CREDIT";
 })(TransactionTypeEnum || (TransactionTypeEnum = {}));
 
-var TransactionSourceEnum;
-(function (TransactionSourceEnum) {
-    TransactionSourceEnum[TransactionSourceEnum["CASH"] = 1] = "CASH";
-    TransactionSourceEnum[TransactionSourceEnum["BANK_TRANSACTION"] = 2] = "BANK_TRANSACTION";
-})(TransactionSourceEnum || (TransactionSourceEnum = {}));
-
 var TaxExemptionEnum;
 (function (TaxExemptionEnum) {
     TaxExemptionEnum[TaxExemptionEnum["ONE_YEAR_RULE"] = 1] = "ONE_YEAR_RULE";
@@ -6320,6 +6449,18 @@ class AllocationRuleCollection extends Collection {
     getTransfer() {
         return this.filterBy('type', AllocationRuleTypeEnum.TRANSFER);
     }
+    /**
+     * Get dictionary where key is bank transaction id and value is collection of matched rules.
+     * Group by this way for better performance
+     * @TODO Alex: break bank transactions by pagination in case of bad performance
+     */
+    groupByBankTransaction(bankTransactions) {
+        const rulesByBankTransaction = new CollectionDictionary(new AllocationRuleCollection([]));
+        bankTransactions.toArray().forEach((bankTransaction) => {
+            rulesByBankTransaction.add(bankTransaction.id, this.filter((rule) => rule.matchBankTransaction(bankTransaction)));
+        });
+        return rulesByBankTransaction;
+    }
 }
 
 class AccountSetupItemCollection extends Collection {