taxtank-core 0.0.2 → 0.1.2

package/esm2015/lib/services/income-source/salary-forecast.service.js

@@ -0,0 +1,90 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { BaseRestService } from '../base-rest.service';
+import { SalaryForecast } from '../../models/income-source/salary-forecast';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { IncomeSource } from '../../models/income-source/income-source';
+import { AppEvent } from '../../models/event/app-event';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../event/event-dispatcher.service";
+/**
+ * Service to work with Salary Forecasts
+ */
+export class SalaryForecastService extends BaseRestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.modelClass = SalaryForecast;
+        this.url = 'salary-forecasts';
+        this.listenEvents();
+    }
+    /**
+     * Listen to Income Sources events
+     */
+    listenEvents() {
+        this.listenToAddedIncomeSources();
+        this.listenToUpdatedIncomeSources();
+    }
+    /**
+     * Listen to EventDispatcherService event related to added Income Sources
+     */
+    listenToAddedIncomeSources() {
+        this.eventDispatcherService.on(AppEventTypeEnum.INCOME_SOURCES_CREATED)
+            .pipe(map((incomeSources) => incomeSources
+            .filter((incomeSource) => incomeSource.isSalaryIncome())))
+            .subscribe((incomeSources) => {
+            const salaryForecasts = this.assignSalaryForecasts(incomeSources);
+            if (salaryForecasts.length) {
+                this.addBatch(salaryForecasts).subscribe((createdSalaryForecasts) => {
+                    this.eventDispatcherService
+                        .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_CREATED, createdSalaryForecasts));
+                });
+            }
+        });
+    }
+    /**
+     * Listen to EventDispatcherService event related to updated Income Sources
+     */
+    listenToUpdatedIncomeSources() {
+        this.eventDispatcherService.on(AppEventTypeEnum.INCOME_SOURCES_UPDATED)
+            .subscribe((incomeSources) => {
+            const salaryForecasts = this.assignSalaryForecasts(incomeSources);
+            if (salaryForecasts.length) {
+                this.updateBatch(salaryForecasts).subscribe((updatedSalaryForecasts) => {
+                    this.eventDispatcherService
+                        .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_UPDATED, updatedSalaryForecasts));
+                });
+            }
+        });
+    }
+    /**
+     * Assign salary forecasts based on provided income sources
+     * @param incomeSources by which salary forecasts will be assigned
+     */
+    assignSalaryForecasts(incomeSources) {
+        return incomeSources.map((incomeSource) => {
+            incomeSource.salaryForecasts = incomeSource.salaryForecasts
+                .map((salaryForecast) => {
+                salaryForecast.incomeSource = plainToClass(IncomeSource, { id: incomeSource.id });
+                return salaryForecast;
+            });
+            return incomeSource.salaryForecasts;
+        }).flat();
+    }
+}
+SalaryForecastService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SalaryForecastService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+SalaryForecastService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SalaryForecastService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SalaryForecastService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"salary-forecast.service.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/services/income-source/salary-forecast.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { SalaryForecast as SalaryForecastBase } from '../../db/Models/salary-forecast';\nimport { HttpClient } from '@angular/common/http';\nimport { map } from 'rxjs/operators';\nimport { plainToClass } from 'class-transformer';\nimport { BaseRestService } from '../base-rest.service';\nimport { IEventListener } from '../../interfaces/event-listener.interface';\nimport { SalaryForecast } from '../../models/income-source/salary-forecast';\nimport { EventDispatcherService } from '../event/event-dispatcher.service';\nimport { AppEventTypeEnum } from '../../models/event/app-event-type.enum';\nimport { IncomeSource } from '../../models/income-source/income-source';\nimport { AppEvent } from '../../models/event/app-event';\n\n/**\n * Service to work with Salary Forecasts\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class SalaryForecastService extends BaseRestService<SalaryForecastBase, SalaryForecast> implements IEventListener {\n  modelClass: typeof SalaryForecast = SalaryForecast;\n  url: string = 'salary-forecasts';\n\n  constructor(\n    protected http: HttpClient,\n    protected eventDispatcherService: EventDispatcherService,\n    @Inject('environment') protected environment: any\n  ) {\n    super(http, eventDispatcherService, environment);\n    this.listenEvents();\n  }\n\n  /**\n   * Listen to Income Sources events\n   */\n  listenEvents(): void {\n    this.listenToAddedIncomeSources();\n    this.listenToUpdatedIncomeSources();\n  }\n\n  /**\n   * Listen to EventDispatcherService event related to added Income Sources\n   */\n  private listenToAddedIncomeSources(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.INCOME_SOURCES_CREATED)\n      .pipe(\n        map((incomeSources: IncomeSource[]) => incomeSources\n          .filter((incomeSource: IncomeSource) => incomeSource.isSalaryIncome()))\n      )\n      .subscribe((incomeSources: IncomeSource[]) => {\n\n        const salaryForecasts: SalaryForecast[] = this.assignSalaryForecasts(incomeSources);\n        if (salaryForecasts.length) {\n          this.addBatch(salaryForecasts).subscribe((createdSalaryForecasts: SalaryForecast[]) => {\n            this.eventDispatcherService\n              .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_CREATED, createdSalaryForecasts));\n          });\n        }\n      });\n  }\n\n  /**\n   * Listen to EventDispatcherService event related to updated Income Sources\n   */\n  private listenToUpdatedIncomeSources(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.INCOME_SOURCES_UPDATED)\n      .subscribe((incomeSources: IncomeSource[]) => {\n        const salaryForecasts: SalaryForecast[] = this.assignSalaryForecasts(incomeSources);\n        if (salaryForecasts.length) {\n          this.updateBatch(salaryForecasts).subscribe((updatedSalaryForecasts: SalaryForecast[]) => {\n            this.eventDispatcherService\n              .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_UPDATED, updatedSalaryForecasts));\n          });\n        }\n      });\n  }\n\n  /**\n   * Assign salary forecasts based on provided income sources\n   * @param incomeSources by which salary forecasts will be assigned\n   */\n  private assignSalaryForecasts(incomeSources: IncomeSource[]): SalaryForecast[] {\n    return incomeSources.map((incomeSource: IncomeSource) => {\n      incomeSource.salaryForecasts = incomeSource.salaryForecasts\n        .map((salaryForecast: SalaryForecast) => {\n          salaryForecast.incomeSource = plainToClass(IncomeSource, {id: incomeSource.id});\n          return salaryForecast;\n        });\n      return incomeSource.salaryForecasts;\n    }).flat();\n  }\n}\n"]}

