taxtank-core 0.5.1 → 0.6.0

package/esm2015/lib/services/bank/bank-account.service.js

@@ -1,118 +1,118 @@
-import { Inject, Injectable } from '@angular/core';
-import { map } from 'rxjs/operators';
-import _ from 'lodash';
-import { replace } from '../../functions/array';
-import { plainToClass } from 'class-transformer';
-import { BaseRestService } from '../base-rest.service';
-import { BankAccount } from '../../models/bank/bank-account';
-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 that handling user's bank accounts logic
- */
-export class BankAccountService extends BaseRestService {
-    constructor(http, eventDispatcherService, environment) {
-        super(http, eventDispatcherService, environment);
-        this.http = http;
-        this.eventDispatcherService = eventDispatcherService;
-        this.environment = environment;
-        // api url parameter for bank accounts
-        this.url = 'bank-accounts';
-        this.modelClass = BankAccount;
-        this.listenEvents();
-    }
-    /**
-     * Listen system notifications and update cache when got basiq notification received
-     */
-    listenEvents() {
-        this.listenToEventDispatcherChanges();
-    }
-    /**
-     * Created manual bank account
-     * @param bankAccounts
-     * @param queryParams
-     */
-    addBatch(bankAccounts, queryParams = {}) {
-        return this.http.post(`${this.environment.apiV2}/${this.url}`, bankAccounts)
-            .pipe(map((newBankAccountsBase) => {
-            const newBankAccounts = newBankAccountsBase.map((bankAccountBase) => plainToClass(BankAccount, bankAccountBase));
-            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_CREATED, newBankAccounts));
-            const tempCache = _.cloneDeep(this.cache);
-            tempCache.push(...newBankAccounts);
-            this.cache = tempCache;
-            this.updateCache();
-            return newBankAccounts;
-        }));
-    }
-    /**
-     * Update bank account and fire event
-     */
-    update(bankAccount) {
-        return super.update(bankAccount).pipe(map((updatedBankAccount) => {
-            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_UPDATED, updatedBankAccount));
-            return updatedBankAccount;
-        }));
-    }
-    /**
-     * Update bank account opening balance
-     * @param bankAccount Bank account for balance updating
-     */
-    updateOpeningBalance(bankAccount) {
-        return this.http.put(`${this.environment.apiV2}/${this.url}/${bankAccount.id}/opening-balances/${bankAccount.getCurrentYearBalance().id}`, bankAccount.getCurrentYearBalance())
-            .pipe(map((response) => {
-            const tempCache = _.cloneDeep(this.cache);
-            replace(tempCache[tempCache.findIndex((ba) => ba.id === bankAccount.id)].balances, response);
-            this.cache = tempCache;
-            this.updateCache();
-        }));
-    }
-    /**
-     * Update bank account current balance
-     */
-    updateCurrentBalance(bankAccount) {
-        return this.http.put(`${this.environment.apiV2}/${this.url}/${bankAccount.id}/balance`, bankAccount)
-            .pipe(map((response) => {
-            const updatedBankAccount = plainToClass(BankAccount, response);
-            replace(this.cache, updatedBankAccount);
-            this.updateCache();
-            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_UPDATED, updatedBankAccount));
-            return updatedBankAccount;
-        }));
-    }
-    getOwn() {
-        return this.get()
-            .pipe(map((bankAccounts) => {
-            return bankAccounts.filter((bankAccount) => bankAccount.isOwner(+localStorage.getItem('userId')));
-        }));
-    }
-    /**
-     * Listen to EventDispatcherService events
-     */
-    listenToEventDispatcherChanges() {
-        this.eventDispatcherService.on([
-            AppEventTypeEnum.PROPERTY_OWNER_UPDATED,
-            AppEventTypeEnum.LOAN_PAYOUT_UPDATED,
-            AppEventTypeEnum.BANK_CONNECTION_ADDED
-        ]).subscribe(() => {
-            this.fetch().subscribe((bankAccounts) => {
-                this.cache = bankAccounts;
-                this.updateCache();
-            });
-        });
-    }
-}
-BankAccountService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankAccountService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
-BankAccountService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankAccountService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankAccountService, 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":"bank-account.service.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/services/bank/bank-account.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable} from '@angular/core';\r\nimport {HttpClient} from '@angular/common/http';\r\nimport {Observable} from 'rxjs';\r\nimport {BankAccount as BankAccountBase} from '../../db/Models/bank-account';\r\nimport {map} from 'rxjs/operators';\r\nimport _ from 'lodash';\r\nimport {replace} from '../../functions/array';\r\nimport {plainToClass} from 'class-transformer';\r\nimport {BaseRestService} from '../base-rest.service';\r\nimport {BankAccount} from '../../models/bank/bank-account';\r\nimport {EventDispatcherService} from '../event/event-dispatcher.service';\r\nimport {AppEvent} from '../../models/event/app-event';\r\nimport {AppEventTypeEnum} from '../../models/event/app-event-type.enum';\r\n\r\n/**\r\n * Service that handling user's bank accounts logic\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class BankAccountService extends BaseRestService<BankAccountBase, BankAccount> {\r\n  // api url parameter for bank accounts\r\n  url: string = 'bank-accounts';\r\n  modelClass = BankAccount;\r\n\r\n  constructor(\r\n    protected http: HttpClient,\r\n    protected eventDispatcherService: EventDispatcherService,\r\n    @Inject('environment') protected environment: any\r\n  ) {\r\n    super(http, eventDispatcherService, environment);\r\n    this.listenEvents();\r\n  }\r\n\r\n  /**\r\n   * Listen system notifications and update cache when got basiq notification received\r\n   */\r\n  listenEvents(): void {\r\n    this.listenToEventDispatcherChanges();\r\n  }\r\n\r\n  /**\r\n   * Created manual bank account\r\n   * @param bankAccounts\r\n   * @param queryParams\r\n   */\r\n  addBatch(bankAccounts: BankAccount[], queryParams: object = {}): Observable<BankAccount[]> {\r\n    return this.http.post(`${this.environment.apiV2}/${this.url}`, bankAccounts)\r\n      .pipe(\r\n        map((newBankAccountsBase: BankAccountBase[]) => {\r\n          const newBankAccounts: BankAccount[] = newBankAccountsBase.map((bankAccountBase: BankAccountBase): BankAccount => plainToClass(BankAccount, bankAccountBase));\r\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_CREATED, newBankAccounts));\r\n          const tempCache: BankAccount[] = _.cloneDeep(this.cache);\r\n          tempCache.push(...newBankAccounts);\r\n          this.cache = tempCache;\r\n          this.updateCache();\r\n          return newBankAccounts;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Update bank account and fire event\r\n   */\r\n  update(bankAccount: BankAccount): Observable<BankAccount> {\r\n    return super.update(bankAccount).pipe(\r\n      map((updatedBankAccount: BankAccount) => {\r\n        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_UPDATED, updatedBankAccount));\r\n        return updatedBankAccount;\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Update bank account opening balance\r\n   * @param bankAccount Bank account for balance updating\r\n   */\r\n  updateOpeningBalance(bankAccount: BankAccount): Observable<any> {\r\n    return this.http.put(`${this.environment.apiV2}/${this.url}/${bankAccount.id}/opening-balances/${bankAccount.getCurrentYearBalance().id}`, bankAccount.getCurrentYearBalance())\r\n      .pipe(\r\n        map((response: object) => {\r\n          const tempCache: BankAccount[] = _.cloneDeep(this.cache);\r\n\r\n          replace(tempCache[tempCache.findIndex((ba: BankAccount) => ba.id === bankAccount.id)].balances, response);\r\n          this.cache = tempCache;\r\n          this.updateCache();\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Update bank account current balance\r\n   */\r\n  updateCurrentBalance(bankAccount: BankAccount): Observable<BankAccount> {\r\n    return this.http.put(`${this.environment.apiV2}/${this.url}/${bankAccount.id}/balance`, bankAccount)\r\n      .pipe(\r\n        map((response: object) => {\r\n          const updatedBankAccount: BankAccount = plainToClass(BankAccount, response);\r\n\r\n          replace(this.cache, updatedBankAccount);\r\n          this.updateCache();\r\n\r\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_UPDATED, updatedBankAccount));\r\n          return updatedBankAccount;\r\n        })\r\n      );\r\n  }\r\n\r\n  getOwn(): Observable<BankAccount[]> {\r\n    return this.get()\r\n      .pipe(\r\n        map((bankAccounts: BankAccount[]) => {\r\n          return bankAccounts.filter((bankAccount: BankAccount) => bankAccount.isOwner(+localStorage.getItem('userId')));\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Listen to EventDispatcherService events\r\n   */\r\n  private listenToEventDispatcherChanges(): void {\r\n    this.eventDispatcherService.on([\r\n      AppEventTypeEnum.PROPERTY_OWNER_UPDATED,\r\n      AppEventTypeEnum.LOAN_PAYOUT_UPDATED,\r\n      AppEventTypeEnum.BANK_CONNECTION_ADDED\r\n    ]).subscribe(() => {\r\n      this.fetch().subscribe((bankAccounts: BankAccount[]) => {\r\n        this.cache = bankAccounts;\r\n        this.updateCache();\r\n      });\r\n    });\r\n  }\r\n}\r\n"]}
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import _ from 'lodash';
+import { replace } from '../../functions/array';
+import { plainToClass } from 'class-transformer';
+import { BaseRestService } from '../base-rest.service';
+import { BankAccount } from '../../models/bank/bank-account';
+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 that handling user's bank accounts logic
+ */
+export class BankAccountService extends BaseRestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        // api url parameter for bank accounts
+        this.url = 'bank-accounts';
+        this.modelClass = BankAccount;
+        this.listenEvents();
+    }
+    /**
+     * Listen system notifications and update cache when got basiq notification received
+     */
+    listenEvents() {
+        this.listenToEventDispatcherChanges();
+    }
+    /**
+     * Created manual bank account
+     * @param bankAccounts
+     * @param queryParams
+     */
+    addBatch(bankAccounts, queryParams = {}) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}`, bankAccounts)
+            .pipe(map((newBankAccountsBase) => {
+            const newBankAccounts = newBankAccountsBase.map((bankAccountBase) => plainToClass(BankAccount, bankAccountBase));
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_CREATED, newBankAccounts));
+            const tempCache = _.cloneDeep(this.cache);
+            tempCache.push(...newBankAccounts);
+            this.cache = tempCache;
+            this.updateCache();
+            return newBankAccounts;
+        }));
+    }
+    /**
+     * Update bank account and fire event
+     */
+    update(bankAccount) {
+        return super.update(bankAccount).pipe(map((updatedBankAccount) => {
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_UPDATED, updatedBankAccount));
+            return updatedBankAccount;
+        }));
+    }
+    /**
+     * Update bank account opening balance
+     * @param bankAccount Bank account for balance updating
+     */
+    updateOpeningBalance(bankAccount) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}/${bankAccount.id}/opening-balances/${bankAccount.getCurrentYearBalance().id}`, bankAccount.getCurrentYearBalance())
+            .pipe(map((response) => {
+            const tempCache = _.cloneDeep(this.cache);
+            replace(tempCache[tempCache.findIndex((ba) => ba.id === bankAccount.id)].balances, response);
+            this.cache = tempCache;
+            this.updateCache();
+        }));
+    }
+    /**
+     * Update bank account current balance
+     */
+    updateCurrentBalance(bankAccount) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}/${bankAccount.id}/balance`, bankAccount)
+            .pipe(map((response) => {
+            const updatedBankAccount = plainToClass(BankAccount, response);
+            replace(this.cache, updatedBankAccount);
+            this.updateCache();
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_UPDATED, updatedBankAccount));
+            return updatedBankAccount;
+        }));
+    }
+    getOwn() {
+        return this.get()
+            .pipe(map((bankAccounts) => {
+            return bankAccounts.filter((bankAccount) => bankAccount.isOwner(+localStorage.getItem('userId')));
+        }));
+    }
+    /**
+     * Listen to EventDispatcherService events
+     */
+    listenToEventDispatcherChanges() {
+        this.eventDispatcherService.on([
+            AppEventTypeEnum.PROPERTY_OWNER_UPDATED,
+            AppEventTypeEnum.LOAN_PAYOUT_UPDATED,
+            AppEventTypeEnum.BANK_CONNECTION_ADDED
+        ]).subscribe(() => {
+            this.fetch().subscribe((bankAccounts) => {
+                this.cache = bankAccounts;
+                this.updateCache();
+            });
+        });
+    }
+}
+BankAccountService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankAccountService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+BankAccountService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankAccountService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankAccountService, 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":"bank-account.service.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/services/bank/bank-account.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable} from '@angular/core';\nimport {HttpClient} from '@angular/common/http';\nimport {Observable} from 'rxjs';\nimport {BankAccount as BankAccountBase} from '../../db/Models/bank-account';\nimport {map} from 'rxjs/operators';\nimport _ from 'lodash';\nimport {replace} from '../../functions/array';\nimport {plainToClass} from 'class-transformer';\nimport {BaseRestService} from '../base-rest.service';\nimport {BankAccount} from '../../models/bank/bank-account';\nimport {EventDispatcherService} from '../event/event-dispatcher.service';\nimport {AppEvent} from '../../models/event/app-event';\nimport {AppEventTypeEnum} from '../../models/event/app-event-type.enum';\n\n/**\n * Service that handling user's bank accounts logic\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class BankAccountService extends BaseRestService<BankAccountBase, BankAccount> {\n  // api url parameter for bank accounts\n  url: string = 'bank-accounts';\n  modelClass = BankAccount;\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 system notifications and update cache when got basiq notification received\n   */\n  listenEvents(): void {\n    this.listenToEventDispatcherChanges();\n  }\n\n  /**\n   * Created manual bank account\n   * @param bankAccounts\n   * @param queryParams\n   */\n  addBatch(bankAccounts: BankAccount[], queryParams: object = {}): Observable<BankAccount[]> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}`, bankAccounts)\n      .pipe(\n        map((newBankAccountsBase: BankAccountBase[]) => {\n          const newBankAccounts: BankAccount[] = newBankAccountsBase.map((bankAccountBase: BankAccountBase): BankAccount => plainToClass(BankAccount, bankAccountBase));\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_CREATED, newBankAccounts));\n          const tempCache: BankAccount[] = _.cloneDeep(this.cache);\n          tempCache.push(...newBankAccounts);\n          this.cache = tempCache;\n          this.updateCache();\n          return newBankAccounts;\n        })\n      );\n  }\n\n  /**\n   * Update bank account and fire event\n   */\n  update(bankAccount: BankAccount): Observable<BankAccount> {\n    return super.update(bankAccount).pipe(\n      map((updatedBankAccount: BankAccount) => {\n        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_UPDATED, updatedBankAccount));\n        return updatedBankAccount;\n      })\n    );\n  }\n\n  /**\n   * Update bank account opening balance\n   * @param bankAccount Bank account for balance updating\n   */\n  updateOpeningBalance(bankAccount: BankAccount): Observable<any> {\n    return this.http.put(`${this.environment.apiV2}/${this.url}/${bankAccount.id}/opening-balances/${bankAccount.getCurrentYearBalance().id}`, bankAccount.getCurrentYearBalance())\n      .pipe(\n        map((response: object) => {\n          const tempCache: BankAccount[] = _.cloneDeep(this.cache);\n\n          replace(tempCache[tempCache.findIndex((ba: BankAccount) => ba.id === bankAccount.id)].balances, response);\n          this.cache = tempCache;\n          this.updateCache();\n        })\n      );\n  }\n\n  /**\n   * Update bank account current balance\n   */\n  updateCurrentBalance(bankAccount: BankAccount): Observable<BankAccount> {\n    return this.http.put(`${this.environment.apiV2}/${this.url}/${bankAccount.id}/balance`, bankAccount)\n      .pipe(\n        map((response: object) => {\n          const updatedBankAccount: BankAccount = plainToClass(BankAccount, response);\n\n          replace(this.cache, updatedBankAccount);\n          this.updateCache();\n\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_UPDATED, updatedBankAccount));\n          return updatedBankAccount;\n        })\n      );\n  }\n\n  getOwn(): Observable<BankAccount[]> {\n    return this.get()\n      .pipe(\n        map((bankAccounts: BankAccount[]) => {\n          return bankAccounts.filter((bankAccount: BankAccount) => bankAccount.isOwner(+localStorage.getItem('userId')));\n        })\n      );\n  }\n\n  /**\n   * Listen to EventDispatcherService events\n   */\n  private listenToEventDispatcherChanges(): void {\n    this.eventDispatcherService.on([\n      AppEventTypeEnum.PROPERTY_OWNER_UPDATED,\n      AppEventTypeEnum.LOAN_PAYOUT_UPDATED,\n      AppEventTypeEnum.BANK_CONNECTION_ADDED\n    ]).subscribe(() => {\n      this.fetch().subscribe((bankAccounts: BankAccount[]) => {\n        this.cache = bankAccounts;\n        this.updateCache();\n      });\n    });\n  }\n}\n"]}

