taxtank-core 0.0.2 → 0.0.3

package/esm2015/lib/services/employee/employee-invite.service.js

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { replace } from '../../functions/array';
+import _ from 'lodash';
+import { plainToClass } from 'class-transformer';
+import { EmployeeInvite } from '../../models/employee/employee-invite';
+import { BaseRestService } from '../base-rest.service';
+import * as i0 from "@angular/core";
+export class EmployeeInviteService extends BaseRestService {
+    constructor() {
+        super(...arguments);
+        this.url = 'employees/invites';
+        this.modelClass = EmployeeInvite;
+    }
+    /**
+     * Import employees for firm from CSV file
+     * @param file
+     */
+    import(file) {
+        const formData = new FormData();
+        formData.append('file', file);
+        return this.http.post(`${this.environment.apiV2}/${this.url}/import`, formData)
+            .pipe(map((employeeInvite) => {
+            return employeeInvite;
+        }));
+    }
+    /**
+     * Resend invitation from firm to client
+     * @param invite
+     */
+    resend(invite) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}/${invite.id}/resend`, null)
+            .pipe(map((resentInviteBase) => {
+            const updatedInvite = plainToClass(EmployeeInvite, resentInviteBase);
+            // avoid cache changes
+            // @TODO make cache readonly
+            const tempCache = _.cloneDeep(this.cache);
+            replace(tempCache, plainToClass(EmployeeInvite, updatedInvite));
+            this.cache = tempCache;
+            this.updateCache();
+            return updatedInvite;
+        }));
+    }
+}
+EmployeeInviteService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: EmployeeInviteService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+EmployeeInviteService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: EmployeeInviteService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: EmployeeInviteService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { BaseRestService } from '../base-rest.service';
+import { map } from 'rxjs/operators';
+import { replace } from '../../functions/array';
+import _ from 'lodash';
+import { plainToClass } from 'class-transformer';
+import { User } from '../../models/user/user';
+import * as i0 from "@angular/core";
+export class EmployeeService extends BaseRestService {
+    constructor() {
+        super(...arguments);
+        this.url = 'employees';
+        this.modelClass = User;
+    }
+    /**
+     * Grant/Remove Manager role to employee
+     * @param employee
+     */
+    toggleManagerRole(employee) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}/${employee.id}`, {})
+            .pipe(map((updatedEmployeeBase) => {
+            const tempCache = this.cache;
+            const updatedEmployee = plainToClass(User, updatedEmployeeBase);
+            replace(tempCache, updatedEmployee);
+            this.cache = _.cloneDeep(tempCache);
+            this.updateCache();
+            return updatedEmployee;
+        }));
+    }
+}
+EmployeeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: EmployeeService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+EmployeeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: EmployeeService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: EmployeeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/event/event-dispatcher.service.js

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class EventDispatcherService {
+    constructor() {
+        this.eventSubject = new Subject();
+    }
+    /**
+     * subscription to specific event type
+     */
+    on(eventType) {
+        return this.eventSubject.pipe(filter((event) => [].concat(eventType).includes(event.type)), map((event) => event.payload));
+    }
+    /**
+     * deliver new event
+     */
+    dispatch(event) {
+        this.eventSubject.next(event);
+    }
+}
+EventDispatcherService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: EventDispatcherService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+EventDispatcherService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: EventDispatcherService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: EventDispatcherService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/event/sse.service.js

