taxtank-core 0.29.36 → 0.30.0

package/esm2020/lib/services/pdf/pdf-from-table/pdf-from-data-table/pdf-from-data-table.service.mjs

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import autoTable from 'jspdf-autotable';
+import { PdfFromTableService } from '../pdf-from-table.service';
+import jsPDF from 'jspdf';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../export/export-formatter.service";
+/**
+ * Service to generate and export PDF file from provided array-like data tables
+ */
+export class PdfFromDataTableService extends PdfFromTableService {
+    constructor(formatter) {
+        super();
+        this.formatter = formatter;
+    }
+    export(dataTables, fileSettings) {
+        const document = this.generate(dataTables, fileSettings.title);
+        document.save(`${fileSettings.filename}.pdf`);
+    }
+    /**
+     * Generate PDF file from provided list of data tables
+     */
+    generate(dataTables, title) {
+        const pdf = new jsPDF();
+        this.setDocumentTitle(pdf, title);
+        this.setDocumentLogo(pdf);
+        dataTables.forEach((dataTable) => {
+            autoTable(pdf, {
+                head: [dataTable.header],
+                body: this.formatter.format(dataTable.body),
+                foot: this.formatter.format(dataTable.footer),
+                ...this.setTableOptions(pdf, dataTable.caption)
+            });
+        });
+        return pdf;
+    }
+}
+PdfFromDataTableService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PdfFromDataTableService, deps: [{ token: i1.ExportFormatterService }], target: i0.ɵɵFactoryTarget.Injectable });
+PdfFromDataTableService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PdfFromDataTableService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PdfFromDataTableService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ExportFormatterService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/pdf/pdf-from-table/pdf-from-html-table/pdf-from-html-table.service.mjs

