taxtank-core 0.31.61 → 0.32.0

package/esm2022/lib/services/http/firm/firm.service.mjs

@@ -0,0 +1,63 @@
+import { Inject, Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { Firm } from '../../../models/firm/firm';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+// @TODO Alex: think about extend base rest service
+export class FirmService {
+    constructor(http, environment) {
+        this.http = http;
+        this.environment = environment;
+        this.firmSubject = new ReplaySubject(1);
+    }
+    /**
+     * Register new firm
+     * @param data: firm and firm owner data to register
+     */
+    register(data) {
+        return this.http.post(`${this.environment.apiV2}/firms/registration`, data)
+            .pipe(map((firm) => plainToClass(Firm, firm)));
+    }
+    get() {
+        if (!this.firm) {
+            this.http.get(`${this.environment.apiV2}/firms/current`)
+                .pipe(map((firm) => plainToClass(Firm, firm)))
+                .subscribe((firm) => {
+                this.firm = firm;
+                this.firmSubject.next(this.firm);
+            });
+        }
+        return this.firmSubject.asObservable();
+    }
+    update(firm) {
+        return this.http.put(`${this.environment.apiV2}/firms/current`, firm)
+            .pipe(map((updatedItem) => {
+            const updatedInstance = plainToClass(Firm, updatedItem);
+            this.firmSubject.next(updatedInstance);
+        }));
+    }
+    /**
+     * get list of all registered firms
+     */
+    getAll() {
+        return this.http.get(`${this.environment.apiV2}/firms`)
+            .pipe(map((response) => response['hydra:member'].map((firmBase) => plainToClass(Firm, firmBase))));
+    }
+    getByType(type) {
+        return this.getAll().pipe(map((firms) => firms.filter((firm) => firm.type === type)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FirmService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FirmService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FirmService, 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/esm2022/lib/services/http/firm/portfolio-report/client-portfolio-report.service.mjs

@@ -0,0 +1,37 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { ClientPortfolioReport } from '../../../../models/client/client-portfolio-report';
+import { ClientPortfolioReportCollection } from '../../../../collections/client-portfolio-report.collection';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+// @Todo refactor with BaseRest service
+/**
+ * Service to work with employee clients tax summary data
+ */
+export class ClientPortfolioReportService {
+    constructor(http, environment) {
+        this.http = http;
+        this.environment = environment;
+        this.url = 'portfolio-reports';
+    }
+    get() {
+        return this.http.get(`${this.environment.apiV2}/${this.url}`)
+            .pipe(map((response) => {
+            const clientReports = response.map((item) => plainToClass(ClientPortfolioReport, item));
+            return new ClientPortfolioReportCollection(clientReports);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ClientPortfolioReportService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ClientPortfolioReportService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ClientPortfolioReportService, 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/esm2022/lib/services/http/google/google.service.mjs

@@ -0,0 +1,80 @@
+import { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../toast";
+import * as i3 from "../../auth";
+import * as i4 from "@angular/router";
+import * as i5 from "../../mixpanel/mixpanel.service";
+/**
+ * Google instance
+ * https://developers.google.com/identity/oauth2/web/guides/overview
+ * https://developers.google.com/identity/gsi/web/guides/overview
+ */
+export class GoogleService {
+    constructor(http, toastService, jwtService, router, mpService, environment) {
+        this.http = http;
+        this.toastService = toastService;
+        this.jwtService = jwtService;
+        this.router = router;
+        this.mpService = mpService;
+        this.environment = environment;
+        this.isLoggedInSubject = new BehaviorSubject(!this.jwtService.isTokenExpired());
+        this.isGoogleEnabled = !!this.environment['googleClientId'];
+        // depending on the level of access
+        this.googleScope = 'https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/userinfo.email';
+    }
+    /**
+     * prompt for user consent and obtain an access token to work with user data
+     * requestAccessToken() method to trigger the token UX flow and obtain an access token.
+     * https://developers.google.com/identity/oauth2/web/guides/use-token-model
+     */
+    // prompt for user consent and obtain an access token to work with user data
+    login() {
+        return google.accounts.oauth2.initTokenClient({
+            client_id: this.environment['googleClientId'],
+            scope: this.googleScope,
+            callback: (response) => {
+                this.setAuth(response.access_token);
+            },
+        }).requestAccessToken();
+    }
+    /**
+     * requestAccessToken() method to trigger the token UX flow and obtain an access token:
+     * Choose their account;
+     * sign-in to the Google Account if not already signed-in;
+     * grant consent for your web app to access each requested scope.
+     */
+    setAuth(accessToken, redirectUrl = '/client') {
+        this.http.post(`${this.environment.apiV2}/users/authentication/google`, { accessToken })
+            .subscribe((response) => {
+            this.jwtService.saveTokens(response);
+            this.isLoggedInSubject.next(true);
+            this.mpService.track('loginGoogle');
+            this.router.navigate([redirectUrl]);
+        }, (error) => {
+            this.toastService.error(error.error.violations[0].message);
+            this.logout();
+        });
+    }
+    /**
+     * When the user signs out of your website, you need to call the method
+     * google.accounts.id.disableAutoSelect to record the status in cookies.
+     * https://developers.google.com/identity/oauth2/web/guides/use-token-model
+     */
+    logout() {
+        google.accounts.id.disableAutoSelect();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GoogleService, deps: [{ token: i1.HttpClient }, { token: i2.ToastService }, { token: i3.JwtService }, { token: i4.Router }, { token: i5.MixpanelService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GoogleService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GoogleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ToastService }, { type: i3.JwtService }, { type: i4.Router }, { type: i5.MixpanelService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/http/holding/holding-sale.service.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { HoldingSale } from '../../../models';
+import { RestService } from '../rest';
+import { HoldingSaleCollection } from '../../../collections';
+import * as i0 from "@angular/core";
+export class HoldingSaleService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = HoldingSale;
+        this.collectionClass = HoldingSaleCollection;
+        this.endpointUri = 'holding-sales';
+        this.isApiPlatform = true;
+        this.disabledMethods = ['postBatch', 'putBatch', 'deleteBatch'];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HoldingSaleService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HoldingSaleService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HoldingSaleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG9sZGluZy1zYWxlLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9ob2xkaW5nL2hvbGRpbmctc2FsZS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFM0MsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQzlDLE9BQU8sRUFBYyxXQUFXLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFFbEQsT0FBTyxFQUFDLHFCQUFxQixFQUFDLE1BQU0sc0JBQXNCLENBQUM7O0FBSzNELE1BQU0sT0FBTyxrQkFBbUIsU0FBUSxXQUFrRTtJQUgxRzs7UUFJRSxlQUFVLEdBQUcsV0FBVyxDQUFDO1FBQ3pCLG9CQUFlLEdBQUcscUJBQXFCLENBQUM7UUFDeEMsZ0JBQVcsR0FBRyxlQUFlLENBQUM7UUFDOUIsa0JBQWEsR0FBRyxJQUFJLENBQUM7UUFDckIsb0JBQWUsR0FBaUIsQ0FBQyxXQUFXLEVBQUUsVUFBVSxFQUFFLGFBQWEsQ0FBQyxDQUFDO0tBQzFFOytHQU5ZLGtCQUFrQjttSEFBbEIsa0JBQWtCLGNBRmpCLE1BQU07OzRGQUVQLGtCQUFrQjtrQkFIOUIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBIb2xkaW5nU2FsZSBhcyBIb2xkaW5nU2FsZUJhc2UgfSBmcm9tICcuLi8uLi8uLi9kYi9Nb2RlbHMnO1xuaW1wb3J0IHsgSG9sZGluZ1NhbGUgfSBmcm9tICcuLi8uLi8uLi9tb2RlbHMnO1xuaW1wb3J0IHsgUmVzdE1ldGhvZCwgUmVzdFNlcnZpY2UgfSBmcm9tICcuLi9yZXN0JztcbmltcG9ydCB7IENvbGxlY3Rpb24gfSBmcm9tICcuLi8uLi8uLi9jb2xsZWN0aW9ucyc7XG5pbXBvcnQge0hvbGRpbmdTYWxlQ29sbGVjdGlvbn0gZnJvbSAnLi4vLi4vLi4vY29sbGVjdGlvbnMnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBIb2xkaW5nU2FsZVNlcnZpY2UgZXh0ZW5kcyBSZXN0U2VydmljZTxIb2xkaW5nU2FsZUJhc2UsIEhvbGRpbmdTYWxlLCBDb2xsZWN0aW9uPEhvbGRpbmdTYWxlPj4ge1xuICBtb2RlbENsYXNzID0gSG9sZGluZ1NhbGU7XG4gIGNvbGxlY3Rpb25DbGFzcyA9IEhvbGRpbmdTYWxlQ29sbGVjdGlvbjtcbiAgZW5kcG9pbnRVcmkgPSAnaG9sZGluZy1zYWxlcyc7XG4gIGlzQXBpUGxhdGZvcm0gPSB0cnVlO1xuICBkaXNhYmxlZE1ldGhvZHM6IFJlc3RNZXRob2RbXSA9IFsncG9zdEJhdGNoJywgJ3B1dEJhdGNoJywgJ2RlbGV0ZUJhdGNoJ107XG59XG4iXX0=

package/esm2022/lib/services/http/holding/holding-type.service.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { HoldingType } from '../../../models';
+import { RestService } from '../rest';
+import { HoldingTypeCollection } from '../../../collections';
+import * as i0 from "@angular/core";
+export class HoldingTypeService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = HoldingType;
+        this.collectionClass = HoldingTypeCollection;
+        this.endpointUri = 'holding-types';
+        this.isApiPlatform = true;
+        this.disabledMethods = ['postBatch', 'putBatch', 'deleteBatch'];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HoldingTypeService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HoldingTypeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HoldingTypeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG9sZGluZy10eXBlLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvaHR0cC9ob2xkaW5nL2hvbGRpbmctdHlwZS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFM0MsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQzlDLE9BQU8sRUFBYyxXQUFXLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFDbEQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7O0FBSzdELE1BQU0sT0FBTyxrQkFBbUIsU0FBUSxXQUFnRTtJQUh4Rzs7UUFJRSxlQUFVLEdBQXVCLFdBQVcsQ0FBQztRQUM3QyxvQkFBZSxHQUFpQyxxQkFBcUIsQ0FBQztRQUN0RSxnQkFBVyxHQUFHLGVBQWUsQ0FBQztRQUM5QixrQkFBYSxHQUFHLElBQUksQ0FBQztRQUNyQixvQkFBZSxHQUFpQixDQUFDLFdBQVcsRUFBRSxVQUFVLEVBQUUsYUFBYSxDQUFDLENBQUM7S0FDMUU7K0dBTlksa0JBQWtCO21IQUFsQixrQkFBa0IsY0FGakIsTUFBTTs7NEZBRVAsa0JBQWtCO2tCQUg5QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEhvbGRpbmdUeXBlIGFzIEhvbGRpbmdUeXBlQmFzZSB9IGZyb20gJy4uLy4uLy4uL2RiL01vZGVscyc7XG5pbXBvcnQgeyBIb2xkaW5nVHlwZSB9IGZyb20gJy4uLy4uLy4uL21vZGVscyc7XG5pbXBvcnQgeyBSZXN0TWV0aG9kLCBSZXN0U2VydmljZSB9IGZyb20gJy4uL3Jlc3QnO1xuaW1wb3J0IHsgSG9sZGluZ1R5cGVDb2xsZWN0aW9uIH0gZnJvbSAnLi4vLi4vLi4vY29sbGVjdGlvbnMnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBIb2xkaW5nVHlwZVNlcnZpY2UgZXh0ZW5kcyBSZXN0U2VydmljZTxIb2xkaW5nVHlwZUJhc2UsIEhvbGRpbmdUeXBlLCBIb2xkaW5nVHlwZUNvbGxlY3Rpb24+IHtcbiAgbW9kZWxDbGFzczogdHlwZW9mIEhvbGRpbmdUeXBlID0gSG9sZGluZ1R5cGU7XG4gIGNvbGxlY3Rpb25DbGFzczogdHlwZW9mIEhvbGRpbmdUeXBlQ29sbGVjdGlvbiA9IEhvbGRpbmdUeXBlQ29sbGVjdGlvbjtcbiAgZW5kcG9pbnRVcmkgPSAnaG9sZGluZy10eXBlcyc7XG4gIGlzQXBpUGxhdGZvcm0gPSB0cnVlO1xuICBkaXNhYmxlZE1ldGhvZHM6IFJlc3RNZXRob2RbXSA9IFsncG9zdEJhdGNoJywgJ3B1dEJhdGNoJywgJ2RlbGV0ZUJhdGNoJ107XG59XG4iXX0=

package/esm2022/lib/services/http/holding/holding.service.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { Holding, HoldingSale } from '../../../models';
+import { RestService } from '../rest';
+import { HoldingCollection } from '../../../collections';
+import { UserRolesEnum } from '../../../db/Enums/user-roles.enum';
+import * as i0 from "@angular/core";
+export class HoldingService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = Holding;
+        this.collectionClass = HoldingCollection;
+        this.endpointUri = 'holdings';
+        this.isApiPlatform = true;
+        this.disabledMethods = ['postBatch', 'putBatch', 'deleteBatch'];
+        this.roles = [UserRolesEnum.HOLDING_TANK];
+    }
+    listenEvents() {
+        this.listenCSE(HoldingSale, ['post', 'put', 'delete'], this.refreshCache);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HoldingService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HoldingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HoldingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/http/income-source/income-source-forecast/income-source-forecast.service.mjs

@@ -0,0 +1,79 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { RestService } from '../../rest/rest-old.service';
+import { IncomeSourceForecast, AppEvent, AppEventTypeEnum, IncomeSource } from '../../../../models';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with Other Income Forecasts
+ */
+export class IncomeSourceForecastService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = IncomeSourceForecast;
+        this.url = 'income-source-forecasts';
+    }
+    /**
+     * Listen to Income Sources events
+     */
+    listenEvents() {
+        this.listenToAddedIncomeSources();
+        this.listenToUpdatedIncomeSources();
+    }
+    /**
+     * @TODO vik refactor
+     * Listen to EventDispatcherService event related to added Income Sources
+     */
+    listenToAddedIncomeSources() {
+        this.eventDispatcherService.on(AppEventTypeEnum.INCOME_SOURCES_CREATED)
+            .pipe(map((incomeSources) => incomeSources
+            .filter((incomeSource) => !incomeSource.isWorkIncome())))
+            .subscribe((incomeSources) => {
+            const incomeSourceForecasts = this.assignIncomeSourceForecasts(incomeSources);
+            if (incomeSourceForecasts.length) {
+                this.addBatch(incomeSourceForecasts).subscribe((createdIncomeSourceForecasts) => {
+                    this.eventDispatcherService
+                        .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_CREATED, createdIncomeSourceForecasts));
+                });
+            }
+        });
+    }
+    /**
+     * Listen to EventDispatcherService event related to updated Income Sources
+     */
+    listenToUpdatedIncomeSources() {
+        this.eventDispatcherService.on(AppEventTypeEnum.INCOME_SOURCES_UPDATED)
+            .subscribe((incomeSources) => {
+            const incomeSourceForecasts = this.assignIncomeSourceForecasts(incomeSources);
+            if (incomeSourceForecasts.length) {
+                this.updateBatch(incomeSourceForecasts).subscribe((updatedIncomeSourceForecasts) => {
+                    this.eventDispatcherService
+                        .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_UPDATED, updatedIncomeSourceForecasts));
+                });
+            }
+        });
+    }
+    /**
+     * Assign other income forecasts based on provided income sources
+     * @param incomeSources by which other income forecasts will be assigned
+     */
+    assignIncomeSourceForecasts(incomeSources) {
+        return incomeSources.map((incomeSource) => {
+            incomeSource.incomeSourceForecasts = incomeSource.incomeSourceForecasts
+                .map((incomeSourceForecast) => {
+                incomeSourceForecast.incomeSource = plainToClass(IncomeSource, { id: incomeSource.id });
+                return incomeSourceForecast;
+            });
+            return incomeSource.incomeSourceForecasts;
+        }).flat();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IncomeSourceForecastService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IncomeSourceForecastService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IncomeSourceForecastService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/http/income-source/income-source.service.mjs

@@ -0,0 +1,88 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { RestService } from '../rest/rest-old.service';
+import { SalaryForecast, IncomeSource, AppEvent, AppEventTypeEnum } from '../../../models';
+import { replace } from '../../../functions/array';
+import { plainToClass } from 'class-transformer';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with income sources
+ */
+export class IncomeSourceService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.url = 'income-sources';
+        this.modelClass = IncomeSource;
+    }
+    listenEvents() {
+        this.listenSoleBusinessCreated();
+    }
+    /**
+     * Get income sources tax calculation
+     * @param salaryForecast for which tax should be calculated
+     */
+    getTaxCalculation(salaryForecast) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}/tax-calculation`, salaryForecast)
+            .pipe(map((response) => plainToClass(SalaryForecast, response)));
+    }
+    /**
+     * Add batch of income sources
+     * @param incomeSources to add
+     */
+    addBatch(incomeSources) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}`, incomeSources)
+            .pipe(map((addedIncomeSources) => {
+            // assign respond income sources to provided income sources
+            const assignedIncomeSources = addedIncomeSources
+                .map((incomeSource, index) => Object.assign(plainToClass(IncomeSource, {}), incomeSource, incomeSources[index]));
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_CREATED, assignedIncomeSources));
+            this.cache.push(...assignedIncomeSources);
+            this.updateCache();
+            return assignedIncomeSources;
+        }));
+    }
+    /**
+     * Update batch of income sources
+     */
+    updateBatch(incomeSources, queryParams = {}) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}`, incomeSources, queryParams)
+            .pipe(map((updatedItems) => {
+            const updatedInstances = updatedItems.map((item) => this.createModelInstance(item));
+            updatedInstances.forEach((instance) => {
+                replace(this.cache, instance);
+            });
+            if (incomeSources[0].forecasts.length) {
+                this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_UPDATED, incomeSources));
+            }
+            this.updateCache();
+            return updatedInstances;
+        }));
+    }
+    /**
+     * Get income sources by provided types
+     * @param types
+     */
+    getByTypes(types) {
+        return this.get()
+            .pipe(map((incomeSources) => incomeSources
+            .filter((incomeSource) => types.includes(incomeSource.type))));
+    }
+    /**
+     * Sole businesses create together with income source
+     */
+    listenSoleBusinessCreated() {
+        this.eventDispatcherService.on(AppEventTypeEnum.SOLE_BUSINESS_CREATED).subscribe(() => {
+            // @TODO Alex/Vik (TT-1777): we clear cache a lot, a better and easier way required, add todo and task to refactor
+            this.refreshCache();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IncomeSourceService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IncomeSourceService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IncomeSourceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"income-source.service.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/services/http/income-source/income-source.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAErC,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAC3F,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;;AAGjD;;GAEG;AAIH,MAAM,OAAO,mBAAoB,SAAQ,WAA2C;IAHpF;;QAIE,QAAG,GAAG,gBAAgB,CAAC;QACvB,eAAU,GAAG,YAAY,CAAC;KAmF3B;IAjFC,YAAY;QACV,IAAI,CAAC,yBAAyB,EAAE,CAAC;IACnC,CAAC;IAED;;;OAGG;IACH,iBAAiB,CAAC,cAA8B;QAC9C,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,IAAI,IAAI,CAAC,GAAG,kBAAkB,EAAE,cAAc,CAAC;aAC3F,IAAI,CACH,GAAG,CAAC,CAAC,QAAa,EAAE,EAAE,CAAC,YAAY,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC,CAC/D,CAAC;IACN,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,aAA6B;QACpC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,IAAI,IAAI,CAAC,GAAG,EAAE,EAAE,aAAa,CAAC;aAC1E,IAAI,CACH,GAAG,CAAC,CAAC,kBAAsC,EAAE,EAAE;YAC7C,2DAA2D;YAC3D,MAAM,qBAAqB,GAAmB,kBAAkB;iBAC7D,GAAG,CAAC,CAAC,YAA0B,EAAE,KAAa,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,YAAY,EAAE,EAAE,CAAC,EAAE,YAAY,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAEzI,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,gBAAgB,CAAC,sBAAsB,EAAE,qBAAqB,CAAC,CAAC,CAAC;YAEnH,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,qBAAqB,CAAC,CAAC;YAC1C,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,OAAO,qBAAqB,CAAC;QAC/B,CAAC,CAAC,CACH,CAAC;IACN,CAAC;IAED;;OAEG;IAEH,WAAW,CAAC,aAA6B,EAAE,cAAsB,EAAE;QACjE,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,IAAI,IAAI,CAAC,GAAG,EAAE,EAAE,aAAa,EAAE,WAAW,CAAC;aACtF,IAAI,CACH,GAAG,CAAC,CAAC,YAA4B,EAAE,EAAE;YACnC,MAAM,gBAAgB,GAAmB,YAAY,CAAC,GAAG,CACvD,CAAC,IAAkB,EAAE,EAAE,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CACvD,CAAC;YACF,gBAAgB,CAAC,OAAO,CAAC,CAAC,QAAsB,EAAE,EAAE;gBAClD,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;YAChC,CAAC,CAAC,CAAC;YAEH,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,EAAE;gBACrC,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,gBAAgB,CAAC,sBAAsB,EAAE,aAAa,CAAC,CAAC,CAAC;aAC5G;YAED,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,OAAO,gBAAgB,CAAC;QAC1B,CAAC,CAAC,CACH,CAAC;IACN,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,KAA6B;QACtC,OAAO,IAAI,CAAC,GAAG,EAAE;aACd,IAAI,CACH,GAAG,CAAC,CAAC,aAA6B,EAAE,EAAE,CAAC,aAAa;aACjD,MAAM,CAAC,CAAC,YAA0B,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IACrF,CAAC;IAED;;OAEG;IACK,yBAAyB;QAC/B,IAAI,CAAC,sBAAsB,CAAC,EAAE,CAAC,gBAAgB,CAAC,qBAAqB,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YACpF,kHAAkH;YAClH,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC,CAAC,CAAC;IACL,CAAC;+GApFU,mBAAmB;mHAAnB,mBAAmB,cAFlB,MAAM;;4FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { IncomeSource as IncomeSourceBase } from '../../../db/Models/incomeSource/income-source';\nimport { RestService } from '../rest/rest-old.service';\nimport { SalaryForecast, IncomeSource, AppEvent, AppEventTypeEnum } from '../../../models';\nimport { replace } from '../../../functions/array';\nimport { IncomeSourceTypeEnum } from '../../../db/Enums/income-source/income-source-type.enum';\nimport { plainToClass } from 'class-transformer';\nimport { IEventListener } from '../../../interfaces';\n\n/**\n * Service to work with income sources\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class IncomeSourceService extends RestService<IncomeSourceBase, IncomeSource> implements IEventListener {\n  url = 'income-sources';\n  modelClass = IncomeSource;\n\n  listenEvents(): void {\n    this.listenSoleBusinessCreated();\n  }\n\n  /**\n   * Get income sources tax calculation\n   * @param salaryForecast for which tax should be calculated\n   */\n  getTaxCalculation(salaryForecast: SalaryForecast): Observable<SalaryForecast> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}/tax-calculation`, salaryForecast)\n      .pipe(\n        map((response: any) => plainToClass(SalaryForecast, response))\n      );\n  }\n\n  /**\n   * Add batch of income sources\n   * @param incomeSources to add\n   */\n  addBatch(incomeSources: IncomeSource[]): Observable<IncomeSource[]> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}`, incomeSources)\n      .pipe(\n        map((addedIncomeSources: IncomeSourceBase[]) => {\n          // assign respond income sources to provided income sources\n          const assignedIncomeSources: IncomeSource[] = addedIncomeSources\n            .map((incomeSource: IncomeSource, index: number) => Object.assign(plainToClass(IncomeSource, {}), incomeSource, incomeSources[index]));\n\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_CREATED, assignedIncomeSources));\n\n          this.cache.push(...assignedIncomeSources);\n          this.updateCache();\n          return assignedIncomeSources;\n        })\n      );\n  }\n\n  /**\n   * Update batch of income sources\n   */\n\n  updateBatch(incomeSources: IncomeSource[], queryParams: object = {}): Observable<IncomeSource[]> {\n    return this.http.put(`${this.environment.apiV2}/${this.url}`, incomeSources, queryParams)\n      .pipe(\n        map((updatedItems: IncomeSource[]) => {\n          const updatedInstances: IncomeSource[] = updatedItems.map(\n            (item: IncomeSource) => this.createModelInstance(item)\n          );\n          updatedInstances.forEach((instance: IncomeSource) => {\n            replace(this.cache, instance);\n          });\n\n          if (incomeSources[0].forecasts.length) {\n            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_UPDATED, incomeSources));\n          }\n\n          this.updateCache();\n          return updatedInstances;\n        })\n      );\n  }\n\n  /**\n   * Get income sources by provided types\n   * @param types\n   */\n  getByTypes(types: IncomeSourceTypeEnum[]): Observable<IncomeSource[]> {\n    return this.get()\n      .pipe(\n        map((incomeSources: IncomeSource[]) => incomeSources\n          .filter((incomeSource: IncomeSource) => types.includes(incomeSource.type))));\n  }\n\n  /**\n   * Sole businesses create together with income source\n   */\n  private listenSoleBusinessCreated() {\n    this.eventDispatcherService.on(AppEventTypeEnum.SOLE_BUSINESS_CREATED).subscribe(() => {\n      // @TODO Alex/Vik (TT-1777): we clear cache a lot, a better and easier way required, add todo and task to refactor\n      this.refreshCache();\n    });\n  }\n}\n"]}

package/esm2022/lib/services/http/income-source/salary-forecast/salary-forecast.service.mjs

@@ -0,0 +1,81 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { RestService } from '../../rest/rest-old.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";
+/**
+ * Service to work with Salary Forecasts
+ */
+export class SalaryForecastService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = SalaryForecast;
+        this.url = 'salary-forecasts';
+    }
+    /**
+     * 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.isWorkIncome())))
+            .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();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SalaryForecastService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SalaryForecastService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SalaryForecastService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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