taxtank-core 0.33.115 → 0.33.117

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

@@ -0,0 +1,28 @@
+import { __decorate } from "tslib";
+import { AbstractModel } from '../../db/Models';
+import { ReportItemDetails } from './report-item-details';
+import { Transform, Type } from 'class-transformer';
+import { Collection, ReportItemCollection } from '../../collections';
+/**
+ * @Todo no base model - should be generated on backend side
+ * Used in tax summary reports to show amounts relating to a tax return category entity and details of what this
+ * amount is comprised of. Example here shows an amount of $951.96 and also details of what this amount is comprised of:
+ */
+export class ReportItem extends AbstractModel {
+    /**
+     * Get amount for one income source
+     * @param name Name of income source for filter
+     */
+    getAmountByIncomeSourceName(name) {
+        return this.details.find((detail) => detail.name === name)?.amount || 0;
+    }
+}
+__decorate([
+    Type(() => ReportItem),
+    Transform(({ value }) => new ReportItemCollection(value))
+], ReportItem.prototype, "items", void 0);
+__decorate([
+    Type(() => ReportItemDetails),
+    Transform(({ value }) => new Collection(value))
+], ReportItem.prototype, "details", void 0);
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,32 @@
+import { __decorate } from "tslib";
+import { TaxSummarySectionEnum } from '../../db/Enums/tax-summary-section.enum';
+import { ReportItem } from './report-item';
+import { ReportItemCollection } from '../../collections';
+import { Transform, Type } from 'class-transformer';
+/**
+ * Base class for each sections of Tax Summary report, contains common properties/methods
+ * See also TaxSummary model
+ */
+export class TaxSummarySection {
+}
+__decorate([
+    Type(() => ReportItem),
+    Transform(({ value }) => new ReportItemCollection(value))
+], TaxSummarySection.prototype, "items", void 0);
+__decorate([
+    Transform(({ obj }) => {
+        switch (obj.section) {
+            case TaxSummarySectionEnum.WORK_TANK:
+                return 'taxSummaryWorkTank';
+            case TaxSummarySectionEnum.PROPERTY_TANK:
+                return 'taxSummaryPropertyTank';
+            case TaxSummarySectionEnum.OTHER_TANK:
+                return 'taxSummaryOtherIncome';
+            case TaxSummarySectionEnum.SOLE_TANK:
+                return 'taxSummarySoleTank';
+            default:
+                return 'taxSummaryTotal';
+        }
+    })
+], TaxSummarySection.prototype, "id", void 0);
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,9 @@
+/**
+ * Enum for tax summary types
+ */
+export var TaxSummaryTypeEnum;
+(function (TaxSummaryTypeEnum) {
+    TaxSummaryTypeEnum["ACTUALS"] = "actuals";
+    TaxSummaryTypeEnum["FORECASTS"] = "forecasts";
+})(TaxSummaryTypeEnum || (TaxSummaryTypeEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGF4LXN1bW1hcnktdHlwZS5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL21vZGVscy90YXgtc3VtbWFyeS90YXgtc3VtbWFyeS10eXBlLmVudW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLENBQU4sSUFBWSxrQkFHWDtBQUhELFdBQVksa0JBQWtCO0lBQzVCLHlDQUFtQixDQUFBO0lBQ25CLDZDQUF1QixDQUFBO0FBQ3pCLENBQUMsRUFIVyxrQkFBa0IsS0FBbEIsa0JBQWtCLFFBRzdCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFbnVtIGZvciB0YXggc3VtbWFyeSB0eXBlc1xuICovXG5leHBvcnQgZW51bSBUYXhTdW1tYXJ5VHlwZUVudW0ge1xuICBBQ1RVQUxTID0gJ2FjdHVhbHMnLFxuICBGT1JFQ0FTVFMgPSAnZm9yZWNhc3RzJ1xufVxuIl19

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

@@ -0,0 +1,153 @@
+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);
+        const borrowingExpenses = this.property.items.sumByCategoriesAndSection([TaxReturnCategoryListEnum.BORROWING_EXPENSES], TaxSummarySectionEnum.PROPERTY_TANK);
+        return this.propertyNetCash - Math.abs(depreciation) - Math.abs(borrowingExpenses);
+    }
+    /**
+     * 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(\n      TAX_RETURN_CATEGORIES.property.depreciation,\n      TaxSummarySectionEnum.PROPERTY_TANK\n    );\n\n    const borrowingExpenses: number = this.property.items.sumByCategoriesAndSection(\n      [TaxReturnCategoryListEnum.BORROWING_EXPENSES],\n      TaxSummarySectionEnum.PROPERTY_TANK\n    );\n\n    return this.propertyNetCash - Math.abs(depreciation) - Math.abs(borrowingExpenses);\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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsb2NhdGlvbi1ydWxlLWNvbmRpdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9tb2RlbHMvdHJhbnNhY3Rpb24vYWxsb2NhdGlvbi1ydWxlLWNvbmRpdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUNMLHVCQUF1QixJQUFJLDJCQUEyQixFQUN2RCxNQUFNLHVEQUF1RCxDQUFDO0FBRS9ELE9BQU8sRUFBRSw2Q0FBNkMsRUFBRSxnQ0FBZ0MsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ2pILE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUU5QyxNQUFNLE9BQU8sdUJBQXdCLFNBQVEsMkJBQTJCO0lBSXRFLG9CQUFvQixDQUFDLGVBQWdDO1FBQ25ELE9BQU8sSUFBSSxDQUFDLEtBQUssS0FBSyxnQ0FBZ0MsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyw0QkFBNEIsQ0FBQyxlQUFlLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLGlDQUFpQyxDQUFDLGVBQWUsQ0FBQyxDQUFDO0lBQy9LLENBQUM7SUFFRCw0QkFBNEIsQ0FBQyxlQUFnQztRQUMzRCxzQ0FBc0M7UUFDdEMsTUFBTSxLQUFLLEdBQVcsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDO1FBRWxDLFFBQVEsSUFBSSxDQUFDLGtCQUFrQixFQUFFO1lBQy9CLEtBQUssNkNBQTZDLENBQUMsTUFBTTtnQkFDdkQsT0FBTyxlQUFlLENBQUMsTUFBTSxLQUFLLEtBQUssQ0FBQztZQUMxQyxLQUFLLDZDQUE2QyxDQUFDLGNBQWM7Z0JBQy9ELE9BQU8sZUFBZSxDQUFDLE1BQU0sSUFBSSxLQUFLLENBQUM7WUFDekMsS0FBSyw2Q0FBNkMsQ0FBQyxpQkFBaUI7Z0JBQ2xFLE9BQU8sZUFBZSxDQUFDLE1BQU0sSUFBSSxLQUFLLENBQUM7U0FDMUM7UUFFRCxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7SUFFRCxpQ0FBaUMsQ0FBQyxlQUFnQztRQUNoRSwrQ0FBK0M7UUFDL0MsTUFBTSxXQUFXLEdBQVcsZUFBZSxDQUFDLFdBQVcsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUN0RSxNQUFNLEtBQUssR0FBVyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBRXRELFFBQVEsSUFBSSxDQUFDLGtCQUFrQixFQUFFO1lBQy9CLEtBQUssNkNBQTZDLENBQUMsTUFBTTtnQkFDdkQsT0FBTyxXQUFXLEtBQUssS0FBSyxDQUFDO1lBQy9CLEtBQUssNkNBQTZDLENBQUMsUUFBUTtnQkFDekQsT0FBTyxXQUFXLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQ3JDLEtBQUssNkNBQTZDLENBQUMsTUFBTTtnQkFDdkQsT0FBTyxXQUFXLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxDQUFDO1NBQ3hDO1FBRUQsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0NBQ0Y7QUF0Q0M7SUFEQyxTQUFTLENBQUMsQ0FBQyxFQUFFLEtBQUssRUFBRSxFQUFFLEVBQUUsQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFLEVBQUUsRUFBRSxXQUFXLEVBQUUsSUFBSSxFQUFFLENBQUM7c0RBQ3BEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgQWxsb2NhdGlvblJ1bGVDb25kaXRpb24gYXMgQWxsb2NhdGlvblJ1bGVDb25kaXRpb25CYXNlXG59IGZyb20gJy4uLy4uL2RiL01vZGVscy90cmFuc2FjdGlvbi9hbGxvY2F0aW9uLXJ1bGUtY29uZGl0aW9uJztcbmltcG9ydCB7IEJhbmtUcmFuc2FjdGlvbiB9IGZyb20gJy4uL2JhbmsnO1xuaW1wb3J0IHsgQWxsb2NhdGlvblJ1bGVDb25kaXRpb25Db21wYXJpc29uT3BlcmF0b3JFbnVtLCBBbGxvY2F0aW9uUnVsZUNvbmRpdGlvbkZpZWxkRW51bSB9IGZyb20gJy4uLy4uL2RiL0VudW1zJztcbmltcG9ydCB7IFRyYW5zZm9ybSB9IGZyb20gJ2NsYXNzLXRyYW5zZm9ybWVyJztcblxuZXhwb3J0IGNsYXNzIEFsbG9jYXRpb25SdWxlQ29uZGl0aW9uIGV4dGVuZHMgQWxsb2NhdGlvblJ1bGVDb25kaXRpb25CYXNlIHtcbiAgQFRyYW5zZm9ybSgoeyB2YWx1ZSB9KSA9PiB2YWx1ZS50b1N0cmluZygpLCB7IHRvUGxhaW5Pbmx5OiB0cnVlIH0pXG4gIHZhbHVlOiBzdHJpbmc7XG5cbiAgbWF0Y2hCYW5rVHJhbnNhY3Rpb24oYmFua1RyYW5zYWN0aW9uOiBCYW5rVHJhbnNhY3Rpb24pOiBib29sZWFuIHtcbiAgICByZXR1cm4gdGhpcy5maWVsZCA9PT0gQWxsb2NhdGlvblJ1bGVDb25kaXRpb25GaWVsZEVudW0uQU1PVU5UID8gdGhpcy5tYXRjaEJhbmtUcmFuc2FjdGlvbkJ5QW1vdW50KGJhbmtUcmFuc2FjdGlvbikgOiB0aGlzLm1hdGNoQmFua1RyYW5zYWN0aW9uQnlEZXNjcmlwdGlvbihiYW5rVHJhbnNhY3Rpb24pO1xuICB9XG5cbiAgbWF0Y2hCYW5rVHJhbnNhY3Rpb25CeUFtb3VudChiYW5rVHJhbnNhY3Rpb246IEJhbmtUcmFuc2FjdGlvbik6IGJvb2xlYW4ge1xuICAgIC8vIEFtb3VudCBzaG91bGQgYmUgY29tcGFyZWQgYXMgbnVtYmVyXG4gICAgY29uc3QgdmFsdWU6IG51bWJlciA9ICt0aGlzLnZhbHVlO1xuXG4gICAgc3dpdGNoICh0aGlzLmNvbXBhcmlzb25PcGVyYXRvcikge1xuICAgICAgY2FzZSBBbGxvY2F0aW9uUnVsZUNvbmRpdGlvbkNvbXBhcmlzb25PcGVyYXRvckVudW0uRVFVQUxTOlxuICAgICAgICByZXR1cm4gYmFua1RyYW5zYWN0aW9uLmFtb3VudCA9PT0gdmFsdWU7XG4gICAgICBjYXNlIEFsbG9jYXRpb25SdWxlQ29uZGl0aW9uQ29tcGFyaXNvbk9wZXJhdG9yRW51bS5FUVVBTFNfT1JfTEVTUzpcbiAgICAgICAgcmV0dXJuIGJhbmtUcmFuc2FjdGlvbi5hbW91bnQgPD0gdmFsdWU7XG4gICAgICBjYXNlIEFsbG9jYXRpb25SdWxlQ29uZGl0aW9uQ29tcGFyaXNvbk9wZXJhdG9yRW51bS5FUVVBTFNfT1JfR1JFQVRFUjpcbiAgICAgICAgcmV0dXJuIGJhbmtUcmFuc2FjdGlvbi5hbW91bnQgPj0gdmFsdWU7XG4gICAgfVxuXG4gICAgcmV0dXJuIGZhbHNlO1xuICB9XG5cbiAgbWF0Y2hCYW5rVHJhbnNhY3Rpb25CeURlc2NyaXB0aW9uKGJhbmtUcmFuc2FjdGlvbjogQmFua1RyYW5zYWN0aW9uKTogYm9vbGVhbiB7XG4gICAgLy8gUHJlcGFyZSB2YWx1ZSBhbmQgZGVzY3JpcHRpb24gZm9yIGNvbXBhcmlzb25cbiAgICBjb25zdCBkZXNjcmlwdGlvbjogc3RyaW5nID0gYmFua1RyYW5zYWN0aW9uLmRlc2NyaXB0aW9uLnRvTG93ZXJDYXNlKCk7XG4gICAgY29uc3QgdmFsdWU6IHN0cmluZyA9IHRoaXMudmFsdWUudHJpbSgpLnRvTG93ZXJDYXNlKCk7XG5cbiAgICBzd2l0Y2ggKHRoaXMuY29tcGFyaXNvbk9wZXJhdG9yKSB7XG4gICAgICBjYXNlIEFsbG9jYXRpb25SdWxlQ29uZGl0aW9uQ29tcGFyaXNvbk9wZXJhdG9yRW51bS5FUVVBTFM6XG4gICAgICAgIHJldHVybiBkZXNjcmlwdGlvbiA9PT0gdmFsdWU7XG4gICAgICBjYXNlIEFsbG9jYXRpb25SdWxlQ29uZGl0aW9uQ29tcGFyaXNvbk9wZXJhdG9yRW51bS5DT05UQUlOUzpcbiAgICAgICAgcmV0dXJuIGRlc2NyaXB0aW9uLmluY2x1ZGVzKHZhbHVlKTtcbiAgICAgIGNhc2UgQWxsb2NhdGlvblJ1bGVDb25kaXRpb25Db21wYXJpc29uT3BlcmF0b3JFbnVtLlNUQVJUUzpcbiAgICAgICAgcmV0dXJuIGRlc2NyaXB0aW9uLnN0YXJ0c1dpdGgodmFsdWUpO1xuICAgIH1cblxuICAgIHJldHVybiBmYWxzZTtcbiAgfVxufVxuIl19

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      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"]}