@@ -0,0 +1,43 @@
+import { Injectable } from '@angular/core';
+import jsPDF from 'jspdf';
+import { PdfFromTableService } from '../pdf-from-table.service';
+import autoTable from 'jspdf-autotable';
+import * as i0 from "@angular/core";
+/**
+ * Service to generate and export PDF file from provided HTML tables
+ */
+export class PdfFromHtmlTableService extends PdfFromTableService {
+    export(tables, fileSettings) {
+        const document = this.generateFile(tables, fileSettings);
+        document.save(`${fileSettings.filename}.pdf`);
+    }
+    /**
+     * Generate PDF file from provided list of HTML tables
+     */
+    generateFile(tables, fileSettings) {
+        const pdf = new jsPDF(fileSettings.orientation);
+        this.setDocumentTitle(pdf, fileSettings.title);
+        this.setDocumentLogo(pdf);
+        tables.forEach((table) => {
+            // Add table caption if not provided
+            if (!table.caption) {
+                table.createCaption();
+                table.caption.innerText = '';
+            }
+            autoTable(pdf, {
+                html: table,
+                ...this.setTableOptions(pdf, table.caption.innerText)
+            });
+        });
+        return pdf;
+    }
+}
+PdfFromHtmlTableService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PdfFromHtmlTableService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+PdfFromHtmlTableService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PdfFromHtmlTableService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PdfFromHtmlTableService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/pdf/pdf-from-table/pdf-from-table.service.mjs

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+import { FILE_SETTINGS } from './file-settings';
+import * as i0 from "@angular/core";
+/**
+ * Service with base functionality to export tables (HTML table, data-table, e.t.c.) as PDF file
+ * The file is generated using the jsPDF library to set custom table styles
+ */
+export class PdfFromTableService {
+    /**
+     * Set basic options for PDF table
+     */
+    setTableOptions(pdf, tableCaption = '') {
+        const lastTableCoords = pdf['lastAutoTable'].finalY || FILE_SETTINGS.contentCoords.top;
+        // get caption height based on caption content height
+        const captionHeight = pdf.getTextDimensions(pdf.splitTextToSize(tableCaption, pdf.internal.pageSize.width)).h;
+        pdf.text(tableCaption, FILE_SETTINGS.contentCoords.left, lastTableCoords + FILE_SETTINGS.contentCoords.top);
+        return {
+            headStyles: {
+                fillColor: FILE_SETTINGS.text.colorPrimary,
+            },
+            footStyles: {
+                fillColor: FILE_SETTINGS.text.colorWhite,
+                textColor: FILE_SETTINGS.text.colorBlack
+            },
+            startY: lastTableCoords + captionHeight + FILE_SETTINGS.titleCoords.top,
+            didParseCell: (data) => {
+                // Align last column content to right
+                if (data.table.columns.length > 1 && (data.column.index === data.table.columns.length - 1)) {
+                    data.cell.styles.halign = 'right';
+                }
+            }
+        };
+    }
+    setDocumentTitle(doc, title) {
+        doc.setFontSize(FILE_SETTINGS.text.fontSize)
+            .setFont(FILE_SETTINGS.text.fontName, FILE_SETTINGS.text.fontStyle, FILE_SETTINGS.text.fontWeight)
+            .text(title, FILE_SETTINGS.text.positionX, FILE_SETTINGS.text.positionY);
+    }
+    setDocumentLogo(doc) {
+        const logo = new Image();
+        logo.src = FILE_SETTINGS.logo.src;
+        doc.addImage(logo, 'PNG', doc.internal.pageSize.width - FILE_SETTINGS.logo.positionX, FILE_SETTINGS.logo.positionY, FILE_SETTINGS.logo.width, FILE_SETTINGS.logo.height);
+    }
+}
+PdfFromTableService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PdfFromTableService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PdfFromTableService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PdfFromTableService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PdfFromTableService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/preloader/preloader.service.mjs

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class PreloaderService {
+    constructor() {
+        this.activePreloaders = new BehaviorSubject([]);
+    }
+    get() {
+        return this.activePreloaders.asObservable();
+    }
+    add(endpoint) {
+        const activePreloaders = this.activePreloaders.getValue();
+        activePreloaders.push(endpoint);
+        this.activePreloaders.next(activePreloaders);
+    }
+    delete(endpoint) {
+        let activePreloaders = this.activePreloaders.getValue();
+        activePreloaders = activePreloaders.filter((preloader) => preloader !== endpoint);
+        this.activePreloaders.next(activePreloaders);
+    }
+}
+PreloaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PreloaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PreloaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PreloaderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PreloaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/property/corelogic/corelogic.service.mjs

