taxtank-core 0.33.115 → 0.33.116

package/esm2022/src/lib/models/transaction/allocation-rule.mjs

@@ -0,0 +1,131 @@
+import { __decorate } from "tslib";
+import { AllocationRule as AllocationRuleBase } from '../../db/Models/transaction/allocation-rule';
+import { BankAccount } from '../bank';
+import { Transform, Type, plainToClass } from 'class-transformer';
+import { AllocationRuleCondition } from './allocation-rule-condition';
+import { AllocationRuleTransaction } from './allocation-rule-transaction';
+import { AllocationRuleConditionComparisonOperatorEnum, AllocationRuleConditionFieldEnum, AllocationRuleConditionOperatorEnum, AllocationRuleTypeEnum, ChartAccountsListEnum } from '../../db/Enums';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';
+import { ChartAccounts } from '../chart-accounts';
+import { TransactionAllocation } from './transaction-allocation';
+export class AllocationRule extends AllocationRuleBase {
+    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);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"allocation-rule.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/models/transaction/allocation-rule.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,cAAc,IAAI,kBAAkB,EAAE,MAAM,6CAA6C,CAAC;AACnG,OAAO,EAAE,WAAW,EAAmB,MAAM,SAAS,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EACL,6CAA6C,EAC7C,gCAAgC,EAChC,mCAAmC,EACnC,sBAAsB,EAAE,qBAAqB,EAC9C,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D,OAAO,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,MAAM,OAAO,cAAe,SAAQ,kBAAkB;IAAtD;;QAcE,SAAI,GAA2B,sBAAsB,CAAC,OAAO,CAAC;QAC9D,sBAAiB,GAAwC,mCAAmC,CAAC,EAAE,CAAC;QAChG,iBAAY,GAAG,KAAK,CAAC;IA0HvB,CAAC;IAxHC,IAAI,SAAS;QACX,QAAQ,IAAI,CAAC,IAAI,EAAE;YACjB,KAAK,sBAAsB,CAAC,OAAO;gBACjC,OAAO,SAAS,CAAC;YAEnB,KAAK,sBAAsB,CAAC,MAAM;gBAChC,OAAO,QAAQ,CAAC;YAElB;gBACE,OAAO,UAAU,CAAC;SACrB;IACH,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,IAAI,KAAK,sBAAsB,CAAC,MAAM,CAAC;IACrD,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,IAAI,KAAK,sBAAsB,CAAC,OAAO,CAAC;IACtD,CAAC;IAED,UAAU;QACR,OAAO,IAAI,CAAC,IAAI,KAAK,sBAAsB,CAAC,QAAQ,CAAC;IACvD,CAAC;IAED,cAAc;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC,QAAQ,KAAK,YAAY,CAAC,QAAQ,CAAC;IAC7D,CAAC;IAED,UAAU;QACR,OAAO,IAAI,CAAC,WAAW,CAAC,QAAQ,KAAK,YAAY,CAAC,IAAI,CAAC;IACzD,CAAC;IAED,UAAU;QACR,OAAO,IAAI,CAAC,WAAW,CAAC,QAAQ,KAAK,YAAY,CAAC,IAAI,CAAC;IACzD,CAAC;IAED,gBAAgB;QACd,OAAO,IAAI,CAAC,QAAQ,EAAE,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;IAClD,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,QAAQ,EAAE,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;IAC9C,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,QAAQ,EAAE,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;IAC9C,CAAC;IAED;;OAEG;IACH,oBAAoB,CAAC,eAAgC;QACnD,OAAO,IAAI,CAAC,iBAAiB,KAAK,mCAAmC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;IAC7I,CAAC;IAED,iBAAiB,CAAC,eAAgC;QAChD,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE;YACrB,MAAM,WAAW,GAAgB,eAAe,CAAC,aAAa,EAAE,CAAC;YAEjE,WAAW,CAAC,SAAS,GAAG,wBAAwB,CAAC,QAAQ,CAAC;YAC1D,WAAW,CAAC,aAAa,GAAG,YAAY,CAAC,aAAa,EAAE,EAAE,EAAE,EAAE,qBAAqB,CAAC,QAAQ,EAAE,CAAC,CAAC;YAEhG,OAAO,WAAW,CAAC;SACpB;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC;QACpE,WAAW,CAAC,WAAW,GAAG,CAAC,qBAAqB,CAAC,MAAM,CAAC,WAAW,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC,CAAC;QAErG,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;OAEG;IACK,QAAQ,CAAC,eAAgC;QAC/C,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE;YACvC,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,eAAe,CAAC,EAAE;gBACpD,OAAO,KAAK,CAAC;aACd;SACF;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACK,OAAO,CAAC,eAAgC;QAC9C,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE;YACvC,IAAI,SAAS,CAAC,oBAAoB,CAAC,eAAe,CAAC,EAAE;gBACnD,OAAO,IAAI,CAAC;aACb;SACF;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,eAAgC;QACzD,OAAO,YAAY,CAAC,cAAc,EAAE;YAClC,IAAI,EAAE,eAAe,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC,CAAC,sBAAsB,CAAC,MAAM;YAChG,WAAW,EAAE,eAAe,CAAC,WAAW;YACxC,iBAAiB,EAAE,mCAAmC,CAAC,GAAG;YAC1D,UAAU,EAAE;gBACV,YAAY,CAAC,uBAAuB,EAAE;oBACpC,KAAK,EAAE,gCAAgC,CAAC,MAAM;oBAC9C,kBAAkB,EAAE,6CAA6C,CAAC,MAAM;oBACxE,KAAK,EAAE,eAAe,CAAC,MAAM;iBAC9B,CAAC;gBACF,YAAY,CAAC,uBAAuB,EAAE;oBACpC,KAAK,EAAE,gCAAgC,CAAC,WAAW;oBACnD,kBAAkB,EAAE,6CAA6C,CAAC,MAAM;oBACxE,KAAK,EAAE,eAAe,CAAC,WAAW;iBACnC,CAAC;aACH;SACF,CAAC,CAAC;IACL,CAAC;CACF;AAvIC;IAFC,IAAI,CAAC,GAAG,EAAE,CAAC,WAAW,CAAC;IACvB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;mDAC1C;AAG1B;IADC,IAAI,CAAC,GAAG,EAAE,CAAC,uBAAuB,CAAC;kDACG;AAGvC;IADC,IAAI,CAAC,GAAG,EAAE,CAAC,yBAAyB,CAAC;mDACE;AAGxC;IADC,IAAI,CAAC,GAAG,EAAE,CAAC,WAAW,CAAC;2DACU","sourcesContent":["import { AllocationRule as AllocationRuleBase } from '../../db/Models/transaction/allocation-rule';\nimport { BankAccount, BankTransaction } from '../bank';\nimport { Transform, Type, plainToClass } from 'class-transformer';\nimport { AllocationRuleCondition } from './allocation-rule-condition';\nimport { AllocationRuleTransaction } from './allocation-rule-transaction';\nimport {\n  AllocationRuleConditionComparisonOperatorEnum,\n  AllocationRuleConditionFieldEnum,\n  AllocationRuleConditionOperatorEnum,\n  AllocationRuleTypeEnum, ChartAccountsListEnum\n} from '../../db/Enums';\nimport { TankTypeEnum } from '../../db/Enums/tank-type.enum';\nimport { Transaction } from './transaction';\nimport { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';\nimport { ChartAccounts } from '../chart-accounts';\nimport { TransactionAllocation } from './transaction-allocation';\n\nexport class AllocationRule extends AllocationRuleBase {\n  @Type(() => BankAccount)\n  @Transform(({ value }) => ({ id: value.id }), { toPlainOnly: true })\n  bankAccount?: BankAccount;\n\n  @Type(() => AllocationRuleCondition)\n  conditions?: AllocationRuleCondition[];\n\n  @Type(() => AllocationRuleTransaction)\n  transaction?: AllocationRuleTransaction;\n\n  @Type(() => BankAccount)\n  transferBankAccount?: BankAccount;\n\n  type: AllocationRuleTypeEnum = AllocationRuleTypeEnum.EXPENSE;\n  conditionOperator: AllocationRuleConditionOperatorEnum = AllocationRuleConditionOperatorEnum.OR;\n  autoAllocate = false;\n\n  get typeLabel(): string {\n    switch (this.type) {\n      case AllocationRuleTypeEnum.EXPENSE:\n        return 'expense';\n\n      case AllocationRuleTypeEnum.INCOME:\n        return 'income';\n\n      default:\n        return 'transfer';\n    }\n  }\n\n  isIncome(): boolean {\n    return this.type === AllocationRuleTypeEnum.INCOME;\n  }\n\n  isExpense(): boolean {\n    return this.type === AllocationRuleTypeEnum.EXPENSE;\n  }\n\n  isTransfer(): boolean {\n    return this.type === AllocationRuleTypeEnum.TRANSFER;\n  }\n\n  isPropertyTank(): boolean {\n    return this.transaction.tankType === TankTypeEnum.PROPERTY;\n  }\n\n  isWorkTank(): boolean {\n    return this.transaction.tankType === TankTypeEnum.WORK;\n  }\n\n  isSoleTank(): boolean {\n    return this.transaction.tankType === 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  /**\n   * @TODO Alex: move to collection\n   */\n  matchBankTransaction(bankTransaction: BankTransaction): boolean {\n    return this.conditionOperator === AllocationRuleConditionOperatorEnum.AND ? this.checkAnd(bankTransaction) : this.checkOr(bankTransaction);\n  }\n\n  createTransaction(bankTransaction: BankTransaction): Transaction {\n    if (this.isTransfer()) {\n      const transaction: Transaction = bankTransaction.toTransaction();\n\n      transaction.operation = TransactionOperationEnum.TRANSFER;\n      transaction.chartAccounts = plainToClass(ChartAccounts, { id: ChartAccountsListEnum.TRANSFER });\n\n      return transaction;\n    }\n\n    const transaction = this.transaction.toTransaction(bankTransaction);\n    transaction.allocations = [TransactionAllocation.create(transaction.amountWithGst, bankTransaction)];\n\n    return transaction;\n  }\n\n  /**\n   * Rule is matched when all conditions matched\n   */\n  private checkAnd(bankTransaction: BankTransaction): boolean {\n    for (const condition of this.conditions) {\n      if (!condition.matchBankTransaction(bankTransaction)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Rule is matched when at least one condition matched\n   */\n  private checkOr(bankTransaction: BankTransaction): boolean {\n    for (const condition of this.conditions) {\n      if (condition.matchBankTransaction(bankTransaction)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * Create allocation rule based on bank transaction (just prefill rule fields with bank transaction values)\n   */\n  static fromBankTransaction(bankTransaction: BankTransaction): AllocationRule {\n    return plainToClass(AllocationRule, {\n      type: bankTransaction.isDebit() ? AllocationRuleTypeEnum.EXPENSE : AllocationRuleTypeEnum.INCOME,\n      bankAccount: bankTransaction.bankAccount,\n      conditionOperator: AllocationRuleConditionOperatorEnum.AND,\n      conditions: [\n        plainToClass(AllocationRuleCondition, {\n          field: AllocationRuleConditionFieldEnum.AMOUNT,\n          comparisonOperator: AllocationRuleConditionComparisonOperatorEnum.EQUALS,\n          value: bankTransaction.amount\n        }),\n        plainToClass(AllocationRuleCondition, {\n          field: AllocationRuleConditionFieldEnum.DESCRIPTION,\n          comparisonOperator: AllocationRuleConditionComparisonOperatorEnum.EQUALS,\n          value: bankTransaction.description\n        })\n      ]\n    });\n  }\n}\n"]}

