taxtank-core 0.32.89 → 0.33.2

package/esm2022/src/lib/models/tax-summary/tax-summary.mjs

@@ -0,0 +1,152 @@
+import { __decorate } from "tslib";
+import { TaxSummarySection } from './tax-summary-section';
+import { Type } from 'class-transformer';
+import { ReportItemCollection, TAX_RETURN_CATEGORIES } from '../../collections';
+import { TaxReturnCategoryListEnum } from '../../db/Enums';
+import { TaxSummarySectionEnum } from '../../db/Enums/tax-summary-section.enum';
+/**
+ * @Todo refactor with base model when it will be provided
+ * Tax summary report structure
+ */
+export class TaxSummary {
+    get sections() {
+        return [this.work, this.property, this.other, this.sole, this.summary];
+    }
+    getReportItems(sections) {
+        return new ReportItemCollection([].concat(...sections.map((section) => section.items.toArray())));
+    }
+    get taxPercent() {
+        // Check if netAmount is not 0 to avoid division by zero
+        if (!this.summary.netAmount) {
+            return 0;
+        }
+        return this.summary.items.findByCategory(TaxReturnCategoryListEnum.GROSS_TAX_PAYABLE).amount / this.summary.netAmount;
+    }
+    /**
+     * Work Net Cash = Income - tax withheld - expenses - interest
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+     */
+    get workNetCash() {
+        const taxWithheld = this.summary.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.work.taxWithheld, TaxSummarySectionEnum.WORK_TANK);
+        return this.workNetTotal - Math.abs(taxWithheld);
+    }
+    get income() {
+        return this.getReportItems([this.work, this.property, this.sole, this.other]).sumByCategories([
+            ...TAX_RETURN_CATEGORIES.work.income,
+            ...TAX_RETURN_CATEGORIES.property.income,
+            ...TAX_RETURN_CATEGORIES.sole.income,
+            ...TAX_RETURN_CATEGORIES.other.income,
+        ]);
+    }
+    get expense() {
+        return this.getReportItems([this.work, this.property, this.sole, this.other]).sumByCategories([
+            ...TAX_RETURN_CATEGORIES.work.expenses,
+            ...TAX_RETURN_CATEGORIES.property.expenses,
+            ...TAX_RETURN_CATEGORIES.sole.expenses,
+            ...TAX_RETURN_CATEGORIES.other.expenses,
+        ]);
+    }
+    get netCash() {
+        return this.workNetCash + this.propertyNetCash + this.soleNetCash + this.otherNetCash;
+    }
+    get netTotal() {
+        return this.workNetTotal + this.propertyNetTotal + this.soleNetTotal + this.otherNetTotal;
+    }
+    /**
+     * Work Net Total = Income - expenses - interest
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+     */
+    get workNetTotal() {
+        const income = this.work.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.work.income, TaxSummarySectionEnum.WORK_TANK);
+        const expenses = this.work.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.work.expenses, TaxSummarySectionEnum.WORK_TANK);
+        const interest = this.summary.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.work.interest, TaxSummarySectionEnum.WORK_TANK);
+        return income - Math.abs(expenses) - Math.abs(interest);
+    }
+    /**
+     * Property Net Cash (Cash Position) = Rental Income - expenses - interest
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+     */
+    get propertyNetCash() {
+        const income = this.property.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.property.income, TaxSummarySectionEnum.PROPERTY_TANK);
+        const expenses = this.property.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.property.expenses, TaxSummarySectionEnum.PROPERTY_TANK);
+        const interest = this.property.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.property.interest, TaxSummarySectionEnum.PROPERTY_TANK);
+        return income - Math.abs(expenses) - Math.abs(interest);
+    }
+    /**
+     * Property Net Total (Tax Position) = Rental Income - expenses - interest - depreciation
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+     */
+    get propertyNetTotal() {
+        const depreciation = this.property.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.property.depreciation, TaxSummarySectionEnum.PROPERTY_TANK);
+        return this.propertyNetCash - Math.abs(depreciation);
+    }
+    /**
+     * Other Net Cash = gross income – expenses – tax withheld - tax instalments
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+     */
+    get otherNetCash() {
+        const income = this.other.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.other.income, TaxSummarySectionEnum.OTHER_TANK);
+        const expenses = this.other.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.other.expenses, TaxSummarySectionEnum.OTHER_TANK);
+        const taxWithheld = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.TAX_WITHHELD], TaxSummarySectionEnum.OTHER_TANK);
+        const taxInstalments = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.TAX_INSTALMENTS], TaxSummarySectionEnum.OTHER_TANK);
+        return income - Math.abs(expenses) - Math.abs(taxWithheld) - Math.abs(taxInstalments);
+    }
+    /**
+     * Other Net Total = Gross income - expenses + tax offsets + tax instalments + franking credits
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+     */
+    get otherNetTotal() {
+        const income = this.other.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.other.income, TaxSummarySectionEnum.OTHER_TANK);
+        const expenses = this.other.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.other.expenses, TaxSummarySectionEnum.OTHER_TANK);
+        const taxOffsets = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.TAX_OFFSETS], TaxSummarySectionEnum.SUMMARY);
+        const taxInstallments = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.TAX_INSTALMENTS], TaxSummarySectionEnum.OTHER_TANK);
+        const frankingCredits = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.FRANKING_CREDITS], TaxSummarySectionEnum.OTHER_TANK);
+        return income - Math.abs(expenses) + Math.abs(taxOffsets) + Math.abs(taxInstallments) + Math.abs(frankingCredits);
+    }
+    /**
+     * Sole Net Cash = gross income – expenses
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+     */
+    get soleNetCash() {
+        const depreciation = this.sole.items.sumByCategories(TAX_RETURN_CATEGORIES.sole.depreciation);
+        const loss = this.sole.items.sumByCategories(TAX_RETURN_CATEGORIES.sole.loss);
+        const lossCurrent = this.sole.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.sole.lossCurrent, TaxSummarySectionEnum.SOLE_TANK);
+        return this.soleNetTotal - depreciation - loss + lossCurrent;
+    }
+    /**
+     * Sole Net Total = Gross income - expenses
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main
+     */
+    get soleNetTotal() {
+        // income + expenses + depreciation + loss
+        const profit = this.sole.items.sumByCategories([TaxReturnCategoryListEnum.BUSINESS_INCOME_OR_LOSS]);
+        const lossCurrent = this.sole.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.sole.lossCurrent, TaxSummarySectionEnum.SOLE_TANK);
+        return profit - lossCurrent;
+    }
+    getDeferredBusinessLoss(business) {
+        return this.sole.items
+            .findByCategory(TaxReturnCategoryListEnum.DEFERRED_BUSINESS_LOSSES).items
+            .findBy('title', `Item 15c - ${business.name}`)?.amount;
+    }
+    getBusinessCloseBalance(business) {
+        return this.sole.items
+            .findByCategory(TaxReturnCategoryListEnum.BUSINESS_INCOME_OR_LOSS).items
+            .findBy('title', `Item 15c - ${business.name}`)?.amount;
+    }
+}
+__decorate([
+    Type(() => TaxSummarySection)
+], TaxSummary.prototype, "work", void 0);
+__decorate([
+    Type(() => TaxSummarySection)
+], TaxSummary.prototype, "property", void 0);
+__decorate([
+    Type(() => TaxSummarySection)
+], TaxSummary.prototype, "other", void 0);
+__decorate([
+    Type(() => TaxSummarySection)
+], TaxSummary.prototype, "sole", void 0);
+__decorate([
+    Type(() => TaxSummarySection)
+], TaxSummary.prototype, "summary", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tax-summary.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/models/tax-summary/tax-summary.ts"],"names":[],"mappings":"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","sourcesContent":["import { TaxSummarySection } from './tax-summary-section';\nimport { Type } from 'class-transformer';\nimport { ReportItemCollection, TAX_RETURN_CATEGORIES } from '../../collections';\nimport { TaxReturnCategoryListEnum } from '../../db/Enums';\nimport { TaxSummarySectionEnum } from '../../db/Enums/tax-summary-section.enum';\nimport { SoleBusiness } from '../sole';\n\n/**\n * @Todo refactor with base model when it will be provided\n * Tax summary report structure\n */\nexport class TaxSummary {\n  @Type(() => TaxSummarySection)\n  work: TaxSummarySection;\n\n  @Type(() => TaxSummarySection)\n  property: TaxSummarySection;\n\n  @Type(() => TaxSummarySection)\n  other: TaxSummarySection;\n\n  @Type(() => TaxSummarySection)\n  sole: TaxSummarySection;\n\n  @Type(() => TaxSummarySection)\n  summary: TaxSummarySection;\n\n  projectedTaxPosition: number;\n\n  get sections(): TaxSummarySection[] {\n    return [this.work, this.property, this.other, this.sole, this.summary];\n  }\n\n  getReportItems(sections: TaxSummarySection[]): ReportItemCollection {\n    return new ReportItemCollection([].concat(...sections.map((section) => section.items.toArray())));\n  }\n\n  get taxPercent(): number {\n    // Check if netAmount is not 0 to avoid division by zero\n    if (!this.summary.netAmount) {\n      return 0;\n    }\n\n    return this.summary.items.findByCategory(TaxReturnCategoryListEnum.GROSS_TAX_PAYABLE).amount / this.summary.netAmount;\n  }\n\n  /**\n   * Work Net Cash = Income - tax withheld - expenses - interest\n   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main\n   */\n  get workNetCash(): number {\n    const taxWithheld: number = this.summary.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.work.taxWithheld, TaxSummarySectionEnum.WORK_TANK);\n\n    return this.workNetTotal - Math.abs(taxWithheld);\n  }\n\n  get income(): number {\n    return this.getReportItems([this.work, this.property, this.sole, this.other]).sumByCategories([\n      ...TAX_RETURN_CATEGORIES.work.income,\n      ...TAX_RETURN_CATEGORIES.property.income,\n      ...TAX_RETURN_CATEGORIES.sole.income,\n      ...TAX_RETURN_CATEGORIES.other.income,\n    ]);\n  }\n\n  get expense(): number {\n    return this.getReportItems([this.work, this.property, this.sole, this.other]).sumByCategories([\n      ...TAX_RETURN_CATEGORIES.work.expenses,\n      ...TAX_RETURN_CATEGORIES.property.expenses,\n      ...TAX_RETURN_CATEGORIES.sole.expenses,\n      ...TAX_RETURN_CATEGORIES.other.expenses,\n    ]);\n  }\n\n  get netCash(): number {\n    return this.workNetCash + this.propertyNetCash + this.soleNetCash + this.otherNetCash;\n  }\n\n  get netTotal(): number {\n    return this.workNetTotal + this.propertyNetTotal + this.soleNetTotal + this.otherNetTotal;\n  }\n\n  /**\n   * Work Net Total = Income - expenses - interest\n   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main\n   */\n  get workNetTotal(): number {\n    const income: number = this.work.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.work.income, TaxSummarySectionEnum.WORK_TANK);\n    const expenses: number = this.work.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.work.expenses, TaxSummarySectionEnum.WORK_TANK);\n    const interest: number = this.summary.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.work.interest, TaxSummarySectionEnum.WORK_TANK);\n\n    return income - Math.abs(expenses) - Math.abs(interest);\n  }\n\n  /**\n   * Property Net Cash (Cash Position) = Rental Income - expenses - interest\n   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main\n   */\n  get propertyNetCash(): number {\n    const income: number = this.property.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.property.income, TaxSummarySectionEnum.PROPERTY_TANK);\n    const expenses: number = this.property.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.property.expenses, TaxSummarySectionEnum.PROPERTY_TANK);\n    const interest: number = this.property.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.property.interest, TaxSummarySectionEnum.PROPERTY_TANK);\n\n    return income - Math.abs(expenses) - Math.abs(interest);\n  }\n\n  /**\n   * Property Net Total (Tax Position) = Rental Income - expenses - interest - depreciation\n   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main\n   */\n  get propertyNetTotal(): number {\n    const depreciation: number = this.property.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.property.depreciation, TaxSummarySectionEnum.PROPERTY_TANK);\n\n    return this.propertyNetCash - Math.abs(depreciation);\n  }\n\n  /**\n   * Other Net Cash = gross income – expenses – tax withheld - tax instalments\n   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main\n   */\n  get otherNetCash(): number {\n    const income: number = this.other.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.other.income, TaxSummarySectionEnum.OTHER_TANK);\n    const expenses: number = this.other.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.other.expenses, TaxSummarySectionEnum.OTHER_TANK);\n    const taxWithheld: number = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.TAX_WITHHELD], TaxSummarySectionEnum.OTHER_TANK);\n    const taxInstalments: number = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.TAX_INSTALMENTS], TaxSummarySectionEnum.OTHER_TANK);\n\n    return income - Math.abs(expenses) - Math.abs(taxWithheld) - Math.abs(taxInstalments);\n  }\n\n  /**\n   * Other Net Total = Gross income - expenses + tax offsets + tax instalments + franking credits\n   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main\n   */\n  get otherNetTotal(): number {\n    const income: number = this.other.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.other.income, TaxSummarySectionEnum.OTHER_TANK);\n    const expenses: number = this.other.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.other.expenses, TaxSummarySectionEnum.OTHER_TANK);\n    const taxOffsets: number = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.TAX_OFFSETS], TaxSummarySectionEnum.SUMMARY);\n    const taxInstallments: number = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.TAX_INSTALMENTS], TaxSummarySectionEnum.OTHER_TANK);\n    const frankingCredits: number = this.summary.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.FRANKING_CREDITS], TaxSummarySectionEnum.OTHER_TANK);\n\n    return income - Math.abs(expenses) + Math.abs(taxOffsets) + Math.abs(taxInstallments) + Math.abs(frankingCredits);\n  }\n\n  /**\n   * Sole Net Cash = gross income – expenses\n   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main\n   */\n  get soleNetCash(): number {\n    const depreciation: number = this.sole.items.sumByCategories(TAX_RETURN_CATEGORIES.sole.depreciation);\n    const loss: number = this.sole.items.sumByCategories(TAX_RETURN_CATEGORIES.sole.loss);\n    const lossCurrent: number = this.sole.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.sole.lossCurrent, TaxSummarySectionEnum.SOLE_TANK);\n\n    return this.soleNetTotal - depreciation - loss + lossCurrent;\n  }\n\n  /**\n   * Sole Net Total = Gross income - expenses\n   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217677990/Dashboard+Main\n   */\n  get soleNetTotal(): number {\n    // income + expenses + depreciation + loss\n    const profit: number = this.sole.items.sumByCategories([TaxReturnCategoryListEnum.BUSINESS_INCOME_OR_LOSS]);\n    const lossCurrent: number = this.sole.items.sumByCategoriesAndSection(TAX_RETURN_CATEGORIES.sole.lossCurrent, TaxSummarySectionEnum.SOLE_TANK);\n\n    return profit - lossCurrent;\n  }\n\n  getDeferredBusinessLoss(business: SoleBusiness): number {\n    return this.sole.items\n      .findByCategory(TaxReturnCategoryListEnum.DEFERRED_BUSINESS_LOSSES).items\n      .findBy('title', `Item 15c - ${business.name}`)?.amount;\n  }\n\n  getBusinessCloseBalance(business: SoleBusiness): number {\n    return this.sole.items\n      .findByCategory(TaxReturnCategoryListEnum.BUSINESS_INCOME_OR_LOSS).items\n      .findBy('title', `Item 15c - ${business.name}`)?.amount;\n  }\n}\n"]}

package/esm2022/src/lib/models/toast/toast-type.enum.mjs

@@ -0,0 +1,8 @@
+export var ToastTypeEnum;
+(function (ToastTypeEnum) {
+    ToastTypeEnum[ToastTypeEnum["INFO"] = 0] = "INFO";
+    ToastTypeEnum[ToastTypeEnum["SUCCESS"] = 1] = "SUCCESS";
+    ToastTypeEnum[ToastTypeEnum["WARNING"] = 2] = "WARNING";
+    ToastTypeEnum[ToastTypeEnum["ERROR"] = 3] = "ERROR";
+})(ToastTypeEnum || (ToastTypeEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9hc3QtdHlwZS5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL21vZGVscy90b2FzdC90b2FzdC10eXBlLmVudW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksYUFLWDtBQUxELFdBQVksYUFBYTtJQUN2QixpREFBSSxDQUFBO0lBQ0osdURBQU8sQ0FBQTtJQUNQLHVEQUFPLENBQUE7SUFDUCxtREFBSyxDQUFBO0FBQ1AsQ0FBQyxFQUxXLGFBQWEsS0FBYixhQUFhLFFBS3hCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gVG9hc3RUeXBlRW51bSB7XG4gIElORk8sXG4gIFNVQ0NFU1MsXG4gIFdBUk5JTkcsXG4gIEVSUk9SXG59XG4iXX0=

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

@@ -0,0 +1,10 @@
+/**
+ * Common toast message class
+ */
+export class Toast {
+    constructor() {
+        this.duration = 3000;
+        this.autoClose = true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9hc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvbW9kZWxzL3RvYXN0L3RvYXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOztHQUVHO0FBQ0gsTUFBTSxPQUFPLEtBQUs7SUFBbEI7UUFJRSxhQUFRLEdBQUcsSUFBSSxDQUFDO1FBQ2hCLGNBQVMsR0FBRyxJQUFJLENBQUM7SUFJbkIsQ0FBQztDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVG9hc3RUeXBlRW51bSB9IGZyb20gJy4vdG9hc3QtdHlwZS5lbnVtJztcblxuLyoqXG4gKiBDb21tb24gdG9hc3QgbWVzc2FnZSBjbGFzc1xuICovXG5leHBvcnQgY2xhc3MgVG9hc3Qge1xuICB0eXBlOiBUb2FzdFR5cGVFbnVtO1xuICB0aXRsZTogc3RyaW5nO1xuICBtZXNzYWdlOiBzdHJpbmc7XG4gIGR1cmF0aW9uID0gMzAwMDtcbiAgYXV0b0Nsb3NlID0gdHJ1ZTtcbiAgZGF0ZTogRGF0ZTtcbiAgb25DbG9zZUNsaWNrOiAoKSA9PiB7fTtcbiAgb25DVEFDbGljazogKCkgPT4ge307XG59XG4iXX0=

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

@@ -0,0 +1,40 @@
+import { __decorate } from "tslib";
+import { AllocationRuleCondition as AllocationRuleConditionBase } from '../../db/Models/transaction/allocation-rule-condition';
+import { AllocationRuleConditionComparisonOperatorEnum, AllocationRuleConditionFieldEnum } from '../../db/Enums';
+import { Transform } from 'class-transformer';
+export class AllocationRuleCondition extends AllocationRuleConditionBase {
+    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;
+    }
+}
+__decorate([
+    Transform(({ value }) => value.toString(), { toPlainOnly: true })
+], AllocationRuleCondition.prototype, "value", void 0);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsb2NhdGlvbi1ydWxlLWNvbmRpdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9tb2RlbHMvdHJhbnNhY3Rpb24vYWxsb2NhdGlvbi1ydWxlLWNvbmRpdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFFLHVCQUF1QixJQUFJLDJCQUEyQixFQUFFLE1BQU0sdURBQXVELENBQUM7QUFFL0gsT0FBTyxFQUFFLDZDQUE2QyxFQUFFLGdDQUFnQyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDakgsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRTlDLE1BQU0sT0FBTyx1QkFBd0IsU0FBUSwyQkFBMkI7SUFJdEUsb0JBQW9CLENBQUMsZUFBZ0M7UUFDbkQsT0FBTyxJQUFJLENBQUMsS0FBSyxLQUFLLGdDQUFnQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLDRCQUE0QixDQUFDLGVBQWUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsaUNBQWlDLENBQUMsZUFBZSxDQUFDLENBQUM7SUFDL0ssQ0FBQztJQUVELDRCQUE0QixDQUFDLGVBQWdDO1FBQzNELHNDQUFzQztRQUN0QyxNQUFNLEtBQUssR0FBVyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUM7UUFFbEMsUUFBUSxJQUFJLENBQUMsa0JBQWtCLEVBQUU7WUFDL0IsS0FBSyw2Q0FBNkMsQ0FBQyxNQUFNO2dCQUN2RCxPQUFPLGVBQWUsQ0FBQyxNQUFNLEtBQUssS0FBSyxDQUFDO1lBQzFDLEtBQUssNkNBQTZDLENBQUMsY0FBYztnQkFDL0QsT0FBTyxlQUFlLENBQUMsTUFBTSxJQUFJLEtBQUssQ0FBQztZQUN6QyxLQUFLLDZDQUE2QyxDQUFDLGlCQUFpQjtnQkFDbEUsT0FBTyxlQUFlLENBQUMsTUFBTSxJQUFJLEtBQUssQ0FBQztTQUMxQztRQUVELE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztJQUVELGlDQUFpQyxDQUFDLGVBQWdDO1FBQ2hFLCtDQUErQztRQUMvQyxNQUFNLFdBQVcsR0FBVyxlQUFlLENBQUMsV0FBVyxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBQ3RFLE1BQU0sS0FBSyxHQUFXLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsV0FBVyxFQUFFLENBQUM7UUFFdEQsUUFBUSxJQUFJLENBQUMsa0JBQWtCLEVBQUU7WUFDL0IsS0FBSyw2Q0FBNkMsQ0FBQyxNQUFNO2dCQUN2RCxPQUFPLFdBQVcsS0FBSyxLQUFLLENBQUM7WUFDL0IsS0FBSyw2Q0FBNkMsQ0FBQyxRQUFRO2dCQUN6RCxPQUFPLFdBQVcsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDckMsS0FBSyw2Q0FBNkMsQ0FBQyxNQUFNO2dCQUN2RCxPQUFPLFdBQVcsQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLENBQUM7U0FDeEM7UUFFRCxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7Q0FDRjtBQXRDRztJQURELFNBQVMsQ0FBQyxDQUFDLEVBQUMsS0FBSyxFQUFDLEVBQUUsRUFBRSxDQUFDLEtBQUssQ0FBQyxRQUFRLEVBQUUsRUFBRSxFQUFDLFdBQVcsRUFBRSxJQUFJLEVBQUMsQ0FBQztzREFDOUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBbGxvY2F0aW9uUnVsZUNvbmRpdGlvbiBhcyBBbGxvY2F0aW9uUnVsZUNvbmRpdGlvbkJhc2UgfSBmcm9tICcuLi8uLi9kYi9Nb2RlbHMvdHJhbnNhY3Rpb24vYWxsb2NhdGlvbi1ydWxlLWNvbmRpdGlvbic7XG5pbXBvcnQgeyBCYW5rVHJhbnNhY3Rpb24gfSBmcm9tICcuLi9iYW5rJztcbmltcG9ydCB7IEFsbG9jYXRpb25SdWxlQ29uZGl0aW9uQ29tcGFyaXNvbk9wZXJhdG9yRW51bSwgQWxsb2NhdGlvblJ1bGVDb25kaXRpb25GaWVsZEVudW0gfSBmcm9tICcuLi8uLi9kYi9FbnVtcyc7XG5pbXBvcnQgeyBUcmFuc2Zvcm0gfSBmcm9tICdjbGFzcy10cmFuc2Zvcm1lcic7XG5cbmV4cG9ydCBjbGFzcyBBbGxvY2F0aW9uUnVsZUNvbmRpdGlvbiBleHRlbmRzIEFsbG9jYXRpb25SdWxlQ29uZGl0aW9uQmFzZSB7XG4gIEBUcmFuc2Zvcm0oKHt2YWx1ZX0pID0+IHZhbHVlLnRvU3RyaW5nKCksIHt0b1BsYWluT25seTogdHJ1ZX0pXG4gICAgdmFsdWU6IHN0cmluZztcblxuICBtYXRjaEJhbmtUcmFuc2FjdGlvbihiYW5rVHJhbnNhY3Rpb246IEJhbmtUcmFuc2FjdGlvbik6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLmZpZWxkID09PSBBbGxvY2F0aW9uUnVsZUNvbmRpdGlvbkZpZWxkRW51bS5BTU9VTlQgPyB0aGlzLm1hdGNoQmFua1RyYW5zYWN0aW9uQnlBbW91bnQoYmFua1RyYW5zYWN0aW9uKSA6IHRoaXMubWF0Y2hCYW5rVHJhbnNhY3Rpb25CeURlc2NyaXB0aW9uKGJhbmtUcmFuc2FjdGlvbik7XG4gIH1cblxuICBtYXRjaEJhbmtUcmFuc2FjdGlvbkJ5QW1vdW50KGJhbmtUcmFuc2FjdGlvbjogQmFua1RyYW5zYWN0aW9uKTogYm9vbGVhbiB7XG4gICAgLy8gQW1vdW50IHNob3VsZCBiZSBjb21wYXJlZCBhcyBudW1iZXJcbiAgICBjb25zdCB2YWx1ZTogbnVtYmVyID0gK3RoaXMudmFsdWU7XG5cbiAgICBzd2l0Y2ggKHRoaXMuY29tcGFyaXNvbk9wZXJhdG9yKSB7XG4gICAgICBjYXNlIEFsbG9jYXRpb25SdWxlQ29uZGl0aW9uQ29tcGFyaXNvbk9wZXJhdG9yRW51bS5FUVVBTFM6XG4gICAgICAgIHJldHVybiBiYW5rVHJhbnNhY3Rpb24uYW1vdW50ID09PSB2YWx1ZTtcbiAgICAgIGNhc2UgQWxsb2NhdGlvblJ1bGVDb25kaXRpb25Db21wYXJpc29uT3BlcmF0b3JFbnVtLkVRVUFMU19PUl9MRVNTOlxuICAgICAgICByZXR1cm4gYmFua1RyYW5zYWN0aW9uLmFtb3VudCA8PSB2YWx1ZTtcbiAgICAgIGNhc2UgQWxsb2NhdGlvblJ1bGVDb25kaXRpb25Db21wYXJpc29uT3BlcmF0b3JFbnVtLkVRVUFMU19PUl9HUkVBVEVSOlxuICAgICAgICByZXR1cm4gYmFua1RyYW5zYWN0aW9uLmFtb3VudCA+PSB2YWx1ZTtcbiAgICB9XG5cbiAgICByZXR1cm4gZmFsc2U7XG4gIH1cblxuICBtYXRjaEJhbmtUcmFuc2FjdGlvbkJ5RGVzY3JpcHRpb24oYmFua1RyYW5zYWN0aW9uOiBCYW5rVHJhbnNhY3Rpb24pOiBib29sZWFuIHtcbiAgICAvLyBQcmVwYXJlIHZhbHVlIGFuZCBkZXNjcmlwdGlvbiBmb3IgY29tcGFyaXNvblxuICAgIGNvbnN0IGRlc2NyaXB0aW9uOiBzdHJpbmcgPSBiYW5rVHJhbnNhY3Rpb24uZGVzY3JpcHRpb24udG9Mb3dlckNhc2UoKTtcbiAgICBjb25zdCB2YWx1ZTogc3RyaW5nID0gdGhpcy52YWx1ZS50cmltKCkudG9Mb3dlckNhc2UoKTtcblxuICAgIHN3aXRjaCAodGhpcy5jb21wYXJpc29uT3BlcmF0b3IpIHtcbiAgICAgIGNhc2UgQWxsb2NhdGlvblJ1bGVDb25kaXRpb25Db21wYXJpc29uT3BlcmF0b3JFbnVtLkVRVUFMUzpcbiAgICAgICAgcmV0dXJuIGRlc2NyaXB0aW9uID09PSB2YWx1ZTtcbiAgICAgIGNhc2UgQWxsb2NhdGlvblJ1bGVDb25kaXRpb25Db21wYXJpc29uT3BlcmF0b3JFbnVtLkNPTlRBSU5TOlxuICAgICAgICByZXR1cm4gZGVzY3JpcHRpb24uaW5jbHVkZXModmFsdWUpO1xuICAgICAgY2FzZSBBbGxvY2F0aW9uUnVsZUNvbmRpdGlvbkNvbXBhcmlzb25PcGVyYXRvckVudW0uU1RBUlRTOlxuICAgICAgICByZXR1cm4gZGVzY3JpcHRpb24uc3RhcnRzV2l0aCh2YWx1ZSk7XG4gICAgfVxuXG4gICAgcmV0dXJuIGZhbHNlO1xuICB9XG59XG4iXX0=

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

@@ -0,0 +1,4 @@
+import { AllocationRuleTransactionMetaField as AllocationRuleTransactionMetaFieldBase } from '../../db/Models/transaction/allocation-rule-transaction-meta-field';
+export class AllocationRuleTransactionMetaField extends AllocationRuleTransactionMetaFieldBase {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsb2NhdGlvbi1ydWxlLXRyYW5zYWN0aW9uLW1ldGEtZmllbGQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvbW9kZWxzL3RyYW5zYWN0aW9uL2FsbG9jYXRpb24tcnVsZS10cmFuc2FjdGlvbi1tZXRhLWZpZWxkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxrQ0FBa0MsSUFBSSxzQ0FBc0MsRUFBRSxNQUFNLG9FQUFvRSxDQUFDO0FBRWxLLE1BQU0sT0FBTyxrQ0FBbUMsU0FBUSxzQ0FBc0M7Q0FDN0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBbGxvY2F0aW9uUnVsZVRyYW5zYWN0aW9uTWV0YUZpZWxkIGFzIEFsbG9jYXRpb25SdWxlVHJhbnNhY3Rpb25NZXRhRmllbGRCYXNlIH0gZnJvbSAnLi4vLi4vZGIvTW9kZWxzL3RyYW5zYWN0aW9uL2FsbG9jYXRpb24tcnVsZS10cmFuc2FjdGlvbi1tZXRhLWZpZWxkJztcblxuZXhwb3J0IGNsYXNzIEFsbG9jYXRpb25SdWxlVHJhbnNhY3Rpb25NZXRhRmllbGQgZXh0ZW5kcyBBbGxvY2F0aW9uUnVsZVRyYW5zYWN0aW9uTWV0YUZpZWxkQmFzZSB7XG59XG4iXX0=

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

@@ -0,0 +1,110 @@
+import { __decorate } from "tslib";
+import { AllocationRuleTransaction as AllocationRuleTransactionBase } from '../../db/Models/transaction/allocation-rule-transaction';
+import { ChartAccounts } from '../chart-accounts';
+import { Transform, Type, plainToClass } from 'class-transformer';
+import { AllocationRuleTransactionMetaField } from './allocation-rule-transaction-meta-field';
+import { Loan, Property, SoleBusiness, Transaction } from '../../models';
+import { IncomeSource } from '../income-source';
+import { ChartAccountsListEnum } from '../../db/Enums';
+import { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';
+import { TransactionSourceEnum } from '../../db/Enums/transaction-source.enum';
+export class AllocationRuleTransaction extends AllocationRuleTransactionBase {
+    constructor() {
+        super(...arguments);
+        this.claimPercent = 100;
+        this.tax = 0;
+        this.amount = null;
+    }
+    get amountPercentCoefficient() {
+        return this.amountPercent ? this.amountPercent / 100 : 1;
+    }
+    calculateClaimPercent() {
+        if (!this.chartAccounts) {
+            return null;
+        }
+        let claimPercent = this.chartAccounts.taxablePercent;
+        // Property claim (ownership% x shared%) for property expenses, taxable percent for others
+        if (this.chartAccounts?.isProperty() && this.property) {
+            if (this.chartAccounts.isPropertyExpense() && this.chartAccounts.id !== ChartAccountsListEnum.PLATFORM_FEES) {
+                claimPercent *= this.property?.claimCoefficient;
+            }
+        }
+        return claimPercent;
+    }
+    /**
+     * If rule transaction has amount then split enabled. There is 0 when split disabled
+     */
+    isSplit() {
+        return !!this.amountPercent;
+    }
+    /**
+     * Create Transaction instance based on passed bank transaction and rule transaction
+     */
+    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,
+            property: this.property,
+            loan: this.loan,
+            incomeSource: this.incomeSource,
+            metaFields: this.metaFields,
+            business: this.business,
+            source: TransactionSourceEnum.BANK_TRANSACTION,
+            operation: TransactionOperationEnum.ALLOCATE,
+            transactions: [],
+        });
+        // split allocation
+        if (this.amountPercent) {
+            transaction.amount = bankTransaction.amount * this.amountPercentCoefficient / this.gstCoefficient;
+        }
+        // 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;
+    }
+}
+__decorate([
+    Type(() => ChartAccounts)
+    // @TODO Alex: Create custom decorator for this transform
+    ,
+    Transform(({ value }) => ({ id: value.id }), { toPlainOnly: true })
+], AllocationRuleTransaction.prototype, "chartAccounts", void 0);
+__decorate([
+    Type(() => Property),
+    Transform(({ value }) => value ? { id: value.id } : null, { toPlainOnly: true })
+], AllocationRuleTransaction.prototype, "property", void 0);
+__decorate([
+    Type(() => Loan),
+    Transform(({ value }) => value ? { id: value.id } : null, { toPlainOnly: true })
+], AllocationRuleTransaction.prototype, "loan", void 0);
+__decorate([
+    Type(() => IncomeSource),
+    Transform(({ value }) => value ? { id: value.id } : null, { toPlainOnly: true })
+], AllocationRuleTransaction.prototype, "incomeSource", void 0);
+__decorate([
+    Type(() => SoleBusiness),
+    Transform(({ value }) => value ? { id: value.id } : null, { toPlainOnly: true })
+], AllocationRuleTransaction.prototype, "business", void 0);
+__decorate([
+    Type(() => AllocationRuleTransactionMetaField)
+], AllocationRuleTransaction.prototype, "metaFields", void 0);
+__decorate([
+    Type(() => AllocationRuleTransaction)
+], AllocationRuleTransaction.prototype, "parentTransaction", void 0);
+__decorate([
+    Type(() => AllocationRuleTransaction)
+], AllocationRuleTransaction.prototype, "childTransactions", void 0);
+__decorate([
+    Type(() => Number)
+], AllocationRuleTransaction.prototype, "claimPercent", void 0);
+__decorate([
+    Type(() => Number)
+], AllocationRuleTransaction.prototype, "tax", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"allocation-rule-transaction.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/models/transaction/allocation-rule-transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AllocationRuleTransaction as AllocationRuleTransactionBase\n} from '../../db/Models/transaction/allocation-rule-transaction';\nimport { ChartAccounts } from '../chart-accounts';\nimport { Transform, Type, plainToClass } from 'class-transformer';\nimport { AllocationRuleTransactionMetaField } from './allocation-rule-transaction-meta-field';\nimport { BankTransaction, Loan, Property, SoleBusiness, Transaction, TransactionAllocation } from '../../models';\nimport { IncomeSource } from '../income-source';\nimport { ChartAccountsListEnum } from '../../db/Enums';\nimport merge from 'lodash/merge';\nimport { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';\nimport { TransactionTypeEnum } from '../../db/Enums/transaction-type.enum';\nimport { TransactionSourceEnum } from '../../db/Enums/transaction-source.enum';\n\nexport class AllocationRuleTransaction extends AllocationRuleTransactionBase {\n  @Type(() => ChartAccounts)\n  // @TODO Alex: Create custom decorator for this transform\n  @Transform(({ value }) => ({ id: value.id }), { toPlainOnly: true })\n  chartAccounts: ChartAccounts;\n\n  @Type(() => Property)\n  @Transform(({ value }) => value ? { id: value.id } : null, { toPlainOnly: true })\n  property: Property;\n\n  @Type(() => Loan)\n  @Transform(({ value }) => value ? { id: value.id } : null, { toPlainOnly: true })\n  loan: Loan;\n\n  @Type(() => IncomeSource)\n  @Transform(({ value }) => value ? { id: value.id } : null, { toPlainOnly: true })\n  incomeSource?: IncomeSource;\n\n  @Type(() => SoleBusiness)\n  @Transform(({ value }) => value ? { id: value.id } : null, { toPlainOnly: true })\n  business: SoleBusiness;\n\n  @Type(() => AllocationRuleTransactionMetaField)\n  metaFields: AllocationRuleTransactionMetaField[];\n\n  @Type(() => AllocationRuleTransaction)\n  parentTransaction: AllocationRuleTransaction;\n\n  @Type(() => AllocationRuleTransaction)\n  childTransactions: AllocationRuleTransaction[];\n\n  @Type(() => Number) claimPercent = 100;\n  @Type(() => Number) tax = 0;\n\n  amount: number = null;\n\n  get amountPercentCoefficient(): number {\n    return this.amountPercent ? this.amountPercent / 100 : 1;\n  }\n\n  calculateClaimPercent(): number {\n    if (!this.chartAccounts) {\n      return null;\n    }\n\n    let claimPercent = this.chartAccounts.taxablePercent;\n\n    // Property claim (ownership% x shared%) for property expenses, taxable percent for others\n    if (this.chartAccounts?.isProperty() && this.property) {\n\n      if (this.chartAccounts.isPropertyExpense() && this.chartAccounts.id !== ChartAccountsListEnum.PLATFORM_FEES) {\n        claimPercent *= this.property?.claimCoefficient;\n      }\n    }\n\n    return claimPercent;\n  }\n\n  /**\n   * If rule transaction has amount then split enabled. There is 0 when split disabled\n   */\n  isSplit(): boolean {\n    return !!this.amountPercent;\n  }\n\n  /**\n   * Create Transaction instance based on passed bank transaction and rule transaction\n   */\n  toTransaction(bankTransaction: BankTransaction = null): Transaction {\n    const transaction = bankTransaction ? bankTransaction.toTransaction(this.isGST) : plainToClass(Transaction, {});\n    Object.assign(transaction, {\n      isGST: this.isGST,\n      tax: this.tax,\n      claimPercent: this.claimPercent,\n      chartAccounts: this.chartAccounts,\n      property: this.property,\n      loan: this.loan,\n      incomeSource: this.incomeSource,\n      metaFields: this.metaFields,\n      business: this.business,\n      source: TransactionSourceEnum.BANK_TRANSACTION,\n      operation: TransactionOperationEnum.ALLOCATE,\n      transactions: [],\n    });\n\n    // split allocation\n    if (this.amountPercent) {\n      transaction.amount = bankTransaction.amount * this.amountPercentCoefficient / this.gstCoefficient;\n    }\n\n    // child transactions inherit most of the fields from parent transaction\n    this.childTransactions.forEach((childRuleTransaction: AllocationRuleTransaction) => {\n      const childTransaction = childRuleTransaction.toTransaction();\n      childTransaction.amount = childRuleTransaction.amount;\n      childTransaction.setParent(transaction);\n\n      transaction.transactions.push(childTransaction);\n    });\n\n    return transaction;\n  }\n}\n"]}

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":"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","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=