taxtank-core 0.29.36 → 0.30.0

package/esm2020/lib/models/property/property-equity-chart-data.mjs

@@ -0,0 +1,164 @@
+import first from 'lodash/first';
+import { PropertyEquityChartItem } from './property-equity-chart-item';
+import { FinancialYear } from '../financial-year/financial-year';
+import { PropertyEquityChartTypeEnum } from './property-equity-chart-type.enum';
+// count of years for future values
+const FORECAST_YEARS = 25;
+/**
+ * class contain actual and forecasted market values and loan balances for passed properties
+ * X axis - years from the first actual data year to the last forecasted year
+ * Y axis - amounts of market values, loan balances
+ * Also on hover appear equity positions point
+ */
+export class PropertyEquityChartData {
+    constructor(properties, bankAccounts, loans, registerDate) {
+        this.registerDate = registerDate;
+        this.properties = properties;
+        this.bankAccounts = bankAccounts.getLoanAccounts();
+        this.loans = loans;
+        this.currentYear = new FinancialYear(new Date()).year;
+        this.initItems();
+        this.buildHistoryItems();
+        this.buildActualItem();
+        this.buildForecastedItems();
+        this.checkZeroLoanBalance();
+        this.checkZeroMarketValue();
+    }
+    /**
+     * get items list in chart series format
+     * @param type
+     */
+    getChartSeries(type) {
+        return this.list.map((item) => item.getSerie(type));
+    }
+    /**
+     * get prepared chart data
+     */
+    getChartData() {
+        return [
+            {
+                id: 'marketValue',
+                name: 'Market Value',
+                series: this.getChartSeries(PropertyEquityChartTypeEnum.MARKET_VALUE),
+                // display future market value with dash line and past market value with solid line
+                zones: [{
+                        // line style after current calendar year
+                        value: this.currentYear,
+                        dashStyle: 'Solid'
+                    }, {
+                        // default line style
+                        dashStyle: 'Dash'
+                    }]
+            },
+            {
+                // id used to add/remove serie to chart
+                id: 'loanBalance',
+                name: 'Loan Balance',
+                series: this.getChartSeries(PropertyEquityChartTypeEnum.LOAN_BALANCE)
+            }
+        ];
+    }
+    /**
+     * create empty equity position item for each year in collection
+     */
+    initItems() {
+        this.list = [];
+        for (let year = new FinancialYear(this.registerDate).year - 1; year <= (this.currentYear + FORECAST_YEARS); year++) {
+            this.list.push(new PropertyEquityChartItem(year));
+        }
+    }
+    /**
+     * collect equity position items with past values from properties forecasts
+     */
+    buildHistoryItems() {
+        // get items for past and current years
+        const items = this.list.filter((item) => item.year <= this.currentYear);
+        items.forEach((item) => {
+            // increase item values with property actual forecasts for item year
+            item.marketValue = this.properties.items.reduce((sum, property) => {
+                return sum + this.getMarketValueForPropertyByYear(property, item.year);
+            }, 0);
+            item.loanBalance = Math.abs(this.properties.items.reduce((sum, property) => {
+                return sum + this.getLoanBalanceForPropertyByYear(property, item.year);
+            }, 0));
+        });
+    }
+    /**
+     * set actual year's real data
+     * @private
+     */
+    buildActualItem() {
+        const item = this.list.find((i) => i.year === this.currentYear);
+        item.marketValue = this.properties.marketValue;
+        item.loanBalance = this.properties.items.reduce((sum, property) => {
+            return sum + Math.abs(this.bankAccounts.getPropertyBalanceAmount(property.id));
+        }, 0);
+    }
+    /**
+     * collect equity position items with forecasted (future) calculated values
+     */
+    buildForecastedItems() {
+        // calculate future values for all properties separately
+        this.properties.items.forEach((property) => {
+            let forecastedMarketValue = (property.growthPercent / 100) * property.marketValue + property.marketValue;
+            // calculate future values for each future year for current handling property
+            this.list
+                .filter((item) => item.year > this.currentYear)
+                .forEach((item) => {
+                const propertyBankAccounts = this.bankAccounts.getByPropertyId(property.id);
+                // increase loan balance amount for handling equity position item
+                item.loanBalance += this.getLoanBalanceByYear(property, item.year, propertyBankAccounts, this.loans.getByBankAccountsIds(propertyBankAccounts.getIds()));
+                // increase market value amount for handling equity position item
+                item.marketValue += forecastedMarketValue;
+                // increase current market value forecast for the next cycle iteration
+                forecastedMarketValue += forecastedMarketValue * (property.growthPercent / 100);
+            });
+        });
+    }
+    /**
+     * Get property loan balance by financial year
+     * @param property Property instance for filter
+     * @param year Financial year number
+     * @param bankAccounts List of bank accounts
+     * @param loans List of loans
+     * @private
+     */
+    getLoanBalanceByYear(property, year, bankAccounts, loans) {
+        return bankAccounts.items.reduce((totalSum, bankAccount) => {
+            return totalSum + (bankAccount.getPropertyPercentage(property.id) * (loans.getByBankAccountId(bankAccount.id)?.getLastPaymentByYear(year)?.totalOwed || 0));
+        }, 0);
+    }
+    getMarketValueForPropertyByYear(property, year) {
+        if (new FinancialYear(property.contractDate).year > year) {
+            return 0;
+        }
+        return (property.getForecastByYear(year) || first(property.forecasts)).marketValue;
+    }
+    getLoanBalanceForPropertyByYear(property, year) {
+        if (new FinancialYear(property.contractDate).year > year) {
+            return 0;
+        }
+        return property.getForecastByYear(year)?.loanBalance || this.bankAccounts.getPropertyBalanceAmount(property.id);
+    }
+    /**
+     * Check if loan balance is 0 and set it as null (to not to draw point on the chart)
+     */
+    checkZeroLoanBalance() {
+        this.list.forEach((item) => {
+            if (item.loanBalance === 0) {
+                item.loanBalance = null;
+            }
+        });
+    }
+    /**
+     * Check if market value is 0 and set it as null (to not to draw point on the chart)
+     */
+    checkZeroMarketValue() {
+        this.list.forEach((item) => {
+            if (item.marketValue === 0) {
+                item.marketValue = null;
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"property-equity-chart-data.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/models/property/property-equity-chart-data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,cAAc,CAAC;AACjC,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAIvE,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,EAAE,2BAA2B,EAAE,MAAM,mCAAmC,CAAC;AAIhF,mCAAmC;AACnC,MAAM,cAAc,GAAW,EAAE,CAAC;AAElC;;;;;GAKG;AACH,MAAM,OAAO,uBAAuB;IAUlC,YACE,UAA8B,EAC9B,YAAmC,EACnC,KAAqB,EACb,YAAkB;QAAlB,iBAAY,GAAZ,YAAY,CAAM;QAE1B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC,eAAe,EAAE,CAAC;QACnD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,WAAW,GAAG,IAAI,aAAa,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC;QACtD,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzB,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACH,cAAc,CAAC,IAAiC;QAC9C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAA6B,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IAC/E,CAAC;IAED;;OAEG;IACH,YAAY;QACV,OAAO;YACL;gBACE,EAAE,EAAE,aAAa;gBACjB,IAAI,EAAE,cAAc;gBACpB,MAAM,EAAE,IAAI,CAAC,cAAc,CAAC,2BAA2B,CAAC,YAAY,CAAC;gBACrE,mFAAmF;gBACnF,KAAK,EAAE,CAAC;wBACN,yCAAyC;wBACzC,KAAK,EAAE,IAAI,CAAC,WAAW;wBACvB,SAAS,EAAE,OAAO;qBACnB,EAAE;wBACD,qBAAqB;wBACrB,SAAS,EAAE,MAAM;qBAClB,CAAC;aACH;YACD;gBACE,uCAAuC;gBACvC,EAAE,EAAE,aAAa;gBACjB,IAAI,EAAE,cAAc;gBACpB,MAAM,EAAE,IAAI,CAAC,cAAc,CAAC,2BAA2B,CAAC,YAAY,CAAC;aACtE;SACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,SAAS;QACf,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;QACf,KAAK,IAAI,IAAI,GAAW,IAAI,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,IAAI,GAAG,CAAC,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,GAAG,cAAc,CAAC,EAAE,IAAI,EAAE,EAAE;YAC1H,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,uBAAuB,CAAC,IAAI,CAAC,CAAC,CAAC;SACnD;IACH,CAAC;IAED;;OAEG;IACK,iBAAiB;QACvB,uCAAuC;QACvC,MAAM,KAAK,GAA8B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAA6B,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC;QAC5H,KAAK,CAAC,OAAO,CAAC,CAAC,IAA6B,EAAE,EAAE;YAC9C,oEAAoE;YACpE,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAW,EAAE,QAAkB,EAAU,EAAE;gBAC1F,OAAO,GAAG,GAAG,IAAI,CAAC,+BAA+B,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YACzE,CAAC,EAAE,CAAC,CAAC,CAAC;YAEN,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAW,EAAE,QAAkB,EAAU,EAAE;gBACnG,OAAO,GAAG,GAAG,IAAI,CAAC,+BAA+B,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YACzE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACT,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACK,eAAe;QACrB,MAAM,IAAI,GAA4B,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAA0B,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,WAAW,CAAC,CAAC;QAClH,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC;QAC/C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAW,EAAE,QAAkB,EAAU,EAAE;YAC1F,OAAO,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,wBAAwB,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;QACjF,CAAC,EAAE,CAAC,CAAC,CAAC;IACR,CAAC;IAED;;OAEG;IACK,oBAAoB;QAC1B,wDAAwD;QACxD,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,QAAkB,EAAE,EAAE;YACnD,IAAI,qBAAqB,GAAW,CAAC,QAAQ,CAAC,aAAa,GAAG,GAAG,CAAC,GAAG,QAAQ,CAAC,WAAW,GAAG,QAAQ,CAAC,WAAW,CAAC;YAEjH,6EAA6E;YAC7E,IAAI,CAAC,IAAI;iBACN,MAAM,CAAC,CAAC,IAA6B,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC;iBACvE,OAAO,CAAC,CAAC,IAA6B,EAAE,EAAE;gBACzC,MAAM,oBAAoB,GAA0B,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;gBACnG,iEAAiE;gBACjE,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,oBAAoB,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,EAAE,oBAAoB,EAAE,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;gBAEzJ,iEAAiE;gBACjE,IAAI,CAAC,WAAW,IAAI,qBAAqB,CAAC;gBAE1C,sEAAsE;gBACtE,qBAAqB,IAAI,qBAAqB,GAAG,CAAC,QAAQ,CAAC,aAAa,GAAG,GAAG,CAAC,CAAC;YAClF,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACK,oBAAoB,CAAC,QAAkB,EAAE,IAAY,EAAE,YAAmC,EAAE,KAAqB;QACvH,OAAO,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,QAAgB,EAAE,WAAwB,EAAU,EAAE;YACtF,OAAO,QAAQ,GAAG,CAAC,WAAW,CAAC,qBAAqB,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,kBAAkB,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE,oBAAoB,CAAC,IAAI,CAAC,EAAE,SAAS,IAAI,CAAC,CAAC,CAAC,CAAC;QAC9J,CAAC,EAAE,CAAC,CAAC,CAAC;IACR,CAAC;IAED,+BAA+B,CAAC,QAAkB,EAAE,IAAY;QAC9D,IAAI,IAAI,aAAa,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,IAAI,GAAG,IAAI,EAAE;YACxD,OAAO,CAAC,CAAC;SACV;QAED,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC;IACrF,CAAC;IAED,+BAA+B,CAAC,QAAkB,EAAE,IAAY;QAC9D,IAAI,IAAI,aAAa,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,IAAI,GAAG,IAAI,EAAE;YACxD,OAAO,CAAC,CAAC;SACV;QAED,OAAO,QAAQ,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,IAAI,IAAI,CAAC,YAAY,CAAC,wBAAwB,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAClH,CAAC;IAED;;OAEG;IACK,oBAAoB;QAC1B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAA6B,EAAE,EAAE;YAClD,IAAI,IAAI,CAAC,WAAW,KAAK,CAAC,EAAE;gBAC1B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;aACzB;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,oBAAoB;QAC1B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAA6B,EAAE,EAAE;YAClD,IAAI,IAAI,CAAC,WAAW,KAAK,CAAC,EAAE;gBAC1B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;aACzB;QACH,CAAC,CAAC,CAAC;IACL,CAAC;CACF","sourcesContent":["import first from 'lodash/first';\nimport { PropertyEquityChartItem } from './property-equity-chart-item';\nimport { PropertyCollection } from '../../collections/property/property.collection';\nimport { BankAccountCollection } from '../../collections/bank-account.collection';\nimport { LoanCollection } from '../../collections/loan/loan.collection';\nimport { FinancialYear } from '../financial-year/financial-year';\nimport { PropertyEquityChartTypeEnum } from './property-equity-chart-type.enum';\nimport { Property } from './property';\nimport { BankAccount } from '../bank/bank-account';\n\n// count of years for future values\nconst FORECAST_YEARS: number = 25;\n\n/**\n * class contain actual and forecasted market values and loan balances for passed properties\n * X axis - years from the first actual data year to the last forecasted year\n * Y axis - amounts of market values, loan balances\n * Also on hover appear equity positions point\n */\nexport class PropertyEquityChartData {\n  // list of equity positions for all years range\n  list: PropertyEquityChartItem[];\n  // current financial year\n  currentYear: number;\n  // list of properties this collection based on\n  private properties: PropertyCollection;\n  private bankAccounts: BankAccountCollection;\n  private loans: LoanCollection;\n\n  constructor(\n    properties: PropertyCollection,\n    bankAccounts: BankAccountCollection,\n    loans: LoanCollection,\n    private registerDate: Date\n  ) {\n    this.properties = properties;\n    this.bankAccounts = bankAccounts.getLoanAccounts();\n    this.loans = loans;\n    this.currentYear = new FinancialYear(new Date()).year;\n    this.initItems();\n    this.buildHistoryItems();\n    this.buildActualItem();\n    this.buildForecastedItems();\n    this.checkZeroLoanBalance();\n    this.checkZeroMarketValue();\n  }\n\n  /**\n   * get items list in chart series format\n   * @param type\n   */\n  getChartSeries(type: PropertyEquityChartTypeEnum): number[][] {\n    return this.list.map((item: PropertyEquityChartItem) => item.getSerie(type));\n  }\n\n  /**\n   * get prepared chart data\n   */\n  getChartData(): object[] {\n    return [\n      {\n        id: 'marketValue',\n        name: 'Market Value',\n        series: this.getChartSeries(PropertyEquityChartTypeEnum.MARKET_VALUE),\n        // display future market value with dash line and past market value with solid line\n        zones: [{\n          // line style after current calendar year\n          value: this.currentYear,\n          dashStyle: 'Solid'\n        }, {\n          // default line style\n          dashStyle: 'Dash'\n        }]\n      },\n      {\n        // id used to add/remove serie to chart\n        id: 'loanBalance',\n        name: 'Loan Balance',\n        series: this.getChartSeries(PropertyEquityChartTypeEnum.LOAN_BALANCE)\n      }\n    ];\n  }\n\n  /**\n   * create empty equity position item for each year in collection\n   */\n  private initItems(): void {\n    this.list = [];\n    for (let year: number = new FinancialYear(this.registerDate).year - 1; year <= (this.currentYear + FORECAST_YEARS); year++) {\n      this.list.push(new PropertyEquityChartItem(year));\n    }\n  }\n\n  /**\n   * collect equity position items with past values from properties forecasts\n   */\n  private buildHistoryItems(): void {\n    // get items for past and current years\n    const items: PropertyEquityChartItem[] = this.list.filter((item: PropertyEquityChartItem) => item.year <= this.currentYear);\n    items.forEach((item: PropertyEquityChartItem) => {\n      // increase item values with property actual forecasts for item year\n      item.marketValue = this.properties.items.reduce((sum: number, property: Property): number => {\n        return sum + this.getMarketValueForPropertyByYear(property, item.year);\n      }, 0);\n\n      item.loanBalance = Math.abs(this.properties.items.reduce((sum: number, property: Property): number => {\n        return sum + this.getLoanBalanceForPropertyByYear(property, item.year);\n      }, 0));\n    });\n  }\n\n  /**\n   * set actual year's real data\n   * @private\n   */\n  private buildActualItem(): void {\n    const item: PropertyEquityChartItem = this.list.find((i: PropertyEquityChartItem) => i.year === this.currentYear);\n    item.marketValue = this.properties.marketValue;\n    item.loanBalance = this.properties.items.reduce((sum: number, property: Property): number => {\n      return sum + Math.abs(this.bankAccounts.getPropertyBalanceAmount(property.id));\n    }, 0);\n  }\n\n  /**\n   * collect equity position items with forecasted (future) calculated values\n   */\n  private buildForecastedItems(): void {\n    // calculate future values for all properties separately\n    this.properties.items.forEach((property: Property) => {\n      let forecastedMarketValue: number = (property.growthPercent / 100) * property.marketValue + property.marketValue;\n\n      // calculate future values for each future year for current handling property\n      this.list\n        .filter((item: PropertyEquityChartItem) => item.year > this.currentYear)\n        .forEach((item: PropertyEquityChartItem) => {\n          const propertyBankAccounts: BankAccountCollection = this.bankAccounts.getByPropertyId(property.id);\n          // increase loan balance amount for handling equity position item\n          item.loanBalance += this.getLoanBalanceByYear(property, item.year, propertyBankAccounts, this.loans.getByBankAccountsIds(propertyBankAccounts.getIds()));\n\n          // increase market value amount for handling equity position item\n          item.marketValue += forecastedMarketValue;\n\n          // increase current market value forecast for the next cycle iteration\n          forecastedMarketValue += forecastedMarketValue * (property.growthPercent / 100);\n        });\n    });\n  }\n\n  /**\n   * Get property loan balance by financial year\n   * @param property Property instance for filter\n   * @param year Financial year number\n   * @param bankAccounts List of bank accounts\n   * @param loans List of loans\n   * @private\n   */\n  private getLoanBalanceByYear(property: Property, year: number, bankAccounts: BankAccountCollection, loans: LoanCollection): number {\n    return bankAccounts.items.reduce((totalSum: number, bankAccount: BankAccount): number => {\n      return totalSum + (bankAccount.getPropertyPercentage(property.id) * (loans.getByBankAccountId(bankAccount.id)?.getLastPaymentByYear(year)?.totalOwed || 0));\n    }, 0);\n  }\n\n  getMarketValueForPropertyByYear(property: Property, year: number): number {\n    if (new FinancialYear(property.contractDate).year > year) {\n      return 0;\n    }\n\n    return (property.getForecastByYear(year) || first(property.forecasts)).marketValue;\n  }\n\n  getLoanBalanceForPropertyByYear(property: Property, year: number): number {\n    if (new FinancialYear(property.contractDate).year > year) {\n      return 0;\n    }\n\n    return property.getForecastByYear(year)?.loanBalance || this.bankAccounts.getPropertyBalanceAmount(property.id);\n  }\n\n  /**\n   * Check if loan balance is 0 and set it as null (to not to draw point on the chart)\n   */\n  private checkZeroLoanBalance(): void {\n    this.list.forEach((item: PropertyEquityChartItem) => {\n      if (item.loanBalance === 0) {\n        item.loanBalance = null;\n      }\n    });\n  }\n\n  /**\n   * Check if market value is 0 and set it as null (to not to draw point on the chart)\n   */\n  private checkZeroMarketValue(): void {\n    this.list.forEach((item: PropertyEquityChartItem) => {\n      if (item.marketValue === 0) {\n        item.marketValue = null;\n      }\n    });\n  }\n}\n"]}

package/esm2020/lib/models/property/property-sale/property-sale-cost-base.mjs

@@ -0,0 +1,19 @@
+import { Property } from '../property';
+import { PropertySale } from './property-sale';
+import { plainToClass } from 'class-transformer';
+/**
+ * @Todo TT-2143 should be removed when PropertySaleCostBaseForm refactored (cut property to separated form)
+ */
+export class PropertySaleCostBase {
+    static createFrom(property, propertySale, depreciations, holdingCosts) {
+        return plainToClass(PropertySaleCostBase, {
+            property: plainToClass(Property, property),
+            sale: plainToClass(PropertySale, Object.assign({}, propertySale, {
+                holdingCosts: propertySale.holdingCosts ?? Math.abs(holdingCosts.sumBy('amount')),
+                structuralImprovementsWDV: propertySale.structuralImprovementsWDV ?? depreciations.getWithCapitalProject().getCloseBalanceByYear(),
+                buildingAtCostClaimed: propertySale.buildingAtCostClaimed ?? depreciations.getWithoutCapitalProject().getClaimedAmountByYear(),
+            })),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/models/property/property-sale/property-sale.mjs

@@ -0,0 +1,42 @@
+import { __decorate } from "tslib";
+import { PropertySale as BasePropertySale } from '../../../db/Models/property/property-sale/property-sale';
+import { Type } from 'class-transformer';
+import { PropertySaleTaxExemptionMetadata } from '../../../db/Models';
+import { TaxExemptionEnum } from '../../../db/Enums/property/property-sale/tax-exemption.enum';
+export class PropertySale extends BasePropertySale {
+    get saleCostsTotalAmount() {
+        return this.commission + this.legalFees + this.otherCost;
+    }
+    /**
+     * CGT is not applicable for sales with "Principle place of residence" exemption type.
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/4644110466/Tax+Return+MyTax+-+Online+Form ("Capital gains or losses" section)
+     */
+    isCGTApplicable() {
+        return this.taxExemption?.id !== TaxExemptionEnum.PPR;
+    }
+    get lossApplied() {
+        return this.grossCGT <= 0 ? 0 : Math.min(this.grossCGT, this.capitalLoss);
+    }
+    get grossCGTAfterLoss() {
+        return this.grossCGT - this.lossApplied;
+    }
+}
+__decorate([
+    Type(() => Number)
+], PropertySale.prototype, "commission", void 0);
+__decorate([
+    Type(() => Number)
+], PropertySale.prototype, "legalFees", void 0);
+__decorate([
+    Type(() => Number)
+], PropertySale.prototype, "otherCost", void 0);
+__decorate([
+    Type(() => Date)
+], PropertySale.prototype, "settlementDate", void 0);
+__decorate([
+    Type(() => Date)
+], PropertySale.prototype, "contractDate", void 0);
+__decorate([
+    Type(() => PropertySaleTaxExemptionMetadata)
+], PropertySale.prototype, "taxExemptionMetadata", void 0);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/models/property/property-share.mjs

@@ -0,0 +1,47 @@
+import { __decorate } from "tslib";
+import { PropertyShare as PropertyShareBase } from '../../db/Models/property/property-share';
+import { PropertyShareStatusEnum } from '../../db/Enums/property/property-share-status.enum';
+import { Transform, Type } from 'class-transformer';
+import { User } from '../user/user';
+import { RegistrationInvite } from '../registration-invite/registration-invite';
+import { Property } from './property';
+export class PropertyShare extends PropertyShareBase {
+    isAccepted() {
+        return this.status === PropertyShareStatusEnum.APPROVED;
+    }
+    isPending() {
+        return this.status === PropertyShareStatusEnum.PENDING;
+    }
+    isRejected() {
+        return this.status === PropertyShareStatusEnum.REJECTED;
+    }
+    get statusName() {
+        return PropertyShareStatusEnum[this.status]?.toLowerCase();
+    }
+    /**
+     * Return full user name if user is already registered.
+     * Otherwise - return first name from invitation
+     */
+    get userName() {
+        return this.user ? this.user.fullName : `${this.invite.firstName}`;
+    }
+}
+__decorate([
+    Type(() => Date)
+], PropertyShare.prototype, "fromDate", void 0);
+__decorate([
+    Type(() => Date)
+], PropertyShare.prototype, "toDate", void 0);
+__decorate([
+    Type(() => User)
+], PropertyShare.prototype, "user", void 0);
+__decorate([
+    Type(() => RegistrationInvite)
+], PropertyShare.prototype, "invite", void 0);
+__decorate([
+    Type(() => Property)
+], PropertyShare.prototype, "property", void 0);
+__decorate([
+    Transform(({ obj }) => obj.user ? obj.user.email : obj.invite.email)
+], PropertyShare.prototype, "email", void 0);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvcGVydHktc2hhcmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvbW9kZWxzL3Byb3BlcnR5L3Byb3BlcnR5LXNoYXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsYUFBYSxJQUFJLGlCQUFpQixFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFDN0YsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sb0RBQW9ELENBQUM7QUFDN0YsT0FBTyxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNwRCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQ3BDLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDRDQUE0QyxDQUFDO0FBQ2hGLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFdEMsTUFBTSxPQUFPLGFBQWMsU0FBUSxpQkFBaUI7SUFtQmxELFVBQVU7UUFDUixPQUFPLElBQUksQ0FBQyxNQUFNLEtBQUssdUJBQXVCLENBQUMsUUFBUSxDQUFDO0lBQzFELENBQUM7SUFFRCxTQUFTO1FBQ1AsT0FBTyxJQUFJLENBQUMsTUFBTSxLQUFLLHVCQUF1QixDQUFDLE9BQU8sQ0FBQztJQUN6RCxDQUFDO0lBRUQsVUFBVTtRQUNSLE9BQU8sSUFBSSxDQUFDLE1BQU0sS0FBSyx1QkFBdUIsQ0FBQyxRQUFRLENBQUM7SUFDMUQsQ0FBQztJQUVELElBQUksVUFBVTtRQUNaLE9BQU8sdUJBQXVCLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLFdBQVcsRUFBRSxDQUFDO0lBQzdELENBQUM7SUFFRDs7O09BR0c7SUFDSCxJQUFJLFFBQVE7UUFDVixPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsU0FBUyxFQUFFLENBQUM7SUFDckUsQ0FBQztDQUNGO0FBeENDO0lBREMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQzsrQ0FDRjtBQUdmO0lBREMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQzs2Q0FDSjtBQUdiO0lBREMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQzsyQ0FDTjtBQUdYO0lBREMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLGtCQUFrQixDQUFDOzZDQUNKO0FBRzNCO0lBREMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLFFBQVEsQ0FBQzsrQ0FDRjtBQUduQjtJQURDLFNBQVMsQ0FBQyxDQUFDLEVBQUMsR0FBRyxFQUFDLEVBQUUsRUFBRSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQzs0Q0FDckQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQcm9wZXJ0eVNoYXJlIGFzIFByb3BlcnR5U2hhcmVCYXNlIH0gZnJvbSAnLi4vLi4vZGIvTW9kZWxzL3Byb3BlcnR5L3Byb3BlcnR5LXNoYXJlJztcbmltcG9ydCB7IFByb3BlcnR5U2hhcmVTdGF0dXNFbnVtIH0gZnJvbSAnLi4vLi4vZGIvRW51bXMvcHJvcGVydHkvcHJvcGVydHktc2hhcmUtc3RhdHVzLmVudW0nO1xuaW1wb3J0IHsgVHJhbnNmb3JtLCBUeXBlIH0gZnJvbSAnY2xhc3MtdHJhbnNmb3JtZXInO1xuaW1wb3J0IHsgVXNlciB9IGZyb20gJy4uL3VzZXIvdXNlcic7XG5pbXBvcnQgeyBSZWdpc3RyYXRpb25JbnZpdGUgfSBmcm9tICcuLi9yZWdpc3RyYXRpb24taW52aXRlL3JlZ2lzdHJhdGlvbi1pbnZpdGUnO1xuaW1wb3J0IHsgUHJvcGVydHkgfSBmcm9tICcuL3Byb3BlcnR5JztcblxuZXhwb3J0IGNsYXNzIFByb3BlcnR5U2hhcmUgZXh0ZW5kcyBQcm9wZXJ0eVNoYXJlQmFzZSB7XG4gIEBUeXBlKCgpID0+IERhdGUpXG4gIGZyb21EYXRlOiBEYXRlO1xuXG4gIEBUeXBlKCgpID0+IERhdGUpXG4gIHRvRGF0ZTogRGF0ZTtcblxuICBAVHlwZSgoKSA9PiBVc2VyKVxuICB1c2VyOiBVc2VyO1xuXG4gIEBUeXBlKCgpID0+IFJlZ2lzdHJhdGlvbkludml0ZSlcbiAgaW52aXRlOiBSZWdpc3RyYXRpb25JbnZpdGU7XG5cbiAgQFR5cGUoKCkgPT4gUHJvcGVydHkpXG4gIHByb3BlcnR5OiBQcm9wZXJ0eTtcblxuICBAVHJhbnNmb3JtKCh7b2JqfSkgPT4gb2JqLnVzZXIgPyBvYmoudXNlci5lbWFpbCA6IG9iai5pbnZpdGUuZW1haWwpXG4gIGVtYWlsOiBzdHJpbmc7XG5cbiAgaXNBY2NlcHRlZCgpOiBib29sZWFuIHtcbiAgICByZXR1cm4gdGhpcy5zdGF0dXMgPT09IFByb3BlcnR5U2hhcmVTdGF0dXNFbnVtLkFQUFJPVkVEO1xuICB9XG5cbiAgaXNQZW5kaW5nKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLnN0YXR1cyA9PT0gUHJvcGVydHlTaGFyZVN0YXR1c0VudW0uUEVORElORztcbiAgfVxuXG4gIGlzUmVqZWN0ZWQoKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHRoaXMuc3RhdHVzID09PSBQcm9wZXJ0eVNoYXJlU3RhdHVzRW51bS5SRUpFQ1RFRDtcbiAgfVxuXG4gIGdldCBzdGF0dXNOYW1lKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIFByb3BlcnR5U2hhcmVTdGF0dXNFbnVtW3RoaXMuc3RhdHVzXT8udG9Mb3dlckNhc2UoKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZXR1cm4gZnVsbCB1c2VyIG5hbWUgaWYgdXNlciBpcyBhbHJlYWR5IHJlZ2lzdGVyZWQuXG4gICAqIE90aGVyd2lzZSAtIHJldHVybiBmaXJzdCBuYW1lIGZyb20gaW52aXRhdGlvblxuICAgKi9cbiAgZ2V0IHVzZXJOYW1lKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIHRoaXMudXNlciA/IHRoaXMudXNlci5mdWxsTmFtZSA6IGAke3RoaXMuaW52aXRlLmZpcnN0TmFtZX1gO1xuICB9XG59XG4iXX0=