@@ -0,0 +1,46 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { EventSourcePolyfill } from 'event-source-polyfill/src/eventsource.min.js';
+import * as i0 from "@angular/core";
+import * as i1 from "../auth/jwt.service";
+export class SseService {
+    constructor(zone, jwtService, environment) {
+        this.zone = zone;
+        this.jwtService = jwtService;
+        this.environment = environment;
+    }
+    /**
+     * list to url for server events
+     */
+    on(topic) {
+        const url = new URL(this.environment.mercureUrl);
+        url.searchParams.append('topic', `${this.environment.apiV2}/users/${this.jwtService.decodeToken().username}/${topic}`);
+        // tslint:disable-next-line:typedef
+        return new Observable((observer) => {
+            const es = new EventSourcePolyfill(url, {
+                headers: {
+                    Authorization: 'Bearer ' + this.jwtService.getToken(),
+                }
+            });
+            es.onmessage = (event) => {
+                this.zone.run(() => observer.next(event));
+            };
+        })
+            .pipe(map((messageEvent) => {
+            return JSON.parse(messageEvent.data);
+        }));
+    }
+}
+SseService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SseService, deps: [{ token: i0.NgZone }, { token: i1.JwtService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+SseService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SseService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SseService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i1.JwtService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,79 @@
+import { Inject, Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { Firm } from '../../db/Models/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) => {
+            return plainToClass(Firm, firm);
+        }));
+    }
+    get() {
+        if (!this.firm) {
+            this.http.get(`${this.environment.apiV2}/firms/current`)
+                .pipe(map((firm) => {
+                return 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) => {
+            return response['hydra:member'].map((firmBase) => plainToClass(Firm, firmBase));
+        }));
+    }
+    getByType(type) {
+        return this.getAll().pipe(map((firms) => {
+            return firms.filter((firm) => firm.type === type);
+        }));
+    }
+    updatePhoto(firm, photo) {
+        return this.http.post(`${this.environment.apiV2}/firms/photo?_method=PUT`, photo)
+            .pipe(map((firmPhoto) => {
+            this.firm = plainToClass(Firm, Object.assign(firm, { photo: firmPhoto }));
+            this.firmSubject.next(this.firm);
+            return firm;
+        }));
+    }
+}
+FirmService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: FirmService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+FirmService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: FirmService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", 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/esm2015/lib/services/header-title/header-title.service.js

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import { filter, map, mergeMap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class HeaderTitleService {
+    constructor(router, activatedRoute) {
+        this.router = router;
+        this.activatedRoute = activatedRoute;
+    }
+    handleTitle() {
+        return this.router.events.pipe(filter((event) => event instanceof NavigationEnd), map(() => this.activatedRoute), map((route) => {
+            while (route.firstChild) {
+                route = route.firstChild;
+            }
+            return route;
+        }), filter((route) => route.outlet === 'primary'), mergeMap((route) => route.data));
+    }
+}
+HeaderTitleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: HeaderTitleService, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable });
+HeaderTitleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: HeaderTitleService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: HeaderTitleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/income-source/income-source-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 { IncomeSourceForecast } from '../../models/income-source/income-source-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 Other Income Forecasts
+ */
+export class IncomeSourceForecastService extends BaseRestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.modelClass = IncomeSourceForecast;
+        this.url = 'income-source-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 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();
+    }
+}
+IncomeSourceForecastService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: IncomeSourceForecastService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+IncomeSourceForecastService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: IncomeSourceForecastService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: IncomeSourceForecastService, 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":"income-source-forecast.service.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/services/income-source/income-source-forecast.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAErC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mDAAmD,CAAC;AAEzF,OAAO,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AACxE,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;;;;AAExD;;GAEG;AAIH,MAAM,OAAO,2BAA4B,SAAQ,eAA+D;IAI9G,YACY,IAAgB,EAChB,sBAA8C,EACvB,WAAgB;QAEjD,KAAK,CAAC,IAAI,EAAE,sBAAsB,EAAE,WAAW,CAAC,CAAC;QAJvC,SAAI,GAAJ,IAAI,CAAY;QAChB,2BAAsB,GAAtB,sBAAsB,CAAwB;QACvB,gBAAW,GAAX,WAAW,CAAK;QANnD,eAAU,GAAgC,oBAAoB,CAAC;QAC/D,QAAG,GAAW,yBAAyB,CAAC;QAQtC,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,YAAY;QACV,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAClC,IAAI,CAAC,4BAA4B,EAAE,CAAC;IACtC,CAAC;IAED;;OAEG;IACK,0BAA0B;QAChC,IAAI,CAAC,sBAAsB,CAAC,EAAE,CAAC,gBAAgB,CAAC,sBAAsB,CAAC;aACpE,IAAI,CACH,GAAG,CAAC,CAAC,aAA6B,EAAE,EAAE,CAAC,aAAa;aACjD,MAAM,CAAC,CAAC,YAA0B,EAAE,EAAE,CAAC,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC,CAAC,CAC3E;aACA,SAAS,CAAC,CAAC,aAA6B,EAAE,EAAE;YAE3C,MAAM,qBAAqB,GAA2B,IAAI,CAAC,2BAA2B,CAAC,aAAa,CAAC,CAAC;YACtG,IAAI,qBAAqB,CAAC,MAAM,EAAE;gBAChC,IAAI,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAC,SAAS,CAAC,CAAC,4BAAoD,EAAE,EAAE;oBACtG,IAAI,CAAC,sBAAsB;yBACxB,QAAQ,CAAC,IAAI,QAAQ,CAAC,gBAAgB,CAAC,gCAAgC,EAAE,4BAA4B,CAAC,CAAC,CAAC;gBAC7G,CAAC,CAAC,CAAC;aACJ;QACH,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACK,4BAA4B;QAClC,IAAI,CAAC,sBAAsB,CAAC,EAAE,CAAC,gBAAgB,CAAC,sBAAsB,CAAC;aACpE,SAAS,CAAC,CAAC,aAA6B,EAAE,EAAE;YAC3C,MAAM,qBAAqB,GAA2B,IAAI,CAAC,2BAA2B,CAAC,aAAa,CAAC,CAAC;YACtG,IAAI,qBAAqB,CAAC,MAAM,EAAE;gBAChC,IAAI,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC,SAAS,CAAC,CAAC,4BAAoD,EAAE,EAAE;oBACzG,IAAI,CAAC,sBAAsB;yBACxB,QAAQ,CAAC,IAAI,QAAQ,CAAC,gBAAgB,CAAC,gCAAgC,EAAE,4BAA4B,CAAC,CAAC,CAAC;gBAC7G,CAAC,CAAC,CAAC;aACJ;QACH,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;OAGG;IACK,2BAA2B,CAAC,aAA6B;QAC/D,OAAO,aAAa,CAAC,GAAG,CAAC,CAAC,YAA0B,EAAE,EAAE;YACtD,YAAY,CAAC,qBAAqB,GAAG,YAAY,CAAC,qBAAqB;iBACpE,GAAG,CAAC,CAAC,oBAA0C,EAAE,EAAE;gBAClD,oBAAoB,CAAC,YAAY,GAAG,YAAY,CAAC,YAAY,EAAE,EAAC,EAAE,EAAE,YAAY,CAAC,EAAE,EAAC,CAAC,CAAC;gBACtF,OAAO,oBAAoB,CAAC;YAC9B,CAAC,CAAC,CAAC;YACL,OAAO,YAAY,CAAC,qBAAqB,CAAC;QAC5C,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IACZ,CAAC;;yHAvEU,2BAA2B,kFAO5B,aAAa;6HAPZ,2BAA2B,cAF1B,MAAM;4FAEP,2BAA2B;kBAHvC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAQI,MAAM;2BAAC,aAAa","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { map } from 'rxjs/operators';\nimport { IncomeSourceForecast as IncomeSourceForecastBase } from '../../db/Models/income-source-forecast';\nimport { plainToClass } from 'class-transformer';\nimport { BaseRestService } from '../base-rest.service';\nimport { IncomeSourceForecast } from '../../models/income-source/income-source-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 Other Income Forecasts\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class IncomeSourceForecastService extends BaseRestService<IncomeSourceForecastBase, IncomeSourceForecast> {\n  modelClass: typeof IncomeSourceForecast = IncomeSourceForecast;\n  url: string = 'income-source-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 incomeSourceForecasts: IncomeSourceForecast[] = this.assignIncomeSourceForecasts(incomeSources);\n        if (incomeSourceForecasts.length) {\n          this.addBatch(incomeSourceForecasts).subscribe((createdIncomeSourceForecasts: IncomeSourceForecast[]) => {\n            this.eventDispatcherService\n              .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_CREATED, createdIncomeSourceForecasts));\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 incomeSourceForecasts: IncomeSourceForecast[] = this.assignIncomeSourceForecasts(incomeSources);\n        if (incomeSourceForecasts.length) {\n          this.updateBatch(incomeSourceForecasts).subscribe((updatedIncomeSourceForecasts: IncomeSourceForecast[]) => {\n            this.eventDispatcherService\n              .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_UPDATED, updatedIncomeSourceForecasts));\n          });\n        }\n      });\n  }\n\n  /**\n   * Assign other income forecasts based on provided income sources\n   * @param incomeSources by which other income forecasts will be assigned\n   */\n  private assignIncomeSourceForecasts(incomeSources: IncomeSource[]): IncomeSourceForecast[] {\n    return incomeSources.map((incomeSource: IncomeSource) => {\n      incomeSource.incomeSourceForecasts = incomeSource.incomeSourceForecasts\n        .map((incomeSourceForecast: IncomeSourceForecast) => {\n          incomeSourceForecast.incomeSource = plainToClass(IncomeSource, {id: incomeSource.id});\n          return incomeSourceForecast;\n        });\n      return incomeSource.incomeSourceForecasts;\n    }).flat();\n  }\n}\n"]}

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

