taxtank-core 0.32.71 → 0.32.73

package/fesm2022/taxtank-core.mjs

@@ -21,7 +21,6 @@ import differenceBy from 'lodash/differenceBy';
 import uniq from 'lodash/uniq';
 import moment from 'moment';
 import { DateRange } from 'moment-range';
-import merge from 'lodash/merge';
 import ceil from 'lodash/ceil';
 import range from 'lodash/range';
 import { Validators, UntypedFormGroup, UntypedFormControl, UntypedFormArray, FormControl, FormArray, FormGroup } from '@angular/forms';
@@ -32,6 +31,7 @@ import { EventSourcePolyfill } from 'event-source-polyfill/src/eventsource.min.j
 import { JwtHelperService } from '@auth0/angular-jwt';
 import * as mixpanel from 'mixpanel-browser';
 import clone from 'lodash/clone';
+import merge from 'lodash/merge';
 import { isArray } from 'rxjs/internal-compatibility';
 import * as i4 from '@angular/router';
 import { NavigationEnd } from '@angular/router';
@@ -443,6 +443,9 @@ var TankTypeEnum;
 })(TankTypeEnum || (TankTypeEnum = {}));
 
 class TransactionBase extends ObservableModel {
+    get gstCoefficient() {
+        return this.isGST ? ChartAccounts.GSTCoefficient : 1;
+    }
     get claimRatio() {
         return this.sharedClaimPercent / 100;
     }
@@ -3750,6 +3753,12 @@ class IncomeSourceChartData {
     }
 }
 