package/esm2015/lib/services/bank/bank-connection.service.js

@@ -1,52 +1,52 @@
-import { Inject, Injectable } from '@angular/core';
-import { map } from 'rxjs/operators';
-import { plainToClass } from 'class-transformer';
-import { BankConnection } from '../../models/bank/bank-connection';
-import { BaseRestService } from '../base-rest.service';
-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";
-/**
- * BankConnection means user account at specific bank (usually each user has only one at the same bank)
- * service handles BankConnection management
- */
-export class BankConnectionService extends BaseRestService {
-    constructor(http, eventDispatcherService, environment) {
-        super(http, eventDispatcherService, environment);
-        this.http = http;
-        this.eventDispatcherService = eventDispatcherService;
-        this.environment = environment;
-        this.modelClass = BankConnection;
-        this.url = 'bank-connections';
-        this.listenEvents();
-    }
-    listenEvents() {
-        this.listenToAddedBankAccounts();
-    }
-    post(bankConnection) {
-        return this.http.post(`${this.environment.apiV2}/${this.url}`, bankConnection)
-            .pipe(map((bankConnectionBase) => {
-            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_CONNECTION_ADDED, null));
-            return plainToClass(BankConnection, bankConnectionBase);
-        }));
-    }
-    listenToAddedBankAccounts() {
-        this.eventDispatcherService.on(AppEventTypeEnum.BANK_ACCOUNT_CREATED).subscribe(() => {
-            this.resetCache();
-        });
-    }
-}
-BankConnectionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankConnectionService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
-BankConnectionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankConnectionService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankConnectionService, 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFuay1jb25uZWN0aW9uLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvc2VydmljZXMvYmFuay9iYW5rLWNvbm5lY3Rpb24uc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUduRCxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFckMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRWpELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUNuRSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDdkQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ3hELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHdDQUF3QyxDQUFDOzs7O0FBRTFFOzs7R0FHRztBQUlILE1BQU0sT0FBTyxxQkFBc0IsU0FBUSxlQUFtRDtJQUk1RixZQUNZLElBQWdCLEVBQ2hCLHNCQUE4QyxFQUN2QixXQUFnQjtRQUVqRCxLQUFLLENBQUMsSUFBSSxFQUFFLHNCQUFzQixFQUFFLFdBQVcsQ0FBQyxDQUFDO1FBSnZDLFNBQUksR0FBSixJQUFJLENBQVk7UUFDaEIsMkJBQXNCLEdBQXRCLHNCQUFzQixDQUF3QjtRQUN2QixnQkFBVyxHQUFYLFdBQVcsQ0FBSztRQU5uRCxlQUFVLEdBQUcsY0FBYyxDQUFDO1FBQzVCLFFBQUcsR0FBVyxrQkFBa0IsQ0FBQztRQVEvQixJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDdEIsQ0FBQztJQUVELFlBQVk7UUFDVixJQUFJLENBQUMseUJBQXlCLEVBQUUsQ0FBQztJQUNuQyxDQUFDO0lBRUQsSUFBSSxDQUFDLGNBQThCO1FBQ2pDLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLEtBQUssSUFBSSxJQUFJLENBQUMsR0FBRyxFQUFFLEVBQUUsY0FBYyxDQUFDO2FBQzNFLElBQUksQ0FDSCxHQUFHLENBQUMsQ0FBQyxrQkFBc0MsRUFBRSxFQUFFO1lBQzdDLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxRQUFRLENBQUMsSUFBSSxRQUFRLENBQUMsZ0JBQWdCLENBQUMscUJBQXFCLEVBQUUsSUFBSSxDQUFDLENBQUMsQ0FBQztZQUVqRyxPQUFPLFlBQVksQ0FBQyxjQUFjLEVBQUUsa0JBQWtCLENBQUMsQ0FBQztRQUMxRCxDQUFDLENBQUMsQ0FDSCxDQUFDO0lBQ04sQ0FBQztJQUVELHlCQUF5QjtRQUN2QixJQUFJLENBQUMsc0JBQXNCLENBQUMsRUFBRSxDQUFDLGdCQUFnQixDQUFDLG9CQUFvQixDQUFDLENBQUMsU0FBUyxDQUFDLEdBQUcsRUFBRTtZQUNuRixJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7UUFDcEIsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDOzttSEFoQ1UscUJBQXFCLGtGQU90QixhQUFhO3VIQVBaLHFCQUFxQixjQUZwQixNQUFNOzRGQUVQLHFCQUFxQjtrQkFIakMsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkI7OzBCQVFJLE1BQU07MkJBQUMsYUFBYSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdCwgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBIdHRwQ2xpZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xyXG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XHJcbmltcG9ydCB7IG1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcclxuaW1wb3J0IHsgQmFua0Nvbm5lY3Rpb24gYXMgQmFua0Nvbm5lY3Rpb25CYXNlIH0gZnJvbSAnLi4vLi4vZGIvTW9kZWxzL2JhbmstY29ubmVjdGlvbic7XHJcbmltcG9ydCB7IHBsYWluVG9DbGFzcyB9IGZyb20gJ2NsYXNzLXRyYW5zZm9ybWVyJztcclxuaW1wb3J0IHsgRXZlbnREaXNwYXRjaGVyU2VydmljZSB9IGZyb20gJy4uL2V2ZW50L2V2ZW50LWRpc3BhdGNoZXIuc2VydmljZSc7XHJcbmltcG9ydCB7IEJhbmtDb25uZWN0aW9uIH0gZnJvbSAnLi4vLi4vbW9kZWxzL2JhbmsvYmFuay1jb25uZWN0aW9uJztcclxuaW1wb3J0IHsgQmFzZVJlc3RTZXJ2aWNlIH0gZnJvbSAnLi4vYmFzZS1yZXN0LnNlcnZpY2UnO1xyXG5pbXBvcnQgeyBBcHBFdmVudCB9IGZyb20gJy4uLy4uL21vZGVscy9ldmVudC9hcHAtZXZlbnQnO1xyXG5pbXBvcnQgeyBBcHBFdmVudFR5cGVFbnVtIH0gZnJvbSAnLi4vLi4vbW9kZWxzL2V2ZW50L2FwcC1ldmVudC10eXBlLmVudW0nO1xyXG5cclxuLyoqXHJcbiAqIEJhbmtDb25uZWN0aW9uIG1lYW5zIHVzZXIgYWNjb3VudCBhdCBzcGVjaWZpYyBiYW5rICh1c3VhbGx5IGVhY2ggdXNlciBoYXMgb25seSBvbmUgYXQgdGhlIHNhbWUgYmFuaylcclxuICogc2VydmljZSBoYW5kbGVzIEJhbmtDb25uZWN0aW9uIG1hbmFnZW1lbnRcclxuICovXHJcbkBJbmplY3RhYmxlKHtcclxuICBwcm92aWRlZEluOiAncm9vdCdcclxufSlcclxuZXhwb3J0IGNsYXNzIEJhbmtDb25uZWN0aW9uU2VydmljZSBleHRlbmRzIEJhc2VSZXN0U2VydmljZTxCYW5rQ29ubmVjdGlvbkJhc2UsIEJhbmtDb25uZWN0aW9uPiB7XHJcbiAgbW9kZWxDbGFzcyA9IEJhbmtDb25uZWN0aW9uO1xyXG4gIHVybDogc3RyaW5nID0gJ2JhbmstY29ubmVjdGlvbnMnO1xyXG5cclxuICBjb25zdHJ1Y3RvcihcclxuICAgIHByb3RlY3RlZCBodHRwOiBIdHRwQ2xpZW50LFxyXG4gICAgcHJvdGVjdGVkIGV2ZW50RGlzcGF0Y2hlclNlcnZpY2U6IEV2ZW50RGlzcGF0Y2hlclNlcnZpY2UsXHJcbiAgICBASW5qZWN0KCdlbnZpcm9ubWVudCcpIHByb3RlY3RlZCBlbnZpcm9ubWVudDogYW55XHJcbiAgKSB7XHJcbiAgICBzdXBlcihodHRwLCBldmVudERpc3BhdGNoZXJTZXJ2aWNlLCBlbnZpcm9ubWVudCk7XHJcbiAgICB0aGlzLmxpc3RlbkV2ZW50cygpO1xyXG4gIH1cclxuXHJcbiAgbGlzdGVuRXZlbnRzKCk6IHZvaWQge1xyXG4gICAgdGhpcy5saXN0ZW5Ub0FkZGVkQmFua0FjY291bnRzKCk7XHJcbiAgfVxyXG5cclxuICBwb3N0KGJhbmtDb25uZWN0aW9uOiBCYW5rQ29ubmVjdGlvbik6IE9ic2VydmFibGU8QmFua0Nvbm5lY3Rpb24+IHtcclxuICAgIHJldHVybiB0aGlzLmh0dHAucG9zdChgJHt0aGlzLmVudmlyb25tZW50LmFwaVYyfS8ke3RoaXMudXJsfWAsIGJhbmtDb25uZWN0aW9uKVxyXG4gICAgICAucGlwZShcclxuICAgICAgICBtYXAoKGJhbmtDb25uZWN0aW9uQmFzZTogQmFua0Nvbm5lY3Rpb25CYXNlKSA9PiB7XHJcbiAgICAgICAgICB0aGlzLmV2ZW50RGlzcGF0Y2hlclNlcnZpY2UuZGlzcGF0Y2gobmV3IEFwcEV2ZW50KEFwcEV2ZW50VHlwZUVudW0uQkFOS19DT05ORUNUSU9OX0FEREVELCBudWxsKSk7XHJcblxyXG4gICAgICAgICAgcmV0dXJuIHBsYWluVG9DbGFzcyhCYW5rQ29ubmVjdGlvbiwgYmFua0Nvbm5lY3Rpb25CYXNlKTtcclxuICAgICAgICB9KVxyXG4gICAgICApO1xyXG4gIH1cclxuXHJcbiAgbGlzdGVuVG9BZGRlZEJhbmtBY2NvdW50cygpOiB2b2lkIHtcclxuICAgIHRoaXMuZXZlbnREaXNwYXRjaGVyU2VydmljZS5vbihBcHBFdmVudFR5cGVFbnVtLkJBTktfQUNDT1VOVF9DUkVBVEVEKS5zdWJzY3JpYmUoKCkgPT4ge1xyXG4gICAgICB0aGlzLnJlc2V0Q2FjaGUoKTtcclxuICAgIH0pO1xyXG4gIH1cclxufVxyXG4iXX0=
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { BankConnection } from '../../models/bank/bank-connection';
+import { BaseRestService } from '../base-rest.service';
+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";
+/**
+ * BankConnection means user account at specific bank (usually each user has only one at the same bank)
+ * service handles BankConnection management
+ */
+export class BankConnectionService extends BaseRestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.modelClass = BankConnection;
+        this.url = 'bank-connections';
+        this.listenEvents();
+    }
+    listenEvents() {
+        this.listenToAddedBankAccounts();
+    }
+    post(bankConnection) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}`, bankConnection)
+            .pipe(map((bankConnectionBase) => {
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_CONNECTION_ADDED, null));
+            return plainToClass(BankConnection, bankConnectionBase);
+        }));
+    }
+    listenToAddedBankAccounts() {
+        this.eventDispatcherService.on(AppEventTypeEnum.BANK_ACCOUNT_CREATED).subscribe(() => {
+            this.resetCache();
+        });
+    }
+}
+BankConnectionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankConnectionService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+BankConnectionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankConnectionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankConnectionService, 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,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

package/esm2015/lib/services/bank/bank-transaction-calculation.service.js

@@ -1,65 +1,65 @@
-import { Injectable } from '@angular/core';
-import { BankTransactionCollection } from '../../collections/bank-transaction.collection';
-import * as i0 from "@angular/core";
-/**
- * @TODO move to collection
- */
-export class BankTransactionCalculationService {
-    /**
-     * Sum of allocations for passed bank transactions
-     */
-    getAllocatedAmount(bankTransactions, allocations) {
-        return allocations.getByBankTransactionsIds(bankTransactions.getIds()).amount;
-    }
-    /**
-     * Difference between total bank transactions amount and sum of allocations for passed bank transactions
-     */
-    getUnallocatedAmount(bankTransactionCollection, allocations) {
-        return bankTransactionCollection.getAmount() - allocations.amount;
-    }
-    /**
-     * Check if bank transaction is allocated
-     */
-    isAllocated(bankTransaction, allocations) {
-        return bankTransaction.amount === this.getAllocatedAmount(new BankTransactionCollection([bankTransaction]), allocations);
-    }
-    /**
-     * Get collection of allocated bank transactions
-     * @TODO Alex: consider to move to collection
-     */
-    getAllocatedBankTransactions(bankTransactions, allocations) {
-        return new BankTransactionCollection(bankTransactions.items.filter((bankTransaction) => {
-            return this.isAllocated(bankTransaction, allocations);
-        }));
-    }
-    /**
-     * Get collection of unallocated bank transactions
-     * @TODO Alex: consider to move to collection
-     */
-    getUnallocatedBankTransactions(bankTransactions, allocations) {
-        return new BankTransactionCollection(bankTransactions.items.filter((bankTransaction) => {
-            return !this.isAllocated(bankTransaction, allocations);
-        }));
-    }
-    /**
-     * Allocated sum of credit transactions
-     */
-    getCreditAmount(bankTransactions, allocations) {
-        return allocations.getByBankTransactionsIds(bankTransactions.creditTransactions.getIds()).amount;
-    }
-    /**
-     * Allocated sum of debit transactions
-     */
-    getDebitAmount(bankTransactions, allocations) {
-        return allocations.getByBankTransactionsIds(bankTransactions.debitTransactions.getIds()).amount;
-    }
-}
-BankTransactionCalculationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankTransactionCalculationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-BankTransactionCalculationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankTransactionCalculationService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankTransactionCalculationService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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
+import { Injectable } from '@angular/core';
+import { BankTransactionCollection } from '../../collections/bank-transaction.collection';
+import * as i0 from "@angular/core";
+/**
+ * @TODO move to collection
+ */
+export class BankTransactionCalculationService {
+    /**
+     * Sum of allocations for passed bank transactions
+     */
+    getAllocatedAmount(bankTransactions, allocations) {
+        return allocations.getByBankTransactionsIds(bankTransactions.getIds()).amount;
+    }
+    /**
+     * Difference between total bank transactions amount and sum of allocations for passed bank transactions
+     */
+    getUnallocatedAmount(bankTransactionCollection, allocations) {
+        return bankTransactionCollection.getAmount() - allocations.amount;
+    }
+    /**
+     * Check if bank transaction is allocated
+     */
+    isAllocated(bankTransaction, allocations) {
+        return bankTransaction.amount === this.getAllocatedAmount(new BankTransactionCollection([bankTransaction]), allocations);
+    }
+    /**
+     * Get collection of allocated bank transactions
+     * @TODO Alex: consider to move to collection
+     */
+    getAllocatedBankTransactions(bankTransactions, allocations) {
+        return new BankTransactionCollection(bankTransactions.items.filter((bankTransaction) => {
+            return this.isAllocated(bankTransaction, allocations);
+        }));
+    }
+    /**
+     * Get collection of unallocated bank transactions
+     * @TODO Alex: consider to move to collection
+     */
+    getUnallocatedBankTransactions(bankTransactions, allocations) {
+        return new BankTransactionCollection(bankTransactions.items.filter((bankTransaction) => {
+            return !this.isAllocated(bankTransaction, allocations);
+        }));
+    }
+    /**
+     * Allocated sum of credit transactions
+     */
+    getCreditAmount(bankTransactions, allocations) {
+        return allocations.getByBankTransactionsIds(bankTransactions.creditTransactions.getIds()).amount;
+    }
+    /**
+     * Allocated sum of debit transactions
+     */
+    getDebitAmount(bankTransactions, allocations) {
+        return allocations.getByBankTransactionsIds(bankTransactions.debitTransactions.getIds()).amount;
+    }
+}
+BankTransactionCalculationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankTransactionCalculationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+BankTransactionCalculationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankTransactionCalculationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankTransactionCalculationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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