@@ -0,0 +1,109 @@
+import { Inject, Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { BaseRestService } from '../base-rest.service';
+import { IncomeSourceType } from '../../models/income-source/income-source-type';
+import { SalaryForecast } from '../../models/income-source/salary-forecast';
+import { replace } from '../../functions/array';
+import { plainToClass } from 'class-transformer';
+import { IncomeSource } from '../../models/income-source/income-source';
+import { AppEvent } from '../../models/event/app-event';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+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 income sources
+ */
+export class IncomeSourceService extends BaseRestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.url = 'income-sources';
+        this.modelClass = IncomeSource;
+        this.incomeSourceTypeSubject = new ReplaySubject(1);
+    }
+    /**
+     * 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) => {
+            return 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(this.modelClass, 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))));
+    }
+    /**
+     * Get other incomes types
+     */
+    getIncomeSourceTypes() {
+        if (!this.incomeSourceTypes) {
+            this.incomeSourceTypes = [];
+            this.http.get(`${this.environment.apiV2}/income-source-types`)
+                .pipe(map((response) => {
+                return response.map((item) => plainToClass(IncomeSourceType, item));
+            }))
+                .subscribe((otherIncomesTypes) => {
+                this.incomeSourceTypes = otherIncomesTypes;
+                this.incomeSourceTypeSubject.next(this.incomeSourceTypes);
+            });
+        }
+        return this.incomeSourceTypeSubject.asObservable();
+    }
+}
+IncomeSourceService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: IncomeSourceService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+IncomeSourceService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: IncomeSourceService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: IncomeSourceService, 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":"income-source.service.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/services/income-source/income-source.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { Observable, ReplaySubject } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { HttpClient } from '@angular/common/http';\nimport { IncomeSource as IncomeSourceBase } from '../../db/Models/income-source';\nimport { BaseRestService } from '../base-rest.service';\nimport { IncomeSourceType } from '../../models/income-source/income-source-type';\nimport { SalaryForecast } from '../../models/income-source/salary-forecast';\nimport { replace } from '../../functions/array';\nimport { IncomeSourceTypeEnum } from '../../db/Enums/income-source-type.enum';\nimport { plainToClass } from 'class-transformer';\nimport { EventDispatcherService } from '../event/event-dispatcher.service';\nimport { IncomeSource } from '../../models/income-source/income-source';\nimport { AppEvent } from '../../models/event/app-event';\nimport { AppEventTypeEnum } from '../../models/event/app-event-type.enum';\n\n/**\n * Service to work with income sources\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class IncomeSourceService extends BaseRestService<IncomeSourceBase, IncomeSource> {\n  url: string = 'income-sources';\n  modelClass = IncomeSource;\n  incomeSourceTypes: IncomeSourceType[];\n  incomeSourceTypeSubject: ReplaySubject<IncomeSourceType[]> = new ReplaySubject<IncomeSourceType[]>(1);\n\n  constructor(\n    protected http: HttpClient,\n    protected eventDispatcherService: EventDispatcherService,\n    @Inject('environment') protected environment: any\n  ) {\n    super(http, eventDispatcherService, environment);\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) => {\n          return plainToClass(SalaryForecast, response);\n        })\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(this.modelClass, 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   * Get other incomes types\n   */\n  getIncomeSourceTypes(): Observable<IncomeSourceType[]> {\n    if (!this.incomeSourceTypes) {\n      this.incomeSourceTypes = [];\n      this.http.get(`${this.environment.apiV2}/income-source-types`)\n        .pipe(\n          map((response: any) => {\n            return response.map((item: any) => plainToClass(IncomeSourceType, item));\n          })\n        )\n        .subscribe((otherIncomesTypes: IncomeSourceType[]) => {\n          this.incomeSourceTypes = otherIncomesTypes;\n          this.incomeSourceTypeSubject.next(this.incomeSourceTypes);\n        });\n    }\n\n    return this.incomeSourceTypeSubject.asObservable();\n  }\n}\n"]}