package/esm2022/src/lib/models/transaction/income-amount-type.enum.mjs

@@ -0,0 +1,9 @@
+/**
+ * Enum with income amount types (Net or Gross)
+ */
+export var IncomeAmountTypeEnum;
+(function (IncomeAmountTypeEnum) {
+    IncomeAmountTypeEnum[IncomeAmountTypeEnum["NET"] = 0] = "NET";
+    IncomeAmountTypeEnum[IncomeAmountTypeEnum["GROSS"] = 1] = "GROSS";
+})(IncomeAmountTypeEnum || (IncomeAmountTypeEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5jb21lLWFtb3VudC10eXBlLmVudW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvbW9kZWxzL3RyYW5zYWN0aW9uL2luY29tZS1hbW91bnQtdHlwZS5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFOLElBQVksb0JBR1g7QUFIRCxXQUFZLG9CQUFvQjtJQUM5Qiw2REFBRyxDQUFBO0lBQ0gsaUVBQUssQ0FBQTtBQUNQLENBQUMsRUFIVyxvQkFBb0IsS0FBcEIsb0JBQW9CLFFBRy9CIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFbnVtIHdpdGggaW5jb21lIGFtb3VudCB0eXBlcyAoTmV0IG9yIEdyb3NzKVxuICovXG5leHBvcnQgZW51bSBJbmNvbWVBbW91bnRUeXBlRW51bSB7XG4gIE5FVCxcbiAgR1JPU1Ncbn1cbiJdfQ==

package/esm2022/src/lib/models/transaction/index.mjs

@@ -0,0 +1,9 @@
+export * from './allocation-rule';
+export * from './allocation-rule-transaction';
+export * from './allocation-rule-transaction-meta-field';
+export * from './income-amount-type.enum';
+export * from './transaction';
+export * from './transaction-allocation';
+export * from './transaction-category.enum';
+export * from './transaction-meta-field';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvbW9kZWxzL3RyYW5zYWN0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLDBDQUEwQyxDQUFDO0FBQ3pELGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FsbG9jYXRpb24tcnVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2FsbG9jYXRpb24tcnVsZS10cmFuc2FjdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL2FsbG9jYXRpb24tcnVsZS10cmFuc2FjdGlvbi1tZXRhLWZpZWxkJztcbmV4cG9ydCAqIGZyb20gJy4vaW5jb21lLWFtb3VudC10eXBlLmVudW0nO1xuZXhwb3J0ICogZnJvbSAnLi90cmFuc2FjdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL3RyYW5zYWN0aW9uLWFsbG9jYXRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi90cmFuc2FjdGlvbi1jYXRlZ29yeS5lbnVtJztcbmV4cG9ydCAqIGZyb20gJy4vdHJhbnNhY3Rpb24tbWV0YS1maWVsZCc7XG4iXX0=

package/esm2022/src/lib/models/transaction/transaction-allocation.mjs

@@ -0,0 +1,21 @@
+import { __decorate } from "tslib";
+import { TransactionAllocation as TransactionAllocationBase } from '../../db/Models/transaction/transaction-allocation';
+import { BankTransaction } from '../bank';
+import { Transaction } from './transaction';
+import { Type, plainToClass } from 'class-transformer';
+export class TransactionAllocation extends TransactionAllocationBase {
+    /**
+     * 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);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/models/transaction/transaction-category.enum.mjs

@@ -0,0 +1,8 @@
+export var TransactionCategoryEnum;
+(function (TransactionCategoryEnum) {
+    TransactionCategoryEnum[TransactionCategoryEnum["PROPERTY"] = 0] = "PROPERTY";
+    TransactionCategoryEnum[TransactionCategoryEnum["WORK"] = 1] = "WORK";
+    TransactionCategoryEnum[TransactionCategoryEnum["SOLE"] = 2] = "SOLE";
+    TransactionCategoryEnum[TransactionCategoryEnum["PERSONAL"] = 3] = "PERSONAL";
+})(TransactionCategoryEnum || (TransactionCategoryEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNhY3Rpb24tY2F0ZWdvcnkuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9tb2RlbHMvdHJhbnNhY3Rpb24vdHJhbnNhY3Rpb24tY2F0ZWdvcnkuZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSx1QkFLWDtBQUxELFdBQVksdUJBQXVCO0lBQ2pDLDZFQUFRLENBQUE7SUFDUixxRUFBSSxDQUFBO0lBQ0oscUVBQUksQ0FBQTtJQUNKLDZFQUFRLENBQUE7QUFDVixDQUFDLEVBTFcsdUJBQXVCLEtBQXZCLHVCQUF1QixRQUtsQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIFRyYW5zYWN0aW9uQ2F0ZWdvcnlFbnVtIHtcbiAgUFJPUEVSVFksXG4gIFdPUkssXG4gIFNPTEUsXG4gIFBFUlNPTkFMXG59XG4iXX0=

package/esm2022/src/lib/models/transaction/transaction-meta-field.mjs

@@ -0,0 +1,17 @@
+import { __decorate } from "tslib";
+import { TransactionMetaField as TransactionMetaFieldBase } from '../../db/Models/transaction/transaction-meta-field';
+import { Type } from 'class-transformer';
+import { ChartAccountsMetaField } from '../chart-accounts';
+import { Transaction } from '../../db/Models';
+export class TransactionMetaField extends TransactionMetaFieldBase {
+}
+__decorate([
+    Type(() => ChartAccountsMetaField)
+], TransactionMetaField.prototype, "metaField", void 0);
+__decorate([
+    Type(() => Transaction)
+], TransactionMetaField.prototype, "transaction", void 0);
+__decorate([
+    Type(() => ChartAccountsMetaField)
+], TransactionMetaField.prototype, "chartAccountsMetaField", void 0);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNhY3Rpb24tbWV0YS1maWVsZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9tb2RlbHMvdHJhbnNhY3Rpb24vdHJhbnNhY3Rpb24tbWV0YS1maWVsZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFFLG9CQUFvQixJQUFJLHdCQUF3QixFQUFFLE1BQU0sb0RBQW9ELENBQUM7QUFDdEgsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3pDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQzNELE9BQU8sRUFBQyxXQUFXLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUU1QyxNQUFNLE9BQU8sb0JBQXFCLFNBQVEsd0JBQXdCO0NBT2pFO0FBTEM7SUFEQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsc0JBQXNCLENBQUM7dURBQ0Q7QUFFbEM7SUFEQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsV0FBVyxDQUFDO3lEQUNDO0FBRXpCO0lBREMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLHNCQUFzQixDQUFDO29FQUNZIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVHJhbnNhY3Rpb25NZXRhRmllbGQgYXMgVHJhbnNhY3Rpb25NZXRhRmllbGRCYXNlIH0gZnJvbSAnLi4vLi4vZGIvTW9kZWxzL3RyYW5zYWN0aW9uL3RyYW5zYWN0aW9uLW1ldGEtZmllbGQnO1xuaW1wb3J0IHsgVHlwZSB9IGZyb20gJ2NsYXNzLXRyYW5zZm9ybWVyJztcbmltcG9ydCB7IENoYXJ0QWNjb3VudHNNZXRhRmllbGQgfSBmcm9tICcuLi9jaGFydC1hY2NvdW50cyc7XG5pbXBvcnQge1RyYW5zYWN0aW9ufSBmcm9tICcuLi8uLi9kYi9Nb2RlbHMnO1xuXG5leHBvcnQgY2xhc3MgVHJhbnNhY3Rpb25NZXRhRmllbGQgZXh0ZW5kcyBUcmFuc2FjdGlvbk1ldGFGaWVsZEJhc2Uge1xuICBAVHlwZSgoKSA9PiBDaGFydEFjY291bnRzTWV0YUZpZWxkKVxuICBtZXRhRmllbGQ6IENoYXJ0QWNjb3VudHNNZXRhRmllbGQ7XG4gIEBUeXBlKCgpID0+IFRyYW5zYWN0aW9uKVxuICB0cmFuc2FjdGlvbjogVHJhbnNhY3Rpb247XG4gIEBUeXBlKCgpID0+IENoYXJ0QWNjb3VudHNNZXRhRmllbGQpXG4gIGNoYXJ0QWNjb3VudHNNZXRhRmllbGQ6IENoYXJ0QWNjb3VudHNNZXRhRmllbGQ7XG59XG4iXX0=

package/esm2022/src/lib/models/transaction/transaction.mjs

@@ -0,0 +1,243 @@
+import { __decorate } from "tslib";
+import { Transaction as TransactionBase } from '../../db/Models/transaction/transaction';
+import { TransactionTypeEnum } from '../../db/Enums/transaction-type.enum';
+import { ChartAccountsKeepSign, ChartAccountsListEnum, ChartAccountsMetaFieldListEnum, } from '../../db/Enums';
+import { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';
+import { TransactionSourceEnum } from '../../db/Enums/transaction-source.enum';
+import { DepreciationTypeEnum } from '../../db/Enums/depreciation-type.enum';
+import { DepreciationCalculationEnum } from '../../db/Enums/depreciation-calculation.enum';
+import { Transform, Type, plainToClass } from 'class-transformer';
+import { Property } from '../property';
+import { CHART_ACCOUNTS_CATEGORIES, ChartAccounts } from '../chart-accounts';
+import { IncomeSource } from '../income-source';
+import { TransactionMetaField } from './transaction-meta-field';
+import { Loan } from '../loan';
+import { TransactionAllocation } from './transaction-allocation';
+import { Collection } from '../../collections';
+import { Depreciation } from '../depreciation';
+import { SoleBusiness, SoleInvoiceItem } from '../sole';
+// @TODO Alex: refactor: move here allocations methods, netAmount = amount, grossAmount calculation, remove unused methods, etc.
+export class Transaction extends TransactionBase {
+    constructor() {
+        super(...arguments);
+        /**
+         * @TODO rename to childTransactions
+         */
+        this.transactions = [];
+        this.metaFields = [];
+        this.allocations = [];
+        this.tax = 0;
+        this.operation = TransactionOperationEnum.FIND_AND_MATCH;
+        this.claimPercent = 100;
+        this.amount = 0;
+    }
+    static { this.className = 'Transaction'; }
+    get invoiceId() {
+        return this.invoiceItem?.invoice.id;
+    }
+    isDebit() {
+        return this.type === TransactionTypeEnum.DEBIT;
+    }
+    isCredit() {
+        return this.type === TransactionTypeEnum.CREDIT;
+    }
+    /**
+     * @TODO move to base collection
+     */
+    isIncome() {
+        // @TODO not used
+        if (!this.chartAccounts) {
+            return this.isCredit();
+        }
+        return CHART_ACCOUNTS_CATEGORIES.income.includes(this.chartAccounts.category);
+    }
+    /**
+     * @TODO move to base collection
+     */
+    isExpense() {
+        // @TODO not used
+        if (!this.chartAccounts) {
+            return this.isDebit();
+        }
+        return CHART_ACCOUNTS_CATEGORIES.expense.includes(this.chartAccounts.category);
+    }
+    isPersonal() {
+        return CHART_ACCOUNTS_CATEGORIES.personal.includes(this.chartAccounts.category);
+    }
+    isInterest() {
+        return this.chartAccounts.id === ChartAccountsListEnum.INTEREST_ON_LOAN;
+    }
+    /**
+     * Check if transaction type is vehicle
+     */
+    isVehicleTransaction() {
+        return this.chartAccounts.isVehicleExpense();
+    }
+    get taxFreeComponent() {
+        return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.TAX_FREE_COMPONENT);
+    }
+    get frankingCredit() {
+        return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.FRANKING_CREDIT);
+    }
+    get eligibleForReduction() {
+        return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.ELIGIBLE_FOR_REDUCTION);
+    }
+    get untaxedElement() {
+        return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.UNTAXED_ELEMENT);
+    }
+    /**
+     * Check if transaction reconcile operation if TRANSFER
+     * @TODO bad usage of get (and all is* methods), getter should sound like a noun
+     */
+    get isTransfer() {
+        return this.operation === TransactionOperationEnum.TRANSFER;
+    }
+    isFindAndMatch() {
+        return this.operation === TransactionOperationEnum.FIND_AND_MATCH;
+    }
+    get debit() {
+        return this.isDebit() ? Math.abs(this.grossAmountWithoutGst) : 0;
+    }
+    get credit() {
+        return this.isCredit() ? Math.abs(this.grossAmountWithoutGst) : 0;
+    }
+    /**
+     * Get value of transaction meta field
+     * @param field for which value should be returned
+     * @Todo modify 'metaFields' property from array to Collection
+     */
+    getMetaFieldValue(field) {
+        return +this.metaFields.find((transactionMetaField) => transactionMetaField.chartAccountsMetaField.id === field)?.value || 0;
+    }
+    isCash() {
+        return this.source === TransactionSourceEnum.CASH;
+    }
+    canFindAndMatch(allocations) {
+        return !this.parentTransaction
+            && !this.isCash()
+            && !(this.isSoleTank() && this.isIncome())
+            && this.isEditable()
+            && !this.isAllocated(allocations);
+    }
+    /**
+     * Create Depreciation instance based on Transaction
+     */
+    toDepreciation() {
+        return plainToClass(Depreciation, {
+            date: this.date,
+            amount: Math.abs(this.amount),
+            chartAccounts: this.chartAccounts,
+            description: this.description,
+            type: this.chartAccounts.isPropertyCapitalWorks() ? DepreciationTypeEnum.CAPITAL_WORKS : DepreciationTypeEnum.PLANT_EQUIPMENT,
+            claimPercent: this.claimPercent,
+            property: this.property,
+            calculation: this.property ? this.property.depreciationCalculation : DepreciationCalculationEnum.PRIME_COST,
+            transactions: [this],
+            business: this.business,
+        });
+    }
+    /**
+     * Check if transaction is completely allocated
+     */
+    isAllocated(allocations) {
+        return Math.abs(this.getAllocatedAmount(allocations)) - Math.abs(this.netAmount) >= 0;
+    }
+    getAllocatedAmount(allocations) {
+        return allocations.filterBy('transaction.id', this.id).sumBy('amount');
+    }
+    getUnallocatedAmount(allocations) {
+        return this.netAmount - this.getAllocatedAmount(allocations);
+    }
+    /**
+     * Total transaction amount including taxes and other additional amounts
+     */
+    get grossAmount() {
+        return this.grossAmountWithoutGst + this.gstAmount;
+    }
+    get grossAmountWithoutGst() {
+        let grossAmount = this.amount + this.tax;
+        if (this.isExpense()) {
+            return grossAmount;
+        }
+        // included transactions affect parent transaction amount and as a result grossAmount, skip to avoid double sum
+        const adjustments = new Collection(this.transactions)
+            .filter(transaction => !transaction.chartAccounts?.isAdjustmentIncluded());
+        const income = adjustments.filter(transaction => transaction.isIncome()).sumBy('amount');
+        const expense = adjustments.filter(transaction => transaction.isExpense()).sumBy('amount', true);
+        // all adjustments except property income increase grossIncome
+        grossAmount += expense + (this.isPropertyTank() ? -income : income);
+        if (this.isWorkTank() || this.isHoldingTank()) {
+            grossAmount += this.frankingCredit - this.taxFreeComponent - this.eligibleForReduction;
+        }
+        return grossAmount;
+    }
+    get grossClaimAmountWithoutGst() {
+        return this.grossAmountWithoutGst * this.claimRatio;
+    }
+    /**
+     * @TODO vik confusing logic demanded by Nicole, we need a better ux to fix it
+     * netAmount matches received payment (bankTransaction amount), includes gst and salary included adjustments
+     * ie user received 1000$ salary including 100$ tips. NetAmount=1000$, amount=900$, tips=100$
+     */
+    get netAmount() {
+        return new Collection(this.transactions)
+            .filter((t) => t.chartAccounts?.isAdjustmentIncluded())
+            .sumBy('amount') + this.amountWithGst;
+    }
+    /**
+     * most of the transactions could have only positive or negative amount depends on chartAccounts, so we ignore
+     * user's choice and transform amount, but there are exceptions like advance (negative or positive amount)
+     */
+    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;
+    }
+    isEditable() {
+        return !ChartAccounts.systemList.includes(this.chartAccounts.id);
+    }
+}
+__decorate([
+    Type(() => Transaction)
+], Transaction.prototype, "transactions", void 0);
+__decorate([
+    Type(() => Property)
+], Transaction.prototype, "property", void 0);
+__decorate([
+    Type(() => ChartAccounts)
+], Transaction.prototype, "chartAccounts", void 0);
+__decorate([
+    Type(() => IncomeSource)
+], Transaction.prototype, "incomeSource", void 0);
+__decorate([
+    Type(() => TransactionMetaField)
+], Transaction.prototype, "metaFields", void 0);
+__decorate([
+    Type(() => Transaction)
+], Transaction.prototype, "transfer", void 0);
+__decorate([
+    Type(() => Loan)
+], Transaction.prototype, "loan", void 0);
+__decorate([
+    Type(() => Date)
+], Transaction.prototype, "date", void 0);
+__decorate([
+    Type(() => TransactionAllocation)
+], Transaction.prototype, "allocations", void 0);
+__decorate([
+    Type(() => SoleInvoiceItem)
+], Transaction.prototype, "invoiceItem", void 0);
+__decorate([
+    Type(() => SoleBusiness)
+], Transaction.prototype, "business", void 0);
+__decorate([
+    Transform(({ value }) => +value)
+], Transaction.prototype, "tax", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/models/transaction/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { Transaction as TransactionBase } from '../../db/Models/transaction/transaction';\nimport { TransactionTypeEnum } from '../../db/Enums/transaction-type.enum';\nimport {\n  ChartAccountsKeepSign,\n  ChartAccountsListEnum,\n  ChartAccountsMetaFieldListEnum,\n} from '../../db/Enums';\nimport { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';\nimport { TransactionSourceEnum } from '../../db/Enums/transaction-source.enum';\nimport { DepreciationTypeEnum } from '../../db/Enums/depreciation-type.enum';\nimport { DepreciationCalculationEnum } from '../../db/Enums/depreciation-calculation.enum';\nimport { Transform, Type, plainToClass } from 'class-transformer';\nimport { Property } from '../property';\nimport { CHART_ACCOUNTS_CATEGORIES, ChartAccounts } from '../chart-accounts';\nimport { IncomeSource } from '../income-source';\nimport { TransactionMetaField } from './transaction-meta-field';\nimport { Loan } from '../loan';\nimport { TransactionAllocation } from './transaction-allocation';\nimport { Collection, TransactionAllocationCollection } from '../../collections';\nimport { Depreciation } from '../depreciation';\nimport { Expense } from '../../interfaces';\nimport { SoleBusiness, SoleInvoiceItem } from '../sole';\n\n// @TODO Alex: refactor: move here allocations methods, netAmount = amount, grossAmount calculation, remove unused methods, etc.\nexport class Transaction extends TransactionBase implements Expense {\n  static className = 'Transaction';\n  /**\n   * @TODO rename to childTransactions\n   */\n  @Type(() => Transaction)\n  transactions: Transaction[] = [];\n\n  @Type(() => Property)\n  property: Property;\n\n  @Type(() => ChartAccounts)\n  chartAccounts: ChartAccounts;\n\n  @Type(() => IncomeSource)\n  incomeSource: IncomeSource;\n\n  @Type(() => TransactionMetaField)\n  metaFields: TransactionMetaField[] = [];\n\n  @Type(() => Transaction)\n  transfer: Transaction;\n\n  @Type(() => Loan)\n  loan: Loan;\n\n  @Type(() => Date)\n  date: Date;\n\n  @Type(() => TransactionAllocation)\n  allocations: TransactionAllocation[] = [];\n\n  @Type(() => SoleInvoiceItem)\n  invoiceItem: SoleInvoiceItem;\n\n  @Type(() => SoleBusiness)\n  business: SoleBusiness;\n\n  @Transform(({ value }) => +value)\n  tax = 0;\n\n  operation: TransactionOperationEnum = TransactionOperationEnum.FIND_AND_MATCH;\n  claimPercent = 100;\n  amount = 0;\n\n  get invoiceId(): number {\n    return this.invoiceItem?.invoice.id;\n  }\n\n  isDebit(): boolean {\n    return this.type === TransactionTypeEnum.DEBIT;\n  }\n\n  isCredit(): boolean {\n    return this.type === TransactionTypeEnum.CREDIT;\n  }\n\n  /**\n   * @TODO move to base collection\n   */\n  isIncome(): boolean {\n    // @TODO not used\n    if (!this.chartAccounts) {\n      return this.isCredit();\n    }\n\n    return CHART_ACCOUNTS_CATEGORIES.income.includes(this.chartAccounts.category);\n  }\n\n  /**\n   * @TODO move to base collection\n   */\n  isExpense(): boolean {\n    // @TODO not used\n    if (!this.chartAccounts) {\n      return this.isDebit();\n    }\n\n    return CHART_ACCOUNTS_CATEGORIES.expense.includes(this.chartAccounts.category);\n  }\n\n  isPersonal(): boolean {\n    return CHART_ACCOUNTS_CATEGORIES.personal.includes(this.chartAccounts.category);\n  }\n\n  isInterest(): boolean {\n    return this.chartAccounts.id === ChartAccountsListEnum.INTEREST_ON_LOAN;\n  }\n\n  /**\n   * Check if transaction type is vehicle\n   */\n  isVehicleTransaction(): boolean {\n    return this.chartAccounts.isVehicleExpense();\n  }\n\n  get taxFreeComponent(): number {\n    return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.TAX_FREE_COMPONENT);\n  }\n\n  get frankingCredit(): number {\n    return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.FRANKING_CREDIT);\n  }\n\n  get eligibleForReduction(): number {\n    return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.ELIGIBLE_FOR_REDUCTION);\n  }\n\n  get untaxedElement(): number {\n    return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.UNTAXED_ELEMENT);\n  }\n\n  /**\n   * Check if transaction reconcile operation if TRANSFER\n   * @TODO bad usage of get (and all is* methods), getter should sound like a noun\n   */\n  get isTransfer(): boolean {\n    return this.operation === TransactionOperationEnum.TRANSFER;\n  }\n\n  isFindAndMatch(): boolean {\n    return this.operation === TransactionOperationEnum.FIND_AND_MATCH;\n  }\n\n  get debit(): number {\n    return this.isDebit() ? Math.abs(this.grossAmountWithoutGst) : 0;\n  }\n\n  get credit(): number {\n    return this.isCredit() ? Math.abs(this.grossAmountWithoutGst) : 0;\n  }\n\n  /**\n   * Get value of transaction meta field\n   * @param field for which value should be returned\n   * @Todo modify 'metaFields' property from array to Collection\n   */\n  getMetaFieldValue(field: ChartAccountsMetaFieldListEnum): number {\n    return +this.metaFields.find((transactionMetaField: TransactionMetaField): boolean => transactionMetaField.chartAccountsMetaField.id === field)?.value || 0;\n  }\n\n  isCash(): boolean {\n    return this.source === TransactionSourceEnum.CASH;\n  }\n\n  canFindAndMatch(allocations: TransactionAllocationCollection): boolean {\n    return !this.parentTransaction\n      && !this.isCash()\n      && !(this.isSoleTank() && this.isIncome())\n      && this.isEditable()\n      && !this.isAllocated(allocations);\n  }\n\n  /**\n   * Create Depreciation instance based on Transaction\n   */\n  toDepreciation(): Depreciation {\n    return plainToClass(Depreciation, {\n      date: this.date,\n      amount: Math.abs(this.amount),\n      chartAccounts: this.chartAccounts,\n      description: this.description,\n      type: this.chartAccounts.isPropertyCapitalWorks() ? DepreciationTypeEnum.CAPITAL_WORKS : DepreciationTypeEnum.PLANT_EQUIPMENT,\n      claimPercent: this.claimPercent,\n      property: this.property,\n      calculation: this.property ? this.property.depreciationCalculation : DepreciationCalculationEnum.PRIME_COST,\n      transactions: [this],\n      business: this.business,\n    });\n  }\n\n  /**\n   * Check if transaction is completely allocated\n   */\n  isAllocated(allocations: TransactionAllocationCollection): boolean {\n    return Math.abs(this.getAllocatedAmount(allocations)) - Math.abs(this.netAmount) >= 0;\n  }\n\n  getAllocatedAmount(allocations: TransactionAllocationCollection): number {\n    return allocations.filterBy('transaction.id', this.id).sumBy('amount');\n  }\n\n  getUnallocatedAmount(allocations: TransactionAllocationCollection): number {\n    return this.netAmount - this.getAllocatedAmount(allocations);\n  }\n\n  /**\n   * Total transaction amount including taxes and other additional amounts\n   */\n  get grossAmount(): number {\n    return this.grossAmountWithoutGst + this.gstAmount;\n  }\n\n  get grossAmountWithoutGst(): number {\n    let grossAmount = this.amount + this.tax;\n    if (this.isExpense()) {\n      return grossAmount;\n    }\n\n    // included transactions affect parent transaction amount and as a result grossAmount, skip to avoid double sum\n    const adjustments = new Collection(this.transactions)\n      .filter(transaction => !transaction.chartAccounts?.isAdjustmentIncluded());\n\n    const income = adjustments.filter(transaction => transaction.isIncome()).sumBy('amount');\n    const expense = adjustments.filter(transaction => transaction.isExpense()).sumBy('amount', true);\n    // all adjustments except property income increase grossIncome\n    grossAmount += expense + (this.isPropertyTank() ? -income : income);\n\n    if (this.isWorkTank() || this.isHoldingTank()) {\n      grossAmount += this.frankingCredit - this.taxFreeComponent - this.eligibleForReduction;\n    }\n\n    return grossAmount;\n  }\n\n  get grossClaimAmountWithoutGst(): number {\n    return this.grossAmountWithoutGst * this.claimRatio;\n  }\n\n  /**\n   * @TODO vik confusing logic demanded by Nicole, we need a better ux to fix it\n   * netAmount matches received payment (bankTransaction amount), includes gst and salary included adjustments\n   * ie user received 1000$ salary including 100$ tips. NetAmount=1000$, amount=900$, tips=100$\n   */\n  get netAmount(): number {\n    return new Collection(this.transactions)\n      .filter((t) => t.chartAccounts?.isAdjustmentIncluded())\n      .sumBy('amount') + this.amountWithGst;\n  }\n\n  /**\n   * most of the transactions could have only positive or negative amount depends on chartAccounts, so we ignore\n   * user's choice and transform amount, but there are exceptions like advance (negative or positive amount)\n   */\n  ignoreSign(): boolean {\n    return !(this.chartAccounts?.id in ChartAccountsKeepSign);\n  }\n\n  setParent(transaction: Transaction): void {\n    this.description = this.chartAccounts.name;\n    this.date = transaction.date;\n    this.claimPercent = transaction.claimPercent;\n    this.property = transaction.property;\n    this.loan = transaction.loan;\n    this.incomeSource = transaction.incomeSource;\n    this.business = transaction.business;\n  }\n\n  isEditable(): boolean {\n    return !ChartAccounts.systemList.includes(this.chartAccounts.id);\n  }\n}\n"]}

package/esm2022/src/lib/models/user/index.mjs

@@ -0,0 +1,10 @@
+export * from './my-account-history-initiated-by.enum';
+export * from './my-account-history-status.enum';
+export * from './my-account-history-type.enum';
+export * from './my-account-history';
+export * from './occupation';
+export * from './user-roles.const';
+export * from './user-to-register';
+export * from './user-work-position.const';
+export * from './user';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvbW9kZWxzL3VzZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3Q0FBd0MsQ0FBQztBQUN2RCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbXktYWNjb3VudC1oaXN0b3J5LWluaXRpYXRlZC1ieS5lbnVtJztcbmV4cG9ydCAqIGZyb20gJy4vbXktYWNjb3VudC1oaXN0b3J5LXN0YXR1cy5lbnVtJztcbmV4cG9ydCAqIGZyb20gJy4vbXktYWNjb3VudC1oaXN0b3J5LXR5cGUuZW51bSc7XG5leHBvcnQgKiBmcm9tICcuL215LWFjY291bnQtaGlzdG9yeSc7XG5leHBvcnQgKiBmcm9tICcuL29jY3VwYXRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi91c2VyLXJvbGVzLmNvbnN0JztcbmV4cG9ydCAqIGZyb20gJy4vdXNlci10by1yZWdpc3Rlcic7XG5leHBvcnQgKiBmcm9tICcuL3VzZXItd29yay1wb3NpdGlvbi5jb25zdCc7XG5leHBvcnQgKiBmcm9tICcuL3VzZXInO1xuIl19

package/esm2022/src/lib/models/user/my-account-history-initiated-by.enum.mjs

@@ -0,0 +1,6 @@
+export var MyAccountHistoryInitiatedByEnum;
+(function (MyAccountHistoryInitiatedByEnum) {
+    MyAccountHistoryInitiatedByEnum[MyAccountHistoryInitiatedByEnum["OWNER"] = 0] = "OWNER";
+    MyAccountHistoryInitiatedByEnum[MyAccountHistoryInitiatedByEnum["ACCOUNTANT"] = 1] = "ACCOUNTANT";
+})(MyAccountHistoryInitiatedByEnum || (MyAccountHistoryInitiatedByEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXktYWNjb3VudC1oaXN0b3J5LWluaXRpYXRlZC1ieS5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL21vZGVscy91c2VyL215LWFjY291bnQtaGlzdG9yeS1pbml0aWF0ZWQtYnkuZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSwrQkFHWDtBQUhELFdBQVksK0JBQStCO0lBQ3pDLHVGQUFTLENBQUE7SUFDVCxpR0FBYyxDQUFBO0FBQ2hCLENBQUMsRUFIVywrQkFBK0IsS0FBL0IsK0JBQStCLFFBRzFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gTXlBY2NvdW50SGlzdG9yeUluaXRpYXRlZEJ5RW51bSB7XG4gIE9XTkVSID0gMCxcbiAgQUNDT1VOVEFOVCA9IDFcbn1cbiJdfQ==

package/esm2022/src/lib/models/user/my-account-history-status.enum.mjs

@@ -0,0 +1,6 @@
+export var MyAccountHistoryStatusEnum;
+(function (MyAccountHistoryStatusEnum) {
+    MyAccountHistoryStatusEnum[MyAccountHistoryStatusEnum["SUCCESS"] = 0] = "SUCCESS";
+    MyAccountHistoryStatusEnum[MyAccountHistoryStatusEnum["ERROR"] = 1] = "ERROR";
+})(MyAccountHistoryStatusEnum || (MyAccountHistoryStatusEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXktYWNjb3VudC1oaXN0b3J5LXN0YXR1cy5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL21vZGVscy91c2VyL215LWFjY291bnQtaGlzdG9yeS1zdGF0dXMuZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSwwQkFHWDtBQUhELFdBQVksMEJBQTBCO0lBQ3BDLGlGQUFXLENBQUE7SUFDWCw2RUFBUyxDQUFBO0FBQ1gsQ0FBQyxFQUhXLDBCQUEwQixLQUExQiwwQkFBMEIsUUFHckMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBNeUFjY291bnRIaXN0b3J5U3RhdHVzRW51bSB7XG4gIFNVQ0NFU1MgPSAwLFxuICBFUlJPUiA9IDFcbn1cbiJdfQ==

package/esm2022/src/lib/models/user/my-account-history-type.enum.mjs

@@ -0,0 +1,7 @@
+export var MyAccountHistoryTypeEnum;
+(function (MyAccountHistoryTypeEnum) {
+    MyAccountHistoryTypeEnum[MyAccountHistoryTypeEnum["REVIEW"] = 0] = "REVIEW";
+    MyAccountHistoryTypeEnum[MyAccountHistoryTypeEnum["UPGRADE_PLAN"] = 1] = "UPGRADE_PLAN";
+    MyAccountHistoryTypeEnum[MyAccountHistoryTypeEnum["UPLOAD_DOCUMENT"] = 2] = "UPLOAD_DOCUMENT";
+})(MyAccountHistoryTypeEnum || (MyAccountHistoryTypeEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXktYWNjb3VudC1oaXN0b3J5LXR5cGUuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9tb2RlbHMvdXNlci9teS1hY2NvdW50LWhpc3RvcnktdHlwZS5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLHdCQUlYO0FBSkQsV0FBWSx3QkFBd0I7SUFDbEMsMkVBQVUsQ0FBQTtJQUNWLHVGQUFnQixDQUFBO0lBQ2hCLDZGQUFtQixDQUFBO0FBQ3JCLENBQUMsRUFKVyx3QkFBd0IsS0FBeEIsd0JBQXdCLFFBSW5DIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gTXlBY2NvdW50SGlzdG9yeVR5cGVFbnVtIHtcbiAgUkVWSUVXID0gMCxcbiAgVVBHUkFERV9QTEFOID0gMSxcbiAgVVBMT0FEX0RPQ1VNRU5UID0gMlxufVxuIl19

package/esm2022/src/lib/models/user/my-account-history.mjs

@@ -0,0 +1,3 @@
+export class MyAccountHistory {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXktYWNjb3VudC1oaXN0b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL21vZGVscy91c2VyL215LWFjY291bnQtaGlzdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLE9BQU8sZ0JBQWdCO0NBTzVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTXlBY2NvdW50SGlzdG9yeVR5cGVFbnVtIH0gZnJvbSAnLi9teS1hY2NvdW50LWhpc3RvcnktdHlwZS5lbnVtJztcbmltcG9ydCB7IE15QWNjb3VudEhpc3RvcnlJbml0aWF0ZWRCeUVudW0gfSBmcm9tICcuL215LWFjY291bnQtaGlzdG9yeS1pbml0aWF0ZWQtYnkuZW51bSc7XG5pbXBvcnQgeyBNeUFjY291bnRIaXN0b3J5U3RhdHVzRW51bSB9IGZyb20gJy4vbXktYWNjb3VudC1oaXN0b3J5LXN0YXR1cy5lbnVtJztcblxuZXhwb3J0IGNsYXNzIE15QWNjb3VudEhpc3Rvcnkge1xuICBpZDogbnVtYmVyO1xuICBuYW1lOiBzdHJpbmc7XG4gIHR5cGU6IE15QWNjb3VudEhpc3RvcnlUeXBlRW51bTtcbiAgaW5pdGlhdGVkQnk6IE15QWNjb3VudEhpc3RvcnlJbml0aWF0ZWRCeUVudW07XG4gIGRhdGU6IERhdGU7XG4gIHN0YXR1czogTXlBY2NvdW50SGlzdG9yeVN0YXR1c0VudW07XG59XG4iXX0=

package/esm2022/src/lib/models/user/occupation.mjs

@@ -0,0 +1,4 @@
+import { Occupation as OccupationBase } from '../../db/Models/client/occupation';
+export class Occupation extends OccupationBase {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2NjdXBhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9tb2RlbHMvdXNlci9vY2N1cGF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLElBQUksY0FBYyxFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFFakYsTUFBTSxPQUFPLFVBQVcsU0FBUSxjQUFjO0NBQzdDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT2NjdXBhdGlvbiBhcyBPY2N1cGF0aW9uQmFzZSB9IGZyb20gJy4uLy4uL2RiL01vZGVscy9jbGllbnQvb2NjdXBhdGlvbic7XG5cbmV4cG9ydCBjbGFzcyBPY2N1cGF0aW9uIGV4dGVuZHMgT2NjdXBhdGlvbkJhc2Uge1xufVxuIl19

package/esm2022/src/lib/models/user/user-roles.const.mjs

@@ -0,0 +1,20 @@
+import { UserRolesEnum } from 'taxtank-core/common';
+/**
+ * role hierarchy
+ */
+export const USER_ROLES = {
+    ROLE_FIRM_OWNER: [UserRolesEnum.FIRM_OWNER, UserRolesEnum.FIRM_MANAGER, UserRolesEnum.ACCOUNTANT, UserRolesEnum.ADVISOR],
+    ROLE_FIRM_MANAGER: [UserRolesEnum.FIRM_MANAGER, UserRolesEnum.ACCOUNTANT, UserRolesEnum.ADVISOR],
+    ROLE_EMPLOYEE: [UserRolesEnum.ACCOUNTANT, UserRolesEnum.ADVISOR],
+    ROLE_ACCOUNTANT: [UserRolesEnum.ACCOUNTANT],
+    ROLE_ADVISOR: [UserRolesEnum.ADVISOR],
+    // @TODO makes no sense, these roles can't be hierarchical
+    ROLE_CLIENT: [UserRolesEnum.CLIENT],
+    ROLE_USER_SUBSCRIPTION: [UserRolesEnum.SUBSCRIPTION],
+    ROLE_USER_WORK: [UserRolesEnum.WORK_TANK],
+    ROLE_USER_PROPERTY: [UserRolesEnum.PROPERTY_TANK],
+    ROLE_USER_SOLE: [UserRolesEnum.SOLE_TANK],
+    ROLE_USER_HOLDING: [UserRolesEnum.HOLDING_TANK],
+    ROLE_PREVIOUS_ADMIN: [UserRolesEnum.SWITCH_USER],
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/models/user/user-to-register.mjs

@@ -0,0 +1,6 @@
+/**
+ * Class with basic information about registering user
+ */
+export class UserToRegister {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci10by1yZWdpc3Rlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9tb2RlbHMvdXNlci91c2VyLXRvLXJlZ2lzdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxPQUFPLGNBQWM7Q0FHMUIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENsYXNzIHdpdGggYmFzaWMgaW5mb3JtYXRpb24gYWJvdXQgcmVnaXN0ZXJpbmcgdXNlclxuICovXG5leHBvcnQgY2xhc3MgVXNlclRvUmVnaXN0ZXIge1xuICBmaXJzdE5hbWU6IHN0cmluZztcbiAgZW1haWw6IHN0cmluZztcbn1cbiJdfQ==

package/esm2022/src/lib/models/user/user-work-position.const.mjs

@@ -0,0 +1,7 @@
+import { UserRolesEnum } from 'taxtank-core/common';
+export const USER_WORK_POSITION = {
+    [UserRolesEnum.EMPLOYEE]: 'Employee',
+    [UserRolesEnum.FIRM_MANAGER]: 'Manager',
+    [UserRolesEnum.FIRM_OWNER]: 'Firm Owner'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci13b3JrLXBvc2l0aW9uLmNvbnN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL21vZGVscy91c2VyL3VzZXItd29yay1wb3NpdGlvbi5jb25zdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFcEQsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQTRCO0lBQ3pELENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxFQUFFLFVBQVU7SUFDcEMsQ0FBQyxhQUFhLENBQUMsWUFBWSxDQUFDLEVBQUUsU0FBUztJQUN2QyxDQUFDLGFBQWEsQ0FBQyxVQUFVLENBQUMsRUFBRSxZQUFZO0NBQ3pDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBVc2VyUm9sZXNFbnVtIH0gZnJvbSAndGF4dGFuay1jb3JlL2NvbW1vbic7XHJcblxyXG5leHBvcnQgY29uc3QgVVNFUl9XT1JLX1BPU0lUSU9OOiB7W2tleTogc3RyaW5nXTogc3RyaW5nfSA9IHtcclxuICBbVXNlclJvbGVzRW51bS5FTVBMT1lFRV06ICdFbXBsb3llZScsXHJcbiAgW1VzZXJSb2xlc0VudW0uRklSTV9NQU5BR0VSXTogJ01hbmFnZXInLFxyXG4gIFtVc2VyUm9sZXNFbnVtLkZJUk1fT1dORVJdOiAnRmlybSBPd25lcidcclxufTtcclxuIl19