taxtank-core 0.8.3 → 0.8.7

package/esm2015/lib/services/http/income-source/income-source-forecast/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 { RestService } from '../../rest/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 RestService {
+    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/http/income-source/income-source-forecast/income-source-forecast.service.ts"],"names":[],"mappings":"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","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 { RestService } from '../../rest/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 RestService<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/http/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 { RestService } from '../rest/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 RestService {
+    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/http/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 { RestService } from '../rest/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 RestService<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"]}

package/esm2015/lib/services/http/income-source/salary-forecast/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 { RestService } from '../../rest/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 RestService {
+    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/http/income-source/salary-forecast/salary-forecast.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGnD,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,OAAO,EAAE,cAAc,EAAE,MAAM,kDAAkD,CAAC;AAElF,OAAO,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,gDAAgD,CAAC;AAC9E,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;;;;AAE9D;;GAEG;AAIH,MAAM,OAAO,qBAAsB,SAAQ,WAA+C;IAIxF,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,GAA0B,cAAc,CAAC;QACnD,QAAG,GAAW,kBAAkB,CAAC;QAQ/B,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,YAAY,CAAC,cAAc,EAAE,CAAC,CAAC,CAC1E;aACA,SAAS,CAAC,CAAC,aAA6B,EAAE,EAAE;YAE3C,MAAM,eAAe,GAAqB,IAAI,CAAC,qBAAqB,CAAC,aAAa,CAAC,CAAC;YACpF,IAAI,eAAe,CAAC,MAAM,EAAE;gBAC1B,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,SAAS,CAAC,CAAC,sBAAwC,EAAE,EAAE;oBACpF,IAAI,CAAC,sBAAsB;yBACxB,QAAQ,CAAC,IAAI,QAAQ,CAAC,gBAAgB,CAAC,gCAAgC,EAAE,sBAAsB,CAAC,CAAC,CAAC;gBACvG,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,eAAe,GAAqB,IAAI,CAAC,qBAAqB,CAAC,aAAa,CAAC,CAAC;YACpF,IAAI,eAAe,CAAC,MAAM,EAAE;gBAC1B,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,SAAS,CAAC,CAAC,sBAAwC,EAAE,EAAE;oBACvF,IAAI,CAAC,sBAAsB;yBACxB,QAAQ,CAAC,IAAI,QAAQ,CAAC,gBAAgB,CAAC,gCAAgC,EAAE,sBAAsB,CAAC,CAAC,CAAC;gBACvG,CAAC,CAAC,CAAC;aACJ;QACH,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;OAGG;IACK,qBAAqB,CAAC,aAA6B;QACzD,OAAO,aAAa,CAAC,GAAG,CAAC,CAAC,YAA0B,EAAE,EAAE;YACtD,YAAY,CAAC,eAAe,GAAG,YAAY,CAAC,eAAe;iBACxD,GAAG,CAAC,CAAC,cAA8B,EAAE,EAAE;gBACtC,cAAc,CAAC,YAAY,GAAG,YAAY,CAAC,YAAY,EAAE,EAAC,EAAE,EAAE,YAAY,CAAC,EAAE,EAAC,CAAC,CAAC;gBAChF,OAAO,cAAc,CAAC;YACxB,CAAC,CAAC,CAAC;YACL,OAAO,YAAY,CAAC,eAAe,CAAC;QACtC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IACZ,CAAC;;mHAvEU,qBAAqB,kFAOtB,aAAa;uHAPZ,qBAAqB,cAFpB,MAAM;4FAEP,qBAAqB;kBAHjC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAQI,MAAM;2BAAC,aAAa","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 { RestService } from '../../rest/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 RestService<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/http/income-source/sole-forecast/sole-forecast.service.js

@@ -0,0 +1,87 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { RestService } from '../../rest/rest.service';
+import { SoleForecast } from '../../../../models/income-source/sole-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";
+export class SoleForecastService extends RestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.modelClass = SoleForecast;
+        this.url = 'sole-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.isSoleIncome())))
+            .subscribe((incomeSources) => {
+            const soleForecasts = this.assignSoleForecasts(incomeSources);
+            if (soleForecasts.length) {
+                this.addBatch(soleForecasts).subscribe((createdSoleForecasts) => {
+                    this.eventDispatcherService
+                        .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_CREATED, createdSoleForecasts));
+                });
+            }
+        });
+    }
+    /**
+     * Listen to EventDispatcherService event related to updated Income Sources
+     */
+    listenToUpdatedIncomeSources() {
+        this.eventDispatcherService.on(AppEventTypeEnum.INCOME_SOURCES_UPDATED)
+            .subscribe((incomeSources) => {
+            const soleForecasts = this.assignSoleForecasts(incomeSources);
+            if (soleForecasts.length) {
+                this.updateBatch(soleForecasts).subscribe((updatedSoleForecasts) => {
+                    this.eventDispatcherService
+                        .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_UPDATED, updatedSoleForecasts));
+                });
+            }
+        });
+    }
+    /**
+     * Assign sole forecasts based on provided income sources
+     * @param incomeSources by which sole forecasts will be assigned
+     */
+    assignSoleForecasts(incomeSources) {
+        return incomeSources.map((incomeSource) => {
+            incomeSource.soleForecasts = incomeSource.soleForecasts
+                .map((soleForecast) => {
+                soleForecast.incomeSource = plainToClass(IncomeSource, { id: incomeSource.id });
+                return soleForecast;
+            });
+            return incomeSource.soleForecasts;
+        }).flat();
+    }
+}
+SoleForecastService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SoleForecastService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+SoleForecastService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SoleForecastService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SoleForecastService, 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":"sole-forecast.service.js","sourceRoot":"","sources":["../../../../../../../../projects/tt-core/src/lib/services/http/income-source/sole-forecast/sole-forecast.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { map } from 'rxjs/operators';\nimport { SoleForecast as SoleForecastBase} from '../../../../db/Models/sole-forecast';\nimport { plainToClass } from 'class-transformer';\nimport { RestService } from '../../rest/rest.service';\nimport { SoleForecast } from '../../../../models/income-source/sole-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@Injectable({\n  providedIn: 'root'\n})\nexport class SoleForecastService extends RestService<SoleForecastBase, SoleForecast> {\n  modelClass: typeof SoleForecast = SoleForecast;\n  url: string = 'sole-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.isSoleIncome()))\n      )\n      .subscribe((incomeSources: IncomeSource[]) => {\n\n        const soleForecasts: SoleForecast[] = this.assignSoleForecasts(incomeSources);\n        if (soleForecasts.length) {\n          this.addBatch(soleForecasts).subscribe((createdSoleForecasts: SoleForecast[]) => {\n            this.eventDispatcherService\n              .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_CREATED, createdSoleForecasts));\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 soleForecasts: SoleForecast[] = this.assignSoleForecasts(incomeSources);\n        if (soleForecasts.length) {\n          this.updateBatch(soleForecasts).subscribe((updatedSoleForecasts: SoleForecast[]) => {\n            this.eventDispatcherService\n              .dispatch(new AppEvent(AppEventTypeEnum.INCOME_SOURCES_FORECASTS_UPDATED, updatedSoleForecasts));\n          });\n        }\n      });\n  }\n\n  /**\n   * Assign sole forecasts based on provided income sources\n   * @param incomeSources by which sole forecasts will be assigned\n   */\n  private assignSoleForecasts(incomeSources: IncomeSource[]): SoleForecast[] {\n    return incomeSources.map((incomeSource: IncomeSource) => {\n      incomeSource.soleForecasts = incomeSource.soleForecasts\n        .map((soleForecast: SoleForecast) => {\n          soleForecast.incomeSource = plainToClass(IncomeSource, {id: incomeSource.id});\n          return soleForecast;\n        });\n      return incomeSource.soleForecasts;\n    }).flat();\n  }\n}\n"]}