package/esm2015/lib/services/intercom/intercom.service.js

@@ -0,0 +1,41 @@
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with intercom
+ */
+export class IntercomService {
+    constructor(environment) {
+        this.environment = environment;
+    }
+    /**
+     * Init object with user credentials
+     * @param user
+     */
+    initUser(user) {
+        return {
+            app_id: this.environment.intercomAppId,
+            email: user.email,
+            user_hash: user.hashedEmail
+        };
+    }
+    /**
+     * Init connection for provided data
+     * @param user
+     */
+    initConnection(user) {
+        const connectionCredentials = this.initUser(user);
+        window.Intercom('boot', connectionCredentials);
+    }
+}
+IntercomService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: IntercomService, deps: [{ token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+IntercomService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: IntercomService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: IntercomService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/loan/loan.service.js

@@ -0,0 +1,145 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { replace } from '../../functions/array';
+import { BaseRestService } from '../base-rest.service';
+import { plainToClass } from 'class-transformer';
+import { Loan } from '../../models/loan/loan';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { AppEvent } from '../../models/event/app-event';
+import { LoanPayout } from '../../models/loan/loan-payout';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../event/event-dispatcher.service";
+/**
+ * Service that handling loans logic
+ */
+export class LoanService extends BaseRestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.url = 'bank-accounts/loans';
+        this.modelClass = Loan;
+        this.listenEvents();
+    }
+    /**
+     * Listen to Loans events
+     */
+    listenEvents() {
+        this.listenToAddedLoans();
+        this.listenToUpdatedBankAccounts();
+    }
+    listenToAddedLoans() {
+        this.eventDispatcherService.on(AppEventTypeEnum.BANK_ACCOUNT_CREATED)
+            .subscribe((bankAccounts) => {
+            // fetch loans when loan bank account created
+            if (bankAccounts.find(ba => !!ba.loan)) {
+                this.resetCache();
+            }
+        });
+    }
+    listenToUpdatedBankAccounts() {
+        this.eventDispatcherService.on(AppEventTypeEnum.BANK_ACCOUNT_UPDATED)
+            .subscribe((updatedBankAccount) => {
+            if (!!updatedBankAccount.loan) {
+                this.resetCache();
+            }
+        });
+    }
+    /**
+     * Create Loan
+     */
+    add(model) {
+        return this.addBatch([model])
+            .pipe(map((newLoan) => {
+            return newLoan[0];
+        }));
+    }
+    /**
+     * Updated loan
+     * @param loan
+     */
+    update(loan) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}/${loan.id}`, loan)
+            .pipe(map((updatedLoanBase) => {
+            const updatedLoan = plainToClass(Loan, updatedLoanBase);
+            // if loan type is NOT vehicle - fire EventDispatcher event
+            if (!updatedLoan.isVehicle()) {
+                this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_UPDATED, null));
+            }
+            replace(this.cache, updatedLoan);
+            this.updateCache();
+            return updatedLoan;
+        }));
+    }
+    /**
+     * Get list of vehicle loans
+     */
+    getVehicleLoans() {
+        return this.get()
+            .pipe(map((loans) => {
+            return loans.filter((loan) => loan.isVehicle());
+        }));
+    }
+    /**
+     * Calculate loan payments
+     * @param loan
+     */
+    calculateLoanPayments(loan) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}/calculation`, loan).pipe(map((response) => {
+            return plainToClass(Loan, response);
+        }));
+    }
+    /**
+     * Add new loan payout
+     * @param loan
+     * @param paidOutLoan
+     */
+    addPayoutLoan(loan, paidOutLoan) {
+        return this.http.post(`${this.environment.apiV2}/loans/${loan.id}/payout`, paidOutLoan).pipe(map((response) => {
+            loan.payout = plainToClass(LoanPayout, response);
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));
+            // reset cache to fetch loans with updated data
+            this.resetCache();
+        }));
+    }
+    /**
+     * Delete loan payout
+     * @param loan
+     * @param payout
+     */
+    deletePayoutLoan(loan, payout) {
+        return this.http.delete(`${this.environment.apiV2}/loans/${loan.id}/payout/${payout.id}`).pipe(map(() => {
+            loan.payout = null;
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));
+            // reset cache to fetch loans with updated data
+            this.resetCache();
+        }));
+    }
+    /**
+     * Update loan payout
+     * @param loan
+     * @param paidOutLoan
+     */
+    updatePayoutLoan(loan, paidOutLoan) {
+        return this.http.put(`${this.environment.apiV2}/loans/${loan.id}/payout/${paidOutLoan.id}`, paidOutLoan).pipe(map((response) => {
+            loan.payout = plainToClass(LoanPayout, response);
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));
+            // reset cache to fetch loans with updated data
+            this.resetCache();
+        }));
+    }
+}
+LoanService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: LoanService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+LoanService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: LoanService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: LoanService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loan.service.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/services/loan/loan.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { Loan as LoanBase } from '../../db/Models/loan';\nimport { map } from 'rxjs/operators';\nimport { replace } from '../../functions/array';\nimport { HttpClient } from '@angular/common/http';\nimport { BaseRestService } from '../base-rest.service';\nimport { plainToClass } from 'class-transformer';\nimport { Loan } from '../../models/loan/loan';\nimport { EventDispatcherService } from '../event/event-dispatcher.service';\nimport { AppEventTypeEnum } from '../../models/event/app-event-type.enum';\nimport { BankAccount } from '../../models/bank/bank-account';\nimport { AppEvent } from '../../models/event/app-event';\nimport { LoanPayout } from '../../models/loan/loan-payout';\n\n/**\n * Service that handling loans logic\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class LoanService extends BaseRestService<LoanBase, Loan> {\n  url: string = 'bank-accounts/loans';\n  modelClass: typeof Loan = Loan;\n\n  constructor(\n    protected http: HttpClient,\n    protected eventDispatcherService: EventDispatcherService,\n    @Inject('environment') protected environment: any\n  ) {\n    super(http, eventDispatcherService, environment);\n    this.listenEvents();\n  }\n\n  /**\n   * Listen to Loans events\n   */\n  listenEvents(): void {\n    this.listenToAddedLoans();\n    this.listenToUpdatedBankAccounts();\n  }\n\n  listenToAddedLoans(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.BANK_ACCOUNT_CREATED)\n      .subscribe((bankAccounts: BankAccount[]) => {\n        // fetch loans when loan bank account created\n        if (bankAccounts.find(ba => !!ba.loan)) {\n          this.resetCache();\n        }\n      });\n  }\n\n  listenToUpdatedBankAccounts(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.BANK_ACCOUNT_UPDATED)\n      .subscribe((updatedBankAccount: BankAccount): void => {\n        if (!!updatedBankAccount.loan) {\n          this.resetCache();\n        }\n      });\n  }\n\n  /**\n   * Create Loan\n   */\n  add(model: Loan): Observable<Loan> {\n    return this.addBatch([model])\n      .pipe(\n        map((newLoan: Loan[]): Loan => {\n          return newLoan[0];\n        })\n      );\n  }\n\n  /**\n   * Updated loan\n   * @param loan\n   */\n  update(loan: Loan): Observable<Loan> {\n    return this.http.put(`${this.environment.apiV2}/${this.url}/${loan.id}`, loan)\n      .pipe(\n        map((updatedLoanBase: LoanBase) => {\n          const updatedLoan: Loan = plainToClass(Loan, updatedLoanBase);\n          // if loan type is NOT vehicle - fire EventDispatcher event\n          if (!updatedLoan.isVehicle()) {\n            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_UPDATED, null));\n          }\n\n          replace(this.cache, updatedLoan);\n          this.updateCache();\n          return updatedLoan;\n        })\n      );\n  }\n\n  /**\n   * Get list of vehicle loans\n   */\n  getVehicleLoans(): Observable<Loan[]> {\n    return this.get()\n      .pipe(\n        map((loans: Loan[]) => {\n          return loans.filter((loan: Loan) => loan.isVehicle());\n        })\n      );\n  }\n\n  /**\n   * Calculate loan payments\n   * @param loan\n   */\n  calculateLoanPayments(loan: Loan): Observable<any> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}/calculation`, loan).pipe(\n      map((response: any) => {\n        return plainToClass(Loan, response);\n      })\n    );\n  }\n\n  /**\n   * Add new loan payout\n   * @param loan\n   * @param paidOutLoan\n   */\n  addPayoutLoan(loan: Loan, paidOutLoan: LoanPayout): Observable<any> {\n    return this.http.post(`${this.environment.apiV2}/loans/${loan.id}/payout`, paidOutLoan).pipe(\n      map((response: any) => {\n          loan.payout = plainToClass(LoanPayout, response);\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));\n          // reset cache to fetch loans with updated data\n          this.resetCache();\n        }\n      ));\n  }\n\n  /**\n   * Delete loan payout\n   * @param loan\n   * @param payout\n   */\n  deletePayoutLoan(loan: Loan, payout: LoanPayout): Observable<any> {\n    return this.http.delete(`${this.environment.apiV2}/loans/${loan.id}/payout/${payout.id}`).pipe(\n      map(() => {\n          loan.payout = null;\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));\n          // reset cache to fetch loans with updated data\n          this.resetCache();\n        }\n      ));\n  }\n\n  /**\n   * Update loan payout\n   * @param loan\n   * @param paidOutLoan\n   */\n  updatePayoutLoan(loan: Loan, paidOutLoan: LoanPayout): Observable<any> {\n    return this.http.put(`${this.environment.apiV2}/loans/${loan.id}/payout/${paidOutLoan.id}`, paidOutLoan).pipe(\n      map((response: any) => {\n          loan.payout = plainToClass(LoanPayout, response);\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));\n          // reset cache to fetch loans with updated data\n          this.resetCache();\n        }\n      ));\n  }\n}\n"]}

package/esm2015/lib/services/notification/notification.service.js

@@ -0,0 +1,65 @@
+import { Inject, Injectable } from '@angular/core';
+import { Notification } from '../../models/notification/notification';
+import { replace } from '../../functions/array';
+import { plainToClass } from 'class-transformer';
+import { BaseRestService } from '../base-rest.service';
+import { AppEvent } from '../../models/event/app-event';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import clone from 'lodash/clone';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../event/event-dispatcher.service";
+import * as i3 from "../event/sse.service";
+/**
+ * Service to handle service notifications logic
+ */
+export class NotificationService extends BaseRestService {
+    constructor(http, eventDispatcherService, environment, sseService) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.sseService = sseService;
+        this.modelClass = Notification;
+        this.url = 'service-notifications';
+        this.isHydra = true;
+        this.listenEvents();
+    }
+    /**
+     * SSE and Event Dispatcher Services listeners
+     */
+    listenEvents() {
+        this.listenNotifications();
+    }
+    /**
+     * subscribe to new chat messages
+     */
+    listenNotifications() {
+        this.sseService.on(`serviceNotification`).subscribe((notificationBase) => {
+            const notification = plainToClass(Notification, notificationBase);
+            const cache = clone(this.cache);
+            // update existing notification if read and add new notification if not read
+            if (notification.isRead) {
+                replace(cache, notification);
+            }
+            else {
+                cache.unshift(notification);
+            }
+            this.cache = cache;
+            this.cacheSubject.next(this.cache);
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.NOTIFICATION_ADDED, notification));
+        });
+    }
+}
+NotificationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: NotificationService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }, { token: i3.SseService }], target: i0.ɵɵFactoryTarget.Injectable });
+NotificationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: NotificationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i3.SseService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/preloader/preloader.service.js