+var TransactionSourceEnum;
+(function (TransactionSourceEnum) {
+    TransactionSourceEnum[TransactionSourceEnum["CASH"] = 1] = "CASH";
+    TransactionSourceEnum[TransactionSourceEnum["BANK_TRANSACTION"] = 2] = "BANK_TRANSACTION";
+})(TransactionSourceEnum || (TransactionSourceEnum = {}));
+
 class AllocationRuleTransaction extends AllocationRuleTransaction$1 {
     constructor() {
         super(...arguments);
@@ -3782,8 +3791,10 @@ class AllocationRuleTransaction extends AllocationRuleTransaction$1 {
     /**
      * Create Transaction instance based on passed bank transaction and rule transaction
      */
-    toTransaction(bankTransaction) {
-        const transaction = merge(bankTransaction.toTransaction(this.isGST), {
+    toTransaction(bankTransaction = null) {
+        const transaction = bankTransaction ? bankTransaction.toTransaction(this.isGST) : plainToClass(Transaction, {});
+        Object.assign(transaction, {
+            isGST: this.isGST,
             tax: this.tax,
             claimPercent: this.claimPercent,
             chartAccounts: this.chartAccounts,
@@ -3791,19 +3802,22 @@ class AllocationRuleTransaction extends AllocationRuleTransaction$1 {
             loan: this.loan,
             incomeSource: this.incomeSource,
             metaFields: this.metaFields,
-            parentTransaction: this.parentTransaction,
-            childTransactions: this.childTransactions,
             business: this.business,
+            source: TransactionSourceEnum.BANK_TRANSACTION,
             operation: TransactionOperationEnum.ALLOCATE,
+            transactions: [],
         });
-        // amount: bankTransaction.amount * (this.amountPercent ? (this.amountPercent / 100) : 1),
-        if (this.amount) {
-            transaction.amount = this.amount;
+        // split allocation
+        if (this.amountPercent) {
+            transaction.amount = bankTransaction.amount * this.amountPercentCoefficient / this.gstCoefficient;
         }
-        else if (this.amountPercent) {
-            transaction.amount *= this.amountPercentCoefficient;
-        }
-        transaction.allocations = [TransactionAllocation.create(transaction.amountWithGst, bankTransaction)];
+        // child transactions inherit most of the fields from parent transaction
+        this.childTransactions.forEach((childRuleTransaction) => {
+            const childTransaction = childRuleTransaction.toTransaction();
+            childTransaction.amount = childRuleTransaction.amount;
+            childTransaction.setParent(transaction);
+            transaction.transactions.push(childTransaction);
+        });
         return transaction;
     }
 }
@@ -3845,145 +3859,12 @@ __decorate([
     Type(() => Number)
 ], AllocationRuleTransaction.prototype, "tax", void 0);
 
-class AllocationRule extends AllocationRule$1 {
-    constructor() {
-        super(...arguments);
-        this.type = AllocationRuleTypeEnum.EXPENSE;
-        this.conditionOperator = AllocationRuleConditionOperatorEnum.OR;
-        this.autoAllocate = false;
-    }
-    get typeLabel() {
-        switch (this.type) {
-            case AllocationRuleTypeEnum.EXPENSE:
-                return 'expense';
-            case AllocationRuleTypeEnum.INCOME:
-                return 'income';
-            default:
-                return 'transfer';
-        }
-    }
-    isIncome() {
-        return this.type === AllocationRuleTypeEnum.INCOME;
-    }
-    isExpense() {
-        return this.type === AllocationRuleTypeEnum.EXPENSE;
-    }
-    isTransfer() {
-        return this.type === AllocationRuleTypeEnum.TRANSFER;
-    }
-    isPropertyTank() {
-        return this.transaction.tankType === TankTypeEnum.PROPERTY;
-    }
-    isWorkTank() {
-        return this.transaction.tankType === TankTypeEnum.WORK;
-    }
-    isSoleTank() {
-        return this.transaction.tankType === TankTypeEnum.SOLE;
-    }
-    isPropertyIncome() {
-        return this.isIncome() && this.isPropertyTank();
-    }
-    isWorkIncome() {
-        return this.isIncome() && this.isWorkTank();
-    }
-    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 (const condition of this.conditions) {
-            if (!condition.matchBankTransaction(bankTransaction)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Rule is matched when at least one condition matched
-     */
-    checkOr(bankTransaction) {
-        for (const 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),
-    Transform(({ value }) => ({ id: value.id }), { toPlainOnly: true })
-], AllocationRule.prototype, "bankAccount", void 0);
-__decorate([
-    Type(() => AllocationRuleCondition)
-], AllocationRule.prototype, "conditions", void 0);
-__decorate([
-    Type(() => AllocationRuleTransaction)
-], AllocationRule.prototype, "transaction", void 0);
-__decorate([
-    Type(() => BankAccount)
-], AllocationRule.prototype, "transferBankAccount", void 0);
-
-/**
- * Enum with income amount types (Net or Gross)
- */
-var IncomeAmountTypeEnum;
-(function (IncomeAmountTypeEnum) {
-    IncomeAmountTypeEnum[IncomeAmountTypeEnum["NET"] = 0] = "NET";
-    IncomeAmountTypeEnum[IncomeAmountTypeEnum["GROSS"] = 1] = "GROSS";
-})(IncomeAmountTypeEnum || (IncomeAmountTypeEnum = {}));
-
 var TransactionTypeEnum;
 (function (TransactionTypeEnum) {
     TransactionTypeEnum[TransactionTypeEnum["DEBIT"] = 1] = "DEBIT";
     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";
@@ -6261,27 +6142,13 @@ __decorate([
     Type(() => ChartAccountsMetaField)
 ], TransactionMetaField.prototype, "chartAccountsMetaField", void 0);
 
-class TransactionAllocation extends TransactionAllocation$1 {
-    /**
-     * Create a new instance of transaction allocation
-     * transaction could be empty since we can POST allocation inside a new transaction
-     */
-    static create(amount, bankTransaction, transaction) {
-        return plainToClass(TransactionAllocation, { amount, transaction, bankTransaction });
-    }
-}
-__decorate([
-    Type(() => BankTransaction)
-], TransactionAllocation.prototype, "bankTransaction", void 0);
-__decorate([
-    Type(() => Transaction)
-], TransactionAllocation.prototype, "transaction", void 0);
-
 // @TODO Alex: refactor: move here allocations methods, netAmount = amount, grossAmount calculation, remove unused methods, etc.
 class Transaction extends Transaction$1 {
     constructor() {
         super(...arguments);
-        // list of child transactions (fees)
+        /**
+         * @TODO rename to childTransactions
+         */
         this.transactions = [];
         this.metaFields = [];
         this.allocations = [];
@@ -6459,6 +6326,15 @@ class Transaction extends Transaction$1 {
     ignoreSign() {
         return !(this.chartAccounts?.id in ChartAccountsKeepSign);
     }
+    setParent(transaction) {
+        this.description = this.chartAccounts.name;
+        this.date = transaction.date;
+        this.claimPercent = transaction.claimPercent;
+        this.property = transaction.property;
+        this.loan = transaction.loan;
+        this.incomeSource = transaction.incomeSource;
+        this.business = transaction.business;
+    }
 }
 __decorate([
     Type(() => Transaction)
@@ -6494,6 +6370,151 @@ __decorate([
     Transform(({ value }) => +value)
 ], Transaction.prototype, "tax", void 0);
 
+class TransactionAllocation extends TransactionAllocation$1 {
+    /**
+     * Create a new instance of transaction allocation
+     * transaction could be empty since we can POST allocation inside a new transaction
+     */
+    static create(amount, bankTransaction, transaction) {
+        return plainToClass(TransactionAllocation, { amount, transaction, bankTransaction });
+    }
+}
+__decorate([
+    Type(() => BankTransaction)
+], TransactionAllocation.prototype, "bankTransaction", void 0);
+__decorate([
+    Type(() => Transaction)
+], TransactionAllocation.prototype, "transaction", void 0);
+
+class AllocationRule extends AllocationRule$1 {
+    constructor() {
+        super(...arguments);
+        this.type = AllocationRuleTypeEnum.EXPENSE;
+        this.conditionOperator = AllocationRuleConditionOperatorEnum.OR;
+        this.autoAllocate = false;
+    }
+    get typeLabel() {
+        switch (this.type) {
+            case AllocationRuleTypeEnum.EXPENSE:
+                return 'expense';
+            case AllocationRuleTypeEnum.INCOME:
+                return 'income';
+            default:
+                return 'transfer';
+        }
+    }
+    isIncome() {
+        return this.type === AllocationRuleTypeEnum.INCOME;
+    }
+    isExpense() {
+        return this.type === AllocationRuleTypeEnum.EXPENSE;
+    }
+    isTransfer() {
+        return this.type === AllocationRuleTypeEnum.TRANSFER;
+    }
+    isPropertyTank() {
+        return this.transaction.tankType === TankTypeEnum.PROPERTY;
+    }
+    isWorkTank() {
+        return this.transaction.tankType === TankTypeEnum.WORK;
+    }
+    isSoleTank() {
+        return this.transaction.tankType === TankTypeEnum.SOLE;
+    }
+    isPropertyIncome() {
+        return this.isIncome() && this.isPropertyTank();
+    }
+    isWorkIncome() {
+        return this.isIncome() && this.isWorkTank();
+    }
+    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;
+        }
+        const transaction = this.transaction.toTransaction(bankTransaction);
+        transaction.allocations = [TransactionAllocation.create(transaction.amountWithGst, bankTransaction)];
+        return transaction;
+    }
+    /**
+     * Rule is matched when all conditions matched
+     */
+    checkAnd(bankTransaction) {
+        for (const condition of this.conditions) {
+            if (!condition.matchBankTransaction(bankTransaction)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Rule is matched when at least one condition matched
+     */
+    checkOr(bankTransaction) {
+        for (const 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),
+    Transform(({ value }) => ({ id: value.id }), { toPlainOnly: true })
+], AllocationRule.prototype, "bankAccount", void 0);
+__decorate([
+    Type(() => AllocationRuleCondition)
+], AllocationRule.prototype, "conditions", void 0);
+__decorate([
+    Type(() => AllocationRuleTransaction)
+], AllocationRule.prototype, "transaction", void 0);
+__decorate([
+    Type(() => BankAccount)
+], AllocationRule.prototype, "transferBankAccount", void 0);
+
+/**
+ * Enum with income amount types (Net or Gross)
+ */
+var IncomeAmountTypeEnum;
+(function (IncomeAmountTypeEnum) {
+    IncomeAmountTypeEnum[IncomeAmountTypeEnum["NET"] = 0] = "NET";
+    IncomeAmountTypeEnum[IncomeAmountTypeEnum["GROSS"] = 1] = "GROSS";
+})(IncomeAmountTypeEnum || (IncomeAmountTypeEnum = {}));
+
 var TransactionCategoryEnum;
 (function (TransactionCategoryEnum) {
     TransactionCategoryEnum[TransactionCategoryEnum["PROPERTY"] = 0] = "PROPERTY";
@@ -11170,7 +11191,6 @@ var BankConnectionMessagesEnum;
  * service handles BankConnection management
  */
 class BankConnectionService extends RestService$1 {
-    // mercureTopic = 'bankConnections';
     constructor(environment) {
         super(environment);
         this.environment = environment;
@@ -11178,6 +11198,7 @@ class BankConnectionService extends RestService$1 {
         this.collectionClass = Collection;
         this.endpointUri = 'bank-connections';
         this.disabledMethods = ['postBatch', 'putBatch', 'delete', 'deleteBatch'];
+        this.mercureTopic = 'bankConnections';
         this.listenEvents();
     }
     listenEvents() {
@@ -11735,7 +11756,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
  * Service for work with messages
  */
 class MessageService extends RestService$1 {
-    // mercureTopic = 'messages';
     constructor(environment) {
         super(environment);
         this.environment = environment;
@@ -11743,6 +11763,7 @@ class MessageService extends RestService$1 {
         this.collectionClass = MessageCollection;
         this.endpointUri = 'messages';
         this.disabledMethods = ['postBatch', 'putBatch'];
+        this.mercureTopic = 'messages';
         this.listenEvents();
     }
     listenEvents() {
@@ -12191,13 +12212,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
         }] });
 
 class ClientInviteService extends RestService$1 {
-    // mercureTopic = 'clientInvites';
     constructor(environment) {
         super(environment);
         this.environment = environment;
         this.endpointUri = 'clients/invites';
         this.collectionClass = ClientInviteCollection;
         this.modelClass = ClientInvite;
+        this.mercureTopic = 'clientInvites';
         this.listenEvents();
     }
     listenEvents() {
@@ -12298,7 +12319,6 @@ var ClientInviteMessages;
 })(ClientInviteMessages || (ClientInviteMessages = {}));
 
 class ClientMovementService extends RestService$1 {
-    // mercureTopic = 'clientMovements';
     constructor(environment) {
         super(environment);
         this.environment = environment;
@@ -12306,6 +12326,7 @@ class ClientMovementService extends RestService$1 {
         this.collectionClass = ClientMovementCollection;
         this.modelClass = ClientMovement;
         this.disabledMethods = ['postBatch', 'delete', 'deleteBatch'];
+        this.mercureTopic = 'clientMovements';
         this.listenEvents();
     }
     listenEvents() {
@@ -14034,13 +14055,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
         }] });
 
 class ServicePaymentMethodService extends RestService$1 {
-    // mercureTopic = 'servicePaymentMethods';
     constructor(environment) {
         super(environment);
         this.environment = environment;
         this.endpointUri = 'service-payment-methods';
         this.collectionClass = Collection;
         this.modelClass = ServicePaymentMethod;
+        this.mercureTopic = 'servicePaymentMethods';
         this.listenEvents();
     }
     listenEvents() {
@@ -14106,7 +14127,6 @@ var SubscriptionMessagesEnum;
  * @TODO Alex refactor
  */
 class SubscriptionService extends RestService$1 {
-    // mercureTopic = 'serviceSubscriptions';
     constructor(http, environment) {
         super(environment);
         this.http = http;
@@ -14115,6 +14135,7 @@ class SubscriptionService extends RestService$1 {
         this.modelClass = ServiceSubscription;
         this.collectionClass = ServiceSubscriptionCollection;
         this.disabledMethods = ['putBatch', 'delete', 'deleteBatch'];
+        this.mercureTopic = 'serviceSubscriptions';
         this.listenEvents();
     }
     listenEvents() {
@@ -23016,6 +23037,33 @@ class AllocationRuleForm extends AbstractForm {
                 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();
+    }
 }
 
 /**
@@ -23161,7 +23209,6 @@ class TransactionForm extends TransactionBaseForm {
             date: transaction.date,
             claimPercent: (transaction.claimPercent * childTransaction.chartAccounts?.taxablePercent) / 100,
             source: TransactionSourceEnum.BANK_TRANSACTION,
-            type: childTransaction.chartAccounts?.isExpense() ? TransactionTypeEnum.DEBIT : TransactionTypeEnum.CREDIT,
             incomeSource: transaction.incomeSource,
             property: transaction.property
         }, this.model.transactions.find((transaction) => transaction.id === childTransaction['id']) || {}, childTransaction));