package/esm2015/lib/services/http/loan/borrowing-expense/borrowing-expense.service.js

@@ -0,0 +1,73 @@
+import { Inject, Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { BorrowingExpense } from '../../../../models/borrowing-expense/borrowing-expense';
+import { BorrowingExpenseLoan } from '../../../../models/borrowing-expense/borrowing-expense-loan';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class BorrowingExpenseService {
+    constructor(http, environment) {
+        this.http = http;
+        this.environment = environment;
+        this.borrowingExpensesSubject = new ReplaySubject(1);
+    }
+    /**
+     * Get borrowing expenses
+     */
+    get() {
+        if (!this._borrowingExpenses) {
+            this.http.get(`${this.environment.apiV2}/borrowing-expenses`)
+                .pipe(map((response) => {
+                return response.map((item) => plainToClass(BorrowingExpense, item));
+            }))
+                .subscribe((borrowingExpenses) => {
+                this._borrowingExpenses = borrowingExpenses;
+                this.borrowingExpensesSubject.next(this._borrowingExpenses);
+            });
+        }
+        return this.borrowingExpensesSubject.asObservable();
+    }
+    getLoanBorrowingExpenses(loan) {
+        return this.get()
+            .pipe(map((borrowingExpenses) => {
+            // Loan borrowing expenses array
+            const borrowingExpensesLoan = [];
+            // Combined array of borrowing expenses list & loan borrowing expenses
+            const combinedBorrowingExpenses = [];
+            borrowingExpenses.forEach((borrowingExpense, index) => {
+                // Fill borrowingExpensesLoan with values based on borrowingExpenses list
+                borrowingExpensesLoan.push(plainToClass(BorrowingExpenseLoan, {
+                    borrowingExpense: borrowingExpense,
+                    loan: loan,
+                    amount: 0,
+                    id: null,
+                    createdAt: null,
+                    updatedAt: null,
+                    createdBy: null,
+                    updatedBy: null
+                }));
+                combinedBorrowingExpenses
+                    .push(Object.assign(plainToClass(BorrowingExpenseLoan, {}), borrowingExpenses[index], borrowingExpensesLoan[index]));
+                // Find current loan borrowing expense in loan object by index
+                const targetBorrowingExpense = loan.borrowingExpenses.find((updBorrowingExpensesLoan) => updBorrowingExpensesLoan.borrowingExpense.id === borrowingExpensesLoan[index].borrowingExpense.id);
+                // ... and set its value to current loan borrowing expense in combinedBorrowingExpenses array
+                combinedBorrowingExpenses[index].amount = targetBorrowingExpense ? targetBorrowingExpense.amount : 0;
+                return combinedBorrowingExpenses;
+            });
+            return combinedBorrowingExpenses;
+        }));
+    }
+}
+BorrowingExpenseService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BorrowingExpenseService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+BorrowingExpenseService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BorrowingExpenseService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BorrowingExpenseService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9ycm93aW5nLWV4cGVuc2Uuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9zZXJ2aWNlcy9odHRwL2xvYW4vYm9ycm93aW5nLWV4cGVuc2UvYm9ycm93aW5nLWV4cGVuc2Uuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRCxPQUFPLEVBQWMsYUFBYSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQ2pELE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUVyQyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDakQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFFMUYsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sNkRBQTZELENBQUM7OztBQUtuRyxNQUFNLE9BQU8sdUJBQXVCO0lBSWxDLFlBQ1UsSUFBZ0IsRUFDUyxXQUFnQjtRQUR6QyxTQUFJLEdBQUosSUFBSSxDQUFZO1FBQ1MsZ0JBQVcsR0FBWCxXQUFXLENBQUs7UUFKbkQsNkJBQXdCLEdBQXNDLElBQUksYUFBYSxDQUFxQixDQUFDLENBQUMsQ0FBQztJQUtuRyxDQUFDO0lBRUw7O09BRUc7SUFDSCxHQUFHO1FBQ0QsSUFBSSxDQUFDLElBQUksQ0FBQyxrQkFBa0IsRUFBRTtZQUM1QixJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsS0FBSyxxQkFBcUIsQ0FBQztpQkFDMUQsSUFBSSxDQUNILEdBQUcsQ0FBQyxDQUFDLFFBQWEsRUFBRSxFQUFFO2dCQUNwQixPQUFPLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFTLEVBQUUsRUFBRSxDQUFDLFlBQVksQ0FBQyxnQkFBZ0IsRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDO1lBQzNFLENBQUMsQ0FBQyxDQUNIO2lCQUNBLFNBQVMsQ0FBQyxDQUFDLGlCQUFxQyxFQUFFLEVBQUU7Z0JBQ25ELElBQUksQ0FBQyxrQkFBa0IsR0FBRyxpQkFBaUIsQ0FBQztnQkFDNUMsSUFBSSxDQUFDLHdCQUF3QixDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsQ0FBQztZQUM5RCxDQUFDLENBQUMsQ0FBQztTQUNOO1FBRUQsT0FBTyxJQUFJLENBQUMsd0JBQXdCLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDdEQsQ0FBQztJQUVELHdCQUF3QixDQUFDLElBQVc7UUFDbEMsT0FBTyxJQUFJLENBQUMsR0FBRyxFQUFFO2FBQ2QsSUFBSSxDQUNILEdBQUcsQ0FBQyxDQUFDLGlCQUFxQyxFQUFFLEVBQUU7WUFDNUMsZ0NBQWdDO1lBQ2hDLE1BQU0scUJBQXFCLEdBQTJCLEVBQUUsQ0FBQztZQUN6RCxzRUFBc0U7WUFDdEUsTUFBTSx5QkFBeUIsR0FBMkIsRUFBRSxDQUFDO1lBRzdELGlCQUFpQixDQUFDLE9BQU8sQ0FBQyxDQUFDLGdCQUFrQyxFQUFFLEtBQWEsRUFBRSxFQUFFO2dCQUM5RSx5RUFBeUU7Z0JBQ3pFLHFCQUFxQixDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsb0JBQW9CLEVBQUU7b0JBQzVELGdCQUFnQixFQUFFLGdCQUFnQjtvQkFDbEMsSUFBSSxFQUFFLElBQUk7b0JBQ1YsTUFBTSxFQUFFLENBQUM7b0JBQ1QsRUFBRSxFQUFFLElBQUk7b0JBQ1IsU0FBUyxFQUFFLElBQUk7b0JBQ2YsU0FBUyxFQUFFLElBQUk7b0JBQ2YsU0FBUyxFQUFFLElBQUk7b0JBQ2YsU0FBUyxFQUFFLElBQUk7aUJBQ2hCLENBQUMsQ0FBQyxDQUFDO2dCQUVKLHlCQUF5QjtxQkFDdEIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsWUFBWSxDQUFDLG9CQUFvQixFQUFFLEVBQTBCLENBQUMsRUFBRSxpQkFBaUIsQ0FBQyxLQUFLLENBQUMsRUFBRSxxQkFBcUIsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUM7Z0JBRS9JLDhEQUE4RDtnQkFDOUQsTUFBTSxzQkFBc0IsR0FBUSxJQUFJLENBQUMsaUJBQWlCLENBQUMsSUFBSSxDQUFDLENBQUMsd0JBQThDLEVBQUUsRUFBRSxDQUNqSCx3QkFBd0IsQ0FBQyxnQkFBZ0IsQ0FBQyxFQUFFLEtBQUsscUJBQXFCLENBQUMsS0FBSyxDQUFDLENBQUMsZ0JBQWdCLENBQUMsRUFBRSxDQUFDLENBQUM7Z0JBRXJHLDZGQUE2RjtnQkFDN0YseUJBQXlCLENBQUMsS0FBSyxDQUFDLENBQUMsTUFBTSxHQUFHLHNCQUFzQixDQUFDLENBQUMsQ0FBQyxzQkFBc0IsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztnQkFFckcsT0FBTyx5QkFBeUIsQ0FBQztZQUNuQyxDQUFDLENBQUMsQ0FBQztZQUVILE9BQU8seUJBQXlCLENBQUM7UUFDbkMsQ0FBQyxDQUFDLENBQ0gsQ0FBQztJQUNOLENBQUM7O3FIQXBFVSx1QkFBdUIsNENBTXhCLGFBQWE7eUhBTlosdUJBQXVCLGNBRnRCLE1BQU07NEZBRVAsdUJBQXVCO2tCQUhuQyxVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQjs7MEJBT0ksTUFBTTsyQkFBQyxhQUFhIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0LCBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlLCBSZXBsYXlTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBtYXAgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XG5pbXBvcnQgeyBIdHRwQ2xpZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuaW1wb3J0IHsgcGxhaW5Ub0NsYXNzIH0gZnJvbSAnY2xhc3MtdHJhbnNmb3JtZXInO1xuaW1wb3J0IHsgQm9ycm93aW5nRXhwZW5zZSB9IGZyb20gJy4uLy4uLy4uLy4uL21vZGVscy9ib3Jyb3dpbmctZXhwZW5zZS9ib3Jyb3dpbmctZXhwZW5zZSc7XG5pbXBvcnQgeyBMb2FuIH0gZnJvbSAnLi4vLi4vLi4vLi4vbW9kZWxzL2xvYW4vbG9hbic7XG5pbXBvcnQgeyBCb3Jyb3dpbmdFeHBlbnNlTG9hbiB9IGZyb20gJy4uLy4uLy4uLy4uL21vZGVscy9ib3Jyb3dpbmctZXhwZW5zZS9ib3Jyb3dpbmctZXhwZW5zZS1sb2FuJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgQm9ycm93aW5nRXhwZW5zZVNlcnZpY2Uge1xuICBfYm9ycm93aW5nRXhwZW5zZXM6IEJvcnJvd2luZ0V4cGVuc2VbXTtcbiAgYm9ycm93aW5nRXhwZW5zZXNTdWJqZWN0OiBSZXBsYXlTdWJqZWN0PEJvcnJvd2luZ0V4cGVuc2VbXT4gPSBuZXcgUmVwbGF5U3ViamVjdDxCb3Jyb3dpbmdFeHBlbnNlW10+KDEpO1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgaHR0cDogSHR0cENsaWVudCxcbiAgICBASW5qZWN0KCdlbnZpcm9ubWVudCcpIHByb3RlY3RlZCBlbnZpcm9ubWVudDogYW55XG4gICkgeyB9XG5cbiAgLyoqXG4gICAqIEdldCBib3Jyb3dpbmcgZXhwZW5zZXNcbiAgICovXG4gIGdldCgpOiBPYnNlcnZhYmxlPEJvcnJvd2luZ0V4cGVuc2VbXT4ge1xuICAgIGlmICghdGhpcy5fYm9ycm93aW5nRXhwZW5zZXMpIHtcbiAgICAgIHRoaXMuaHR0cC5nZXQoYCR7dGhpcy5lbnZpcm9ubWVudC5hcGlWMn0vYm9ycm93aW5nLWV4cGVuc2VzYClcbiAgICAgICAgLnBpcGUoXG4gICAgICAgICAgbWFwKChyZXNwb25zZTogYW55KSA9PiB7XG4gICAgICAgICAgICByZXR1cm4gcmVzcG9uc2UubWFwKChpdGVtOiBhbnkpID0+IHBsYWluVG9DbGFzcyhCb3Jyb3dpbmdFeHBlbnNlLCBpdGVtKSk7XG4gICAgICAgICAgfSlcbiAgICAgICAgKVxuICAgICAgICAuc3Vic2NyaWJlKChib3Jyb3dpbmdFeHBlbnNlczogQm9ycm93aW5nRXhwZW5zZVtdKSA9PiB7XG4gICAgICAgICAgdGhpcy5fYm9ycm93aW5nRXhwZW5zZXMgPSBib3Jyb3dpbmdFeHBlbnNlcztcbiAgICAgICAgICB0aGlzLmJvcnJvd2luZ0V4cGVuc2VzU3ViamVjdC5uZXh0KHRoaXMuX2JvcnJvd2luZ0V4cGVuc2VzKTtcbiAgICAgICAgfSk7XG4gICAgfVxuXG4gICAgcmV0dXJuIHRoaXMuYm9ycm93aW5nRXhwZW5zZXNTdWJqZWN0LmFzT2JzZXJ2YWJsZSgpO1xuICB9XG5cbiAgZ2V0TG9hbkJvcnJvd2luZ0V4cGVuc2VzKGxvYW4/OiBMb2FuKTogT2JzZXJ2YWJsZTxhbnk+IHtcbiAgICByZXR1cm4gdGhpcy5nZXQoKVxuICAgICAgLnBpcGUoXG4gICAgICAgIG1hcCgoYm9ycm93aW5nRXhwZW5zZXM6IEJvcnJvd2luZ0V4cGVuc2VbXSkgPT4ge1xuICAgICAgICAgIC8vIExvYW4gYm9ycm93aW5nIGV4cGVuc2VzIGFycmF5XG4gICAgICAgICAgY29uc3QgYm9ycm93aW5nRXhwZW5zZXNMb2FuOiBCb3Jyb3dpbmdFeHBlbnNlTG9hbltdID0gW107XG4gICAgICAgICAgLy8gQ29tYmluZWQgYXJyYXkgb2YgYm9ycm93aW5nIGV4cGVuc2VzIGxpc3QgJiBsb2FuIGJvcnJvd2luZyBleHBlbnNlc1xuICAgICAgICAgIGNvbnN0IGNvbWJpbmVkQm9ycm93aW5nRXhwZW5zZXM6IEJvcnJvd2luZ0V4cGVuc2VMb2FuW10gPSBbXTtcblxuXG4gICAgICAgICAgYm9ycm93aW5nRXhwZW5zZXMuZm9yRWFjaCgoYm9ycm93aW5nRXhwZW5zZTogQm9ycm93aW5nRXhwZW5zZSwgaW5kZXg6IG51bWJlcikgPT4ge1xuICAgICAgICAgICAgLy8gRmlsbCBib3Jyb3dpbmdFeHBlbnNlc0xvYW4gd2l0aCB2YWx1ZXMgYmFzZWQgb24gYm9ycm93aW5nRXhwZW5zZXMgbGlzdFxuICAgICAgICAgICAgYm9ycm93aW5nRXhwZW5zZXNMb2FuLnB1c2gocGxhaW5Ub0NsYXNzKEJvcnJvd2luZ0V4cGVuc2VMb2FuLCB7XG4gICAgICAgICAgICAgIGJvcnJvd2luZ0V4cGVuc2U6IGJvcnJvd2luZ0V4cGVuc2UsXG4gICAgICAgICAgICAgIGxvYW46IGxvYW4sXG4gICAgICAgICAgICAgIGFtb3VudDogMCxcbiAgICAgICAgICAgICAgaWQ6IG51bGwsXG4gICAgICAgICAgICAgIGNyZWF0ZWRBdDogbnVsbCxcbiAgICAgICAgICAgICAgdXBkYXRlZEF0OiBudWxsLFxuICAgICAgICAgICAgICBjcmVhdGVkQnk6IG51bGwsXG4gICAgICAgICAgICAgIHVwZGF0ZWRCeTogbnVsbFxuICAgICAgICAgICAgfSkpO1xuXG4gICAgICAgICAgICBjb21iaW5lZEJvcnJvd2luZ0V4cGVuc2VzXG4gICAgICAgICAgICAgIC5wdXNoKE9iamVjdC5hc3NpZ24ocGxhaW5Ub0NsYXNzKEJvcnJvd2luZ0V4cGVuc2VMb2FuLCB7fSBhcyBCb3Jyb3dpbmdFeHBlbnNlTG9hbiksIGJvcnJvd2luZ0V4cGVuc2VzW2luZGV4XSwgYm9ycm93aW5nRXhwZW5zZXNMb2FuW2luZGV4XSkpO1xuXG4gICAgICAgICAgICAvLyBGaW5kIGN1cnJlbnQgbG9hbiBib3Jyb3dpbmcgZXhwZW5zZSBpbiBsb2FuIG9iamVjdCBieSBpbmRleFxuICAgICAgICAgICAgY29uc3QgdGFyZ2V0Qm9ycm93aW5nRXhwZW5zZTogYW55ID0gbG9hbi5ib3Jyb3dpbmdFeHBlbnNlcy5maW5kKCh1cGRCb3Jyb3dpbmdFeHBlbnNlc0xvYW46IEJvcnJvd2luZ0V4cGVuc2VMb2FuKSA9PlxuICAgICAgICAgICAgICB1cGRCb3Jyb3dpbmdFeHBlbnNlc0xvYW4uYm9ycm93aW5nRXhwZW5zZS5pZCA9PT0gYm9ycm93aW5nRXhwZW5zZXNMb2FuW2luZGV4XS5ib3Jyb3dpbmdFeHBlbnNlLmlkKTtcblxuICAgICAgICAgICAgLy8gLi4uIGFuZCBzZXQgaXRzIHZhbHVlIHRvIGN1cnJlbnQgbG9hbiBib3Jyb3dpbmcgZXhwZW5zZSBpbiBjb21iaW5lZEJvcnJvd2luZ0V4cGVuc2VzIGFycmF5XG4gICAgICAgICAgICBjb21iaW5lZEJvcnJvd2luZ0V4cGVuc2VzW2luZGV4XS5hbW91bnQgPSB0YXJnZXRCb3Jyb3dpbmdFeHBlbnNlID8gdGFyZ2V0Qm9ycm93aW5nRXhwZW5zZS5hbW91bnQgOiAwO1xuXG4gICAgICAgICAgICByZXR1cm4gY29tYmluZWRCb3Jyb3dpbmdFeHBlbnNlcztcbiAgICAgICAgICB9KTtcblxuICAgICAgICAgIHJldHVybiBjb21iaW5lZEJvcnJvd2luZ0V4cGVuc2VzO1xuICAgICAgICB9KVxuICAgICAgKTtcbiAgfVxufVxuIl19