@@ -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: "12.2.15", ngImport: i0, type: PreloaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PreloaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PreloaderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PreloaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/property/corelogic.service.js

@@ -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: "12.2.15", ngImport: i0, type: CorelogicService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+CorelogicService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: CorelogicService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", 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/esm2015/lib/services/property/property-calculation.service.js

@@ -0,0 +1,121 @@
+import { Injectable } from '@angular/core';
+import { combineLatest } from 'rxjs';
+import { map } from 'rxjs/operators';
+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.cashPosition - 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 taxPosition = this.getTaxPosition(transactions, depreciations);
+        // check if taxPosition = 0 to avoid division by zero
+        if (!taxPosition) {
+            return 0;
+        }
+        return (taxPosition - properties.forecastedTaxPosition) / taxPosition;
+    }
+    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) => {
+                var _a;
+                return propertyAmount + bankAccount.getPropertyPercentage(property.id) * (((_a = loans.getByBankAccountId(bankAccount.id)) === null || _a === void 0 ? void 0 : _a.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);
+        if (!lvr) {
+            // check if lvr = 0 to avoid division by zero
+            return 0;
+        }
+        return (lvr - this.getLvrCommencement(properties, loans, bankAccounts)) / lvr;
+    }
+    getLvrGrowth$(properties$, bankAccounts$, loans$) {
+        return combineLatest([
+            properties$,
+            bankAccounts$,
+            loans$
+        ]).pipe(map(([properties, bankAccounts, loans]) => {
+            return this.getLvrGrowth(properties, bankAccounts, loans);
+        }));
+    }
+    getEquityPosition(properties, bankAccounts) {
+        // Math abs is required for correct percentage calculation
+        return properties.marketValue - Math.abs(this.getLoanValue(properties, bankAccounts));
+    }
+    getPurchaseEquity(properties, bankAccounts, loans) {
+        // Math abs is required for correct percentage calculation
+        return properties.purchasePrice - Math.abs(this.getLoanAmount(properties, bankAccounts, loans));
+    }
+}
+PropertyCalculationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertyCalculationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PropertyCalculationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PropertyCalculationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", 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.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.collection';\nimport { PropertyCollection } from '../../collections/property.collection';\nimport { TransactionCollection } from '../../collections/transaction.collection';\nimport { Property } from '../../models/property/property';\nimport { BankAccount } from '../../models/bank/bank-account';\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.cashPosition - 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 taxPosition: number = this.getTaxPosition(transactions, depreciations);\n    // check if taxPosition = 0 to avoid division by zero\n    if (!taxPosition) {\n      return 0;\n    }\n\n    return (taxPosition - properties.forecastedTaxPosition) / taxPosition;\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    if (!lvr) {\n      // check if lvr = 0 to avoid division by zero\n      return 0;\n    }\n\n    return (lvr - this.getLvrCommencement(properties, loans, bankAccounts)) / lvr;\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  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  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"]}