@@ -0,0 +1,46 @@
+import { Inject, Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { CorelogicSuggestion } from '../../../models/property/corelogic-suggestion';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class CorelogicService {
+    constructor(http, environment) {
+        this.http = http;
+        this.environment = environment;
+        this.accessTokenSubject = new ReplaySubject(1);
+    }
+    getAccessToken(force = false) {
+        if (!this._accessToken || force) {
+            this.http.get(`${this.environment.coreLogicUrl}/access/oauth/token?grant_type=client_credentials&client_id=${this.environment.coreLogicId}&client_secret=${this.environment.coreLogicSecret}`)
+                .pipe(map((response) => {
+                return response.access_token;
+            }))
+                .subscribe((token) => {
+                this._accessToken = token;
+                this.accessTokenSubject.next(this._accessToken);
+            });
+        }
+        return this.accessTokenSubject.asObservable();
+    }
+    getSuggestions(query, country = 'au') {
+        // @TODO handle different countries in future
+        return this.http.get(`${this.environment.coreLogicUrl}/property/${country}/v2/suggest.json?q=${query}`)
+            .pipe(map((response) => {
+            return response.suggestions.map((item) => plainToClass(CorelogicSuggestion, item));
+        }));
+    }
+}
+CorelogicService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: CorelogicService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+CorelogicService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: CorelogicService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: CorelogicService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/property/equity-position-chart/equity-position-chart.service.mjs

@@ -0,0 +1,45 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { ChartData } from '../../../models/chart/chart-data';
+import { ChartSerie } from '../../../models/chart/chart-serie';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Service for get property equity position half-year history chart data
+ */
+export class EquityPositionChartService {
+    constructor(http, environment) {
+        this.http = http;
+        this.environment = environment;
+    }
+    get() {
+        // @TODO refactor backend
+        return this.http.get(`${this.environment.apiV2}/properties/categories/equity`)
+            .pipe(map((response) => {
+            return response.map((item) => {
+                return plainToClass(ChartData, {
+                    name: item.category.name,
+                    data: item.equity.map((serie) => {
+                        return plainToClass(ChartSerie, {
+                            label: serie.date,
+                            value: serie.amount
+                        });
+                    })
+                });
+            });
+        }));
+    }
+}
+EquityPositionChartService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: EquityPositionChartService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+EquityPositionChartService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: EquityPositionChartService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: EquityPositionChartService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXF1aXR5LXBvc2l0aW9uLWNoYXJ0LnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvcHJvcGVydHkvZXF1aXR5LXBvc2l0aW9uLWNoYXJ0L2VxdWl0eS1wb3NpdGlvbi1jaGFydC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBR25ELE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUNyQyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDakQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQzdELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQzs7O0FBRS9EOztHQUVHO0FBSUgsTUFBTSxPQUFPLDBCQUEwQjtJQUNyQyxZQUNVLElBQWdCLEVBQ08sV0FBZ0I7UUFEdkMsU0FBSSxHQUFKLElBQUksQ0FBWTtRQUNPLGdCQUFXLEdBQVgsV0FBVyxDQUFLO0lBQzdDLENBQUM7SUFFTCxHQUFHO1FBQ0QseUJBQXlCO1FBQ3pCLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLEtBQUssK0JBQStCLENBQUM7YUFDM0UsSUFBSSxDQUNILEdBQUcsQ0FBQyxDQUFDLFFBQWUsRUFBZSxFQUFFO1lBQ25DLE9BQU8sUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQVMsRUFBRSxFQUFFO2dCQUNoQyxPQUFPLFlBQVksQ0FBQyxTQUFTLEVBQUU7b0JBQzdCLElBQUksRUFBRSxJQUFJLENBQUMsUUFBUSxDQUFDLElBQUk7b0JBQ3hCLElBQUksRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEtBQVUsRUFBRSxFQUFFO3dCQUNuQyxPQUFPLFlBQVksQ0FBQyxVQUFVLEVBQUU7NEJBQzlCLEtBQUssRUFBRSxLQUFLLENBQUMsSUFBSTs0QkFDakIsS0FBSyxFQUFFLEtBQUssQ0FBQyxNQUFNO3lCQUNwQixDQUFDLENBQUM7b0JBQ0wsQ0FBQyxDQUFDO2lCQUNILENBQUMsQ0FBQztZQUNMLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQyxDQUFDLENBQ0gsQ0FBQztJQUNOLENBQUM7O3VIQXhCVSwwQkFBMEIsNENBRzNCLGFBQWE7MkhBSFosMEJBQTBCLGNBRnpCLE1BQU07MkZBRVAsMEJBQTBCO2tCQUh0QyxVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQjs7MEJBSUksTUFBTTsyQkFBQyxhQUFhIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0LCBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBIdHRwQ2xpZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuaW1wb3J0IHsgbWFwIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuaW1wb3J0IHsgcGxhaW5Ub0NsYXNzIH0gZnJvbSAnY2xhc3MtdHJhbnNmb3JtZXInO1xuaW1wb3J0IHsgQ2hhcnREYXRhIH0gZnJvbSAnLi4vLi4vLi4vbW9kZWxzL2NoYXJ0L2NoYXJ0LWRhdGEnO1xuaW1wb3J0IHsgQ2hhcnRTZXJpZSB9IGZyb20gJy4uLy4uLy4uL21vZGVscy9jaGFydC9jaGFydC1zZXJpZSc7XG5cbi8qKlxuICogU2VydmljZSBmb3IgZ2V0IHByb3BlcnR5IGVxdWl0eSBwb3NpdGlvbiBoYWxmLXllYXIgaGlzdG9yeSBjaGFydCBkYXRhXG4gKi9cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIEVxdWl0eVBvc2l0aW9uQ2hhcnRTZXJ2aWNlIHtcbiAgY29uc3RydWN0b3IoXG4gICAgcHJpdmF0ZSBodHRwOiBIdHRwQ2xpZW50LFxuICAgIEBJbmplY3QoJ2Vudmlyb25tZW50JykgcHJpdmF0ZSBlbnZpcm9ubWVudDogYW55XG4gICkgeyB9XG5cbiAgZ2V0KCk6IE9ic2VydmFibGU8Q2hhcnREYXRhW10+IHtcbiAgICAvLyBAVE9ETyByZWZhY3RvciBiYWNrZW5kXG4gICAgcmV0dXJuIHRoaXMuaHR0cC5nZXQoYCR7dGhpcy5lbnZpcm9ubWVudC5hcGlWMn0vcHJvcGVydGllcy9jYXRlZ29yaWVzL2VxdWl0eWApXG4gICAgICAucGlwZShcbiAgICAgICAgbWFwKChyZXNwb25zZTogYW55W10pOiBDaGFydERhdGFbXSA9PiB7XG4gICAgICAgICAgcmV0dXJuIHJlc3BvbnNlLm1hcCgoaXRlbTogYW55KSA9PiB7XG4gICAgICAgICAgICByZXR1cm4gcGxhaW5Ub0NsYXNzKENoYXJ0RGF0YSwge1xuICAgICAgICAgICAgICBuYW1lOiBpdGVtLmNhdGVnb3J5Lm5hbWUsXG4gICAgICAgICAgICAgIGRhdGE6IGl0ZW0uZXF1aXR5Lm1hcCgoc2VyaWU6IGFueSkgPT4ge1xuICAgICAgICAgICAgICAgIHJldHVybiBwbGFpblRvQ2xhc3MoQ2hhcnRTZXJpZSwge1xuICAgICAgICAgICAgICAgICAgbGFiZWw6IHNlcmllLmRhdGUsXG4gICAgICAgICAgICAgICAgICB2YWx1ZTogc2VyaWUuYW1vdW50XG4gICAgICAgICAgICAgICAgfSk7XG4gICAgICAgICAgICAgIH0pXG4gICAgICAgICAgICB9KTtcbiAgICAgICAgICB9KTtcbiAgICAgICAgfSlcbiAgICAgICk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/services/property/property-calculation/property-calculation.service.mjs

@@ -0,0 +1,177 @@
+import { Injectable } from '@angular/core';
+import { combineLatest } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Dictionary } from '../../../models/dictionary/dictionary';
+import { Badge } from '../../../models/badge/badge';
+import { BadgeColorEnum } from '../../../models/badge/badge-color.enum';
+import * as i0 from "@angular/core";
+/**
+ * Service with calculations methods for properties related with other entities.
+ * Logic here works like collections methods but for several entities
+ */
+export class PropertyCalculationService {
+    getTaxPosition(transactions, depreciations) {
+        // @TODO hack: math abs added because we have mismatching of real values signs
+        return transactions.grossClaimAmount - Math.abs(depreciations.claimAmount);
+    }
+    getTaxPosition$(transactions$, depreciations$) {
+        return combineLatest([
+            transactions$,
+            depreciations$
+        ]).pipe(map(([transactions, depreciations]) => {
+            return this.getTaxPosition(transactions, depreciations);
+        }));
+    }
+    taxPositionGrowth(properties, transactions, depreciations) {
+        const forecastedTaxPosition = properties.sumBy('forecastedTaxPosition');
+        // check if forecastedTaxPosition = 0 to avoid division by zero
+        if (!forecastedTaxPosition) {
+            return 0;
+        }
+        return (this.getTaxPosition(transactions, depreciations) - forecastedTaxPosition) / forecastedTaxPosition;
+    }
+    taxPositionGrowth$(properties$, transactions$, depreciations$) {
+        return combineLatest([
+            properties$,
+            transactions$,
+            depreciations$
+        ]).pipe(map(([properties, transactions, depreciations]) => {
+            return this.taxPositionGrowth(properties, transactions, depreciations);
+        }));
+    }
+    getRentalReturn(properties, transactions) {
+        return transactions.claimIncome / properties.marketValue;
+    }
+    getLoanAmount(properties, bankAccounts, loans) {
+        return properties.items.reduce((totalAmount, property) => {
+            return totalAmount + bankAccounts.items
+                .reduce((propertyAmount, bankAccount) => {
+                return propertyAmount + bankAccount.getPropertyPercentage(property.id) * (loans.getByBankAccountId(bankAccount.id)?.amount || 0);
+            }, 0);
+        }, 0);
+    }
+    getLoanValue(properties, bankAccounts) {
+        return properties.items.reduce((totalAmount, property) => {
+            return totalAmount + bankAccounts.items
+                .reduce((propertyAmount, bankAccount) => {
+                return propertyAmount + bankAccount.getPropertyBalanceAmount(property.id);
+            }, 0);
+        }, 0);
+    }
+    /**
+     * LVR
+     */
+    getLvr(properties, bankAccounts) {
+        // Math abs is required for correct percentage calculation
+        return Math.abs(this.getLoanValue(properties, bankAccounts)) / properties.marketValue;
+    }
+    getLvr$(properties$, bankAccounts$) {
+        return combineLatest([
+            properties$,
+            bankAccounts$
+        ]).pipe(map(([properties, bankAccounts]) => {
+            return this.getLvr(properties, bankAccounts);
+        }));
+    }
+    getLvrCommencement(properties, loans, bankAccounts) {
+        // Math abs is required for correct percentage calculation
+        return Math.abs(this.getLoanAmount(properties, bankAccounts, loans)) / properties.purchasePrice;
+    }
+    getLvrCommencement$(properties$, bankAccounts$, loans$) {
+        return combineLatest([
+            properties$,
+            bankAccounts$,
+            loans$
+        ]).pipe(map(([properties, bankAccounts, loans]) => {
+            return this.getLvrCommencement(properties, loans, bankAccounts);
+        }));
+    }
+    getLvrGrowth(properties, bankAccounts, loans) {
+        const lvr = this.getLvr(properties, bankAccounts);
+        const lvrCommencement = this.getLvrCommencement(properties, loans, bankAccounts);
+        if (!lvrCommencement) {
+            // check if lvrCommencement = 0 to avoid division by zero
+            return 0;
+        }
+        return (this.getLvr(properties, bankAccounts) - lvrCommencement) / lvrCommencement;
+    }
+    getLvrGrowth$(properties$, bankAccounts$, loans$) {
+        return combineLatest([
+            properties$,
+            bankAccounts$,
+            loans$
+        ]).pipe(map(([properties, bankAccounts, loans]) => {
+            return this.getLvrGrowth(properties, bankAccounts, loans);
+        }));
+    }
+    /**
+     * Equity position = Market value - current loan value
+     */
+    getEquityPosition(properties, bankAccounts) {
+        // Math abs is required for correct percentage calculation
+        return properties.marketValue - Math.abs(this.getLoanValue(properties, bankAccounts));
+    }
+    /**
+     * Purchase Equity = Purchase price - initial loan value
+     */
+    getPurchaseEquity(properties, bankAccounts, loans) {
+        // Math abs is required for correct percentage calculation
+        return properties.purchasePrice - Math.abs(this.getLoanAmount(properties, bankAccounts, loans));
+    }
+    getEquityGrowth(properties, bankAccounts, loans) {
+        const purchaseEquity = this.getPurchaseEquity(properties, bankAccounts, loans);
+        // check if purchaseEquity = 0 to avoid division by zero
+        if (!purchaseEquity) {
+            return 0;
+        }
+        return (this.getEquityPosition(properties, bankAccounts) - purchaseEquity) / purchaseEquity;
+    }
+    /**
+     * Get dictionary of badges for each property in collection
+     */
+    getBadgesByProperty(properties, transactions, depreciations) {
+        const badgesByProperty = new Dictionary([]);
+        properties.toArray().forEach((property) => {
+            badgesByProperty.add(property.id, this.getBadge(property, properties, transactions, depreciations));
+        });
+        return badgesByProperty;
+    }
+    getCashPositionGrowth(properties, transactions) {
+        const forecastedCashPosition = properties.sumBy('forecastedCashPosition');
+        // check if forecastedCashPosition = 0 to avoid division by zero
+        if (!forecastedCashPosition) {
+            return 0;
+        }
+        return (transactions.grossClaimAmount - forecastedCashPosition) / forecastedCashPosition;
+    }
+    /**
+     * Get Badge for single property in collection
+     */
+    getBadge(property, properties, transactions, depreciations) {
+        // best performance properties could be only from active properties list
+        const activeProperties = properties.getActiveProperties();
+        const bestPerformanceGrowthProperty = activeProperties.getBestPerformanceGrowthProperty();
+        const bestPerformanceTaxProperty = activeProperties.getBestPerformanceTaxProperty(transactions, depreciations);
+        switch (true) {
+            case !property.isActive:
+                return new Badge('Inactive', BadgeColorEnum.GRAY);
+            case property.id === bestPerformanceTaxProperty.id && property.id === bestPerformanceGrowthProperty.id:
+                return new Badge('Best performance growth & tax', BadgeColorEnum.GOLD);
+            case property.id === bestPerformanceTaxProperty.id:
+                return new Badge('Best performance tax', BadgeColorEnum.GOLD);
+            case property.id === bestPerformanceGrowthProperty.id:
+                return new Badge('Best performance growth', BadgeColorEnum.GREEN);
+            default:
+                return new Badge('Monitoring performance');
+        }
+    }
+}
+PropertyCalculationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyCalculationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PropertyCalculationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyCalculationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: PropertyCalculationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"property-calculation.service.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/services/property/property-calculation/property-calculation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { combineLatest, Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { BankAccountCollection } from '../../../collections/bank-account.collection';\nimport { DepreciationCollection } from '../../../collections/depreciation.collection';\nimport { LoanCollection } from '../../../collections/loan/loan.collection';\nimport { PropertyCollection } from '../../../collections/property/property.collection';\nimport { TransactionCollection } from '../../../collections/transaction/transaction.collection';\nimport { Property } from '../../../models/property/property';\nimport { BankAccount } from '../../../models/bank/bank-account';\nimport { Dictionary } from '../../../models/dictionary/dictionary';\nimport { Badge } from '../../../models/badge/badge';\nimport { BadgeColorEnum } from '../../../models/badge/badge-color.enum';\n\n/**\n * Service with calculations methods for properties related with other entities.\n * Logic here works like collections methods but for several entities\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class PropertyCalculationService {\n  getTaxPosition(transactions: TransactionCollection, depreciations: DepreciationCollection): number {\n    // @TODO hack: math abs added because we have mismatching of real values signs\n    return transactions.grossClaimAmount - Math.abs(depreciations.claimAmount);\n  }\n\n  getTaxPosition$(\n    transactions$: Observable<TransactionCollection>,\n    depreciations$: Observable<DepreciationCollection>\n  ): Observable<number> {\n    return combineLatest([\n      transactions$,\n      depreciations$\n    ]).pipe(\n      map(([transactions, depreciations]: [TransactionCollection, DepreciationCollection]): number => {\n        return this.getTaxPosition(transactions, depreciations);\n      })\n    );\n  }\n\n  taxPositionGrowth(properties: PropertyCollection, transactions: TransactionCollection, depreciations: DepreciationCollection): number {\n    const forecastedTaxPosition: number = properties.sumBy('forecastedTaxPosition');\n    // check if forecastedTaxPosition = 0 to avoid division by zero\n    if (!forecastedTaxPosition) {\n      return 0;\n    }\n\n    return (this.getTaxPosition(transactions, depreciations) - forecastedTaxPosition) / forecastedTaxPosition;\n  }\n\n  taxPositionGrowth$(\n    properties$: Observable<PropertyCollection>,\n    transactions$: Observable<TransactionCollection>,\n    depreciations$: Observable<DepreciationCollection>\n  ): Observable<number> {\n    return combineLatest([\n      properties$,\n      transactions$,\n      depreciations$\n    ]).pipe(\n      map(([properties, transactions, depreciations]: [PropertyCollection, TransactionCollection, DepreciationCollection]): number => {\n        return this.taxPositionGrowth(properties, transactions, depreciations);\n      })\n    );\n  }\n\n  getRentalReturn(properties: PropertyCollection, transactions: TransactionCollection): number {\n    return transactions.claimIncome / properties.marketValue;\n  }\n\n  getLoanAmount(properties: PropertyCollection, bankAccounts: BankAccountCollection, loans: LoanCollection): number {\n    return properties.items.reduce((totalAmount: number, property: Property): number => {\n      return totalAmount + bankAccounts.items\n        .reduce((propertyAmount: number, bankAccount: BankAccount): number => {\n          return propertyAmount + bankAccount.getPropertyPercentage(property.id) * (loans.getByBankAccountId(bankAccount.id)?.amount || 0);\n        }, 0);\n    }, 0);\n  }\n\n  getLoanValue(properties: PropertyCollection, bankAccounts: BankAccountCollection): number {\n    return properties.items.reduce((totalAmount: number, property: Property): number => {\n      return totalAmount + bankAccounts.items\n        .reduce((propertyAmount: number, bankAccount: BankAccount): number => {\n          return propertyAmount + bankAccount.getPropertyBalanceAmount(property.id);\n        }, 0);\n    }, 0);\n  }\n\n  /**\n   * LVR\n   */\n\n  getLvr(properties: PropertyCollection, bankAccounts: BankAccountCollection): number {\n    // Math abs is required for correct percentage calculation\n    return Math.abs(this.getLoanValue(properties, bankAccounts)) / properties.marketValue;\n  }\n\n  getLvr$(\n    properties$: Observable<PropertyCollection>,\n    bankAccounts$: Observable<BankAccountCollection>\n  ): Observable<number> {\n    return combineLatest([\n      properties$,\n      bankAccounts$\n    ]).pipe(\n      map(([properties, bankAccounts]: [PropertyCollection, BankAccountCollection]): number => {\n        return this.getLvr(properties, bankAccounts);\n      })\n    );\n  }\n\n  getLvrCommencement(properties: PropertyCollection, loans: LoanCollection, bankAccounts: BankAccountCollection): number {\n    // Math abs is required for correct percentage calculation\n    return Math.abs(this.getLoanAmount(properties, bankAccounts, loans)) / properties.purchasePrice;\n  }\n\n  getLvrCommencement$(\n    properties$: Observable<PropertyCollection>,\n    bankAccounts$: Observable<BankAccountCollection>,\n    loans$: Observable<LoanCollection>\n  ): Observable<number> {\n    return combineLatest([\n      properties$,\n      bankAccounts$,\n      loans$\n    ]).pipe(\n      map(([properties, bankAccounts, loans]: [PropertyCollection, BankAccountCollection, LoanCollection]): number => {\n        return this.getLvrCommencement(properties, loans, bankAccounts);\n      })\n    );\n  }\n\n  getLvrGrowth(properties: PropertyCollection, bankAccounts: BankAccountCollection, loans: LoanCollection): number {\n    const lvr: number = this.getLvr(properties, bankAccounts);\n    const lvrCommencement: number = this.getLvrCommencement(properties, loans, bankAccounts);\n    if (!lvrCommencement) {\n      // check if lvrCommencement = 0 to avoid division by zero\n      return 0;\n    }\n\n    return (this.getLvr(properties, bankAccounts) - lvrCommencement) / lvrCommencement;\n  }\n\n  getLvrGrowth$(\n    properties$: Observable<PropertyCollection>,\n    bankAccounts$: Observable<BankAccountCollection>,\n    loans$: Observable<LoanCollection>\n  ): Observable<number> {\n    return combineLatest([\n      properties$,\n      bankAccounts$,\n      loans$\n    ]).pipe(\n      map(([properties, bankAccounts, loans]: [PropertyCollection, BankAccountCollection, LoanCollection]): number => {\n        return this.getLvrGrowth(properties, bankAccounts, loans);\n      })\n    );\n  }\n\n  /**\n   * Equity position = Market value - current loan value\n   */\n  getEquityPosition(properties: PropertyCollection, bankAccounts: BankAccountCollection): number {\n    // Math abs is required for correct percentage calculation\n    return properties.marketValue - Math.abs(this.getLoanValue(properties, bankAccounts));\n  }\n\n  /**\n   * Purchase Equity = Purchase price - initial loan value\n   */\n  getPurchaseEquity(properties: PropertyCollection, bankAccounts: BankAccountCollection, loans: LoanCollection): number {\n    // Math abs is required for correct percentage calculation\n    return properties.purchasePrice - Math.abs(this.getLoanAmount(properties, bankAccounts, loans));\n  }\n\n  getEquityGrowth(properties: PropertyCollection, bankAccounts: BankAccountCollection, loans: LoanCollection): number {\n    const purchaseEquity: number = this.getPurchaseEquity(properties, bankAccounts, loans);\n    // check if purchaseEquity = 0 to avoid division by zero\n    if (!purchaseEquity) {\n      return 0;\n    }\n\n    return (this.getEquityPosition(properties, bankAccounts) - purchaseEquity) / purchaseEquity;\n  }\n\n  /**\n   * Get dictionary of badges for each property in collection\n   */\n  getBadgesByProperty(properties: PropertyCollection, transactions: TransactionCollection, depreciations: DepreciationCollection): Dictionary<Badge> {\n    const badgesByProperty = new Dictionary([]);\n\n    properties.toArray().forEach((property: Property) => {\n      badgesByProperty.add(property.id, this.getBadge(property, properties, transactions, depreciations));\n    });\n\n    return badgesByProperty;\n  }\n\n  getCashPositionGrowth(properties: PropertyCollection, transactions: TransactionCollection): number {\n    const forecastedCashPosition: number = properties.sumBy('forecastedCashPosition');\n\n    // check if forecastedCashPosition = 0 to avoid division by zero\n    if (!forecastedCashPosition) {\n      return 0;\n    }\n\n    return (transactions.grossClaimAmount - forecastedCashPosition) / forecastedCashPosition;\n  }\n\n  /**\n   * Get Badge for single property in collection\n   */\n  private getBadge(property: Property, properties: PropertyCollection, transactions: TransactionCollection, depreciations: DepreciationCollection): Badge {\n    // best performance properties could be only from active properties list\n    const activeProperties: PropertyCollection = properties.getActiveProperties();\n    const bestPerformanceGrowthProperty: Property = activeProperties.getBestPerformanceGrowthProperty();\n    const bestPerformanceTaxProperty: Property = activeProperties.getBestPerformanceTaxProperty(\n      transactions, depreciations\n    );\n\n    switch (true) {\n      case !property.isActive:\n        return new Badge('Inactive', BadgeColorEnum.GRAY);\n      case property.id === bestPerformanceTaxProperty.id && property.id === bestPerformanceGrowthProperty.id:\n        return new Badge('Best performance growth & tax', BadgeColorEnum.GOLD);\n      case property.id === bestPerformanceTaxProperty.id:\n        return new Badge('Best performance tax', BadgeColorEnum.GOLD);\n      case property.id === bestPerformanceGrowthProperty.id:\n        return new Badge('Best performance growth', BadgeColorEnum.GREEN);\n      default:\n        return new Badge('Monitoring performance');\n    }\n  }\n}\n"]}