taxtank-core 0.8.3 → 0.8.7

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

@@ -0,0 +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 { RestService } from '../../rest/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 RestService {
+    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_SHARE_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/http/bank/bank-account/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 {RestService} from '../../rest/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 RestService<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_SHARE_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/http/bank/bank-connection/bank-connection.service.js

@@ -0,0 +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 { RestService } from '../../rest/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 RestService {
+    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/http/bank/bank-transaction/bank-transaction.service.js

@@ -0,0 +1,89 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { RestService } from '../../rest/rest.service';
+import { plainToClass } from 'class-transformer';
+import { UserEventTypeClientTypeEnum } from '../../../../db/Enums/user-event-type-client-type.enum';
+import { BankTransaction } from '../../../../models/bank/bank-transaction';
+import { FinancialYear } from '../../../../models/financial-year/financial-year';
+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 for bank transactions business logic
+ */
+export class BankTransactionService extends RestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        // url part for BankTransaction API
+        this.url = 'bank-transactions';
+        this.modelClass = BankTransaction;
+        this.listenEvents();
+    }
+    listenEvents() {
+        this.listenBankTransactionsImport();
+    }
+    ;
+    /**
+     * get list of bank transactions for passed bank account id
+     * @param bankAccountId Id of bank account we search bank transactions for
+     */
+    getByBankAccountId(bankAccountId) {
+        return this.get()
+            .pipe(map((bankTransactions) => {
+            return bankTransactions.filter((bankTransaction) => bankTransaction.bankAccount.id === bankAccountId);
+        }));
+    }
+    /**
+     * Get list of bank transactions for provided financial year
+     * @TODO VIK/Alex: consider to use one endpoint to get bank transactions for 2 fin years
+     */
+    getTransactionsByYear(finYear) {
+        return this.http.get(`${this.environment.apiV2}/bank-transactions?financialYear=${finYear}`)
+            .pipe(map((bankTransactionsBase) => {
+            return bankTransactionsBase.map((bankTransaction) => plainToClass(BankTransaction, bankTransaction));
+        }));
+    }
+    /**
+     * import bank transactions from csv file
+     * @param bankAccountId Bank account id we import bank transactions for
+     * @param file File with bank transactions for import
+     */
+    import(bankAccountId, file) {
+        const formData = new FormData();
+        formData.append('file', file);
+        return this.http.post(`${this.environment.apiV2}/bank-accounts/${bankAccountId}/bank-transaction-imports`, formData)
+            .pipe(map((response) => {
+            const newBankTransactions = response.map((bankTransaction) => plainToClass(BankTransaction, bankTransaction));
+            // push new items to cache only if we already have cache. Otherwise cache will contain only new items.
+            if (this.cache) {
+                // just current year's transactions should be added
+                this.cache.push(...newBankTransactions.filter((bt) => new FinancialYear().includes(bt.date)));
+                this.updateCache();
+            }
+            return newBankTransactions;
+        }));
+    }
+    listenBankTransactionsImport() {
+        this.eventDispatcherService.on(AppEventTypeEnum.NOTIFICATION_ADDED).subscribe((notification) => {
+            if (!notification.isRead && notification.eventType === UserEventTypeClientTypeEnum.BASIQ_FIRST_IMPORT_COMPLETE) {
+                this.resetCache();
+            }
+        });
+    }
+}
+BankTransactionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankTransactionService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+BankTransactionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankTransactionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankTransactionService, 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-transaction.service.js","sourceRoot":"","sources":["../../../../../../../../projects/tt-core/src/lib/services/http/bank/bank-transaction/bank-transaction.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { BankTransaction as BankTransactionBase } from '../../../../db/Models/bank-transaction';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { RestService } from '../../rest/rest.service';\nimport { plainToClass } from 'class-transformer';\nimport { HttpClient } from '@angular/common/http';\nimport { UserEventTypeClientTypeEnum } from '../../../../db/Enums/user-event-type-client-type.enum';\nimport { BankTransaction } from '../../../../models/bank/bank-transaction';\nimport { EventDispatcherService } from '../../../event/event-dispatcher.service';\nimport { FinancialYear } from '../../../../models/financial-year/financial-year';\nimport { AppEventTypeEnum } from '../../../../models/event/app-event-type.enum';\nimport { Notification } from '../../../../models/notification/notification';\n\n/**\n * Service for bank transactions business logic\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class BankTransactionService extends RestService<BankTransactionBase, BankTransaction> {\n  // url part for BankTransaction API\n  url: string = 'bank-transactions';\n  modelClass = BankTransaction;\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  private listenEvents(): void {\n    this.listenBankTransactionsImport();\n  };\n\n  /**\n   * get list of bank transactions for passed bank account id\n   * @param bankAccountId Id of bank account we search bank transactions for\n   */\n  getByBankAccountId(bankAccountId: number): Observable<BankTransaction[]> {\n    return this.get()\n      .pipe(\n        map((bankTransactions: BankTransaction[]) => {\n          return bankTransactions.filter((bankTransaction: BankTransaction) => bankTransaction.bankAccount.id === bankAccountId);\n        })\n      );\n  }\n\n  /**\n   * Get list of bank transactions for provided financial year\n   * @TODO VIK/Alex: consider to use one endpoint to get bank transactions for 2 fin years\n   */\n  getTransactionsByYear(finYear: number): Observable<BankTransaction[]> {\n    return this.http.get(`${this.environment.apiV2}/bank-transactions?financialYear=${finYear}`)\n      .pipe(\n        map((bankTransactionsBase: BankTransactionBase[]) => {\n          return bankTransactionsBase.map((bankTransaction: BankTransaction) => plainToClass(BankTransaction, bankTransaction));\n        })\n      );\n  }\n\n  /**\n   * import bank transactions from csv file\n   * @param bankAccountId Bank account id we import bank transactions for\n   * @param file File with bank transactions for import\n   */\n  import(bankAccountId: number, file: File): Observable<BankTransaction[]> {\n    const formData: FormData = new FormData();\n    formData.append('file', file);\n\n    return this.http.post(`${this.environment.apiV2}/bank-accounts/${bankAccountId}/bank-transaction-imports`, formData)\n      .pipe(\n        map((response: BankTransactionBase[]) => {\n          const newBankTransactions: BankTransaction[] = response.map((bankTransaction: BankTransactionBase) => plainToClass(BankTransaction, bankTransaction));\n          // push new items to cache only if we already have cache. Otherwise cache will contain only new items.\n          if (this.cache) {\n            // just current year's transactions should be added\n            this.cache.push(...newBankTransactions.filter((bt: BankTransaction) => new FinancialYear().includes(bt.date)));\n            this.updateCache();\n          }\n\n          return newBankTransactions;\n        })\n      );\n  }\n\n  private listenBankTransactionsImport(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.NOTIFICATION_ADDED).subscribe((notification: Notification) => {\n      if (!notification.isRead && notification.eventType === UserEventTypeClientTypeEnum.BASIQ_FIRST_IMPORT_COMPLETE) {\n        this.resetCache();\n      }\n    });\n  }\n}\n"]}

package/esm2015/lib/services/http/bank/bank.service.js

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { Bank } from '../../../models/bank/bank';
+import { RestService } from '../rest/rest.service';
+import * as i0 from "@angular/core";
+/**
+ * Service that handling banks logic
+ */
+export class BankService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = Bank;
+        this.url = 'banks';
+        this.isHydra = true;
+    }
+}
+BankService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+BankService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFuay5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3NlcnZpY2VzL2h0dHAvYmFuay9iYW5rLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDakQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHNCQUFzQixDQUFDOztBQUVuRDs7R0FFRztBQUlILE1BQU0sT0FBTyxXQUFZLFNBQVEsV0FBMkI7SUFINUQ7O1FBSUUsZUFBVSxHQUFnQixJQUFJLENBQUM7UUFDL0IsUUFBRyxHQUFXLE9BQU8sQ0FBQztRQUN0QixZQUFPLEdBQVksSUFBSSxDQUFDO0tBQ3pCOzt5R0FKWSxXQUFXOzZHQUFYLFdBQVcsY0FGVixNQUFNOzRGQUVQLFdBQVc7a0JBSHZCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQmFuayBhcyBCYW5rQmFzZSB9IGZyb20gJy4uLy4uLy4uL2RiL01vZGVscy9iYW5rJztcbmltcG9ydCB7IEJhbmsgfSBmcm9tICcuLi8uLi8uLi9tb2RlbHMvYmFuay9iYW5rJztcbmltcG9ydCB7IFJlc3RTZXJ2aWNlIH0gZnJvbSAnLi4vcmVzdC9yZXN0LnNlcnZpY2UnO1xuXG4vKipcbiAqIFNlcnZpY2UgdGhhdCBoYW5kbGluZyBiYW5rcyBsb2dpY1xuICovXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBCYW5rU2VydmljZSBleHRlbmRzIFJlc3RTZXJ2aWNlPEJhbmtCYXNlLCBCYW5rPiB7XG4gIG1vZGVsQ2xhc3M6IHR5cGVvZiBCYW5rID0gQmFuaztcbiAgdXJsOiBzdHJpbmcgPSAnYmFua3MnO1xuICBpc0h5ZHJhOiBib29sZWFuID0gdHJ1ZTtcbn1cbiJdfQ==

package/esm2015/lib/services/http/bank/basiq/basiq.service.js

@@ -0,0 +1,94 @@
+import { Inject, Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { UserEventTypeClientTypeEnum } from '../../../../db/Enums/user-event-type-client-type.enum';
+import { RestService } from '../../rest/rest.service';
+import { BankAccount } from '../../../../models/bank/bank-account';
+import { BasiqToken } from '../../../../models/bank/basiq-token';
+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";
+/**
+ * basiq is a middleman between bank and user
+ * service is responsible for fetching bank related information
+ */
+export class BasiqService extends RestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.tokenSubject = new ReplaySubject();
+        this.url = 'basiq/accounts';
+        this.modelClass = BankAccount;
+        this.listenEvents();
+    }
+    /**
+     * Listen events from Event Dispatcher service
+     */
+    listenEvents() {
+        this.listenToBankConnectionAdded();
+        this.listenNotifications();
+    }
+    /**
+     * access token to use basiq connect ui iframe
+     */
+    getToken() {
+        if (!this.token || this.token.isExpired()) {
+            this.http.get(`${this.environment.apiV2}/basiq/tokens`)
+                .pipe(map((response) => {
+                const now = new Date().getTime();
+                return new BasiqToken(response['access_token'], new Date(now + response['expires_in'] * 1000));
+            }))
+                .subscribe((token) => {
+                this.tokenSubject.next(token);
+            });
+        }
+        return this.tokenSubject.asObservable();
+    }
+    getConnections() {
+        return this.get().pipe(map((bankAccounts) => {
+            // get all connections
+            const connections = bankAccounts.map((bankAccount) => {
+                return bankAccount.bankConnection;
+            });
+            // return without duplicates
+            return [...new Map(connections.map((connection) => [connection.id, connection])).values()];
+        }));
+    }
+    /**
+     * Listen to EventDispatcherService event related to added Bank connection
+     */
+    listenToBankConnectionAdded() {
+        this.eventDispatcherService.on(AppEventTypeEnum.BANK_CONNECTION_ADDED).subscribe(() => {
+            this.fetch().subscribe((bankAccounts) => {
+                this.cache = bankAccounts;
+                this.updateCache();
+            });
+        });
+    }
+    /**
+     * listen to notifications to update basiq accounts list
+     */
+    listenNotifications() {
+        this.eventDispatcherService.on(AppEventTypeEnum.NOTIFICATION_ADDED).subscribe((notification) => {
+            if (!notification.isRead && notification.eventType === UserEventTypeClientTypeEnum.BASIQ_NEW_ACCOUNTS) {
+                this.resetCache();
+                this.get().subscribe();
+            }
+        });
+    }
+}
+BasiqService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BasiqService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+BasiqService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BasiqService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BasiqService, 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":"basiq.service.js","sourceRoot":"","sources":["../../../../../../../../projects/tt-core/src/lib/services/http/bank/basiq/basiq.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable, ReplaySubject } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { BankAccount as BankAccountBase } from '../../../../db/Models/bank-account';\nimport { UserEventTypeClientTypeEnum } from '../../../../db/Enums/user-event-type-client-type.enum';\nimport { RestService } from '../../rest/rest.service';\nimport { BankAccount } from '../../../../models/bank/bank-account';\nimport { BasiqToken } from '../../../../models/bank/basiq-token';\nimport { EventDispatcherService } from '../../../event/event-dispatcher.service';\nimport { AppEventTypeEnum } from '../../../../models/event/app-event-type.enum';\nimport { BankConnection } from '../../../../models/bank/bank-connection';\nimport { Notification } from '../../../../models/notification/notification';\n\n/**\n * basiq is a middleman between bank and user\n * service is responsible for fetching bank related information\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class BasiqService extends RestService<BankAccountBase, BankAccount> {\n  token: BasiqToken;\n  tokenSubject: ReplaySubject<BasiqToken> = new ReplaySubject<BasiqToken>();\n  url: string = 'basiq/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 events from Event Dispatcher service\n   */\n  listenEvents(): void {\n    this.listenToBankConnectionAdded();\n    this.listenNotifications();\n  }\n\n  /**\n   * access token to use basiq connect ui iframe\n   */\n  getToken(): Observable<BasiqToken> {\n    if (!this.token || this.token.isExpired()) {\n      this.http.get(`${this.environment.apiV2}/basiq/tokens`)\n        .pipe(\n          map((response: object) => {\n            const now: number = new Date().getTime();\n\n            return new BasiqToken(response['access_token'], new Date(now + response['expires_in'] * 1000));\n          })\n        )\n        .subscribe((token: BasiqToken) => {\n          this.tokenSubject.next(token);\n        });\n    }\n\n    return this.tokenSubject.asObservable();\n  }\n\n  getConnections(): Observable<BankConnection[]> {\n    return this.get().pipe(\n      map((bankAccounts: BankAccount[]) => {\n        // get all connections\n        const connections: BankConnection[] = bankAccounts.map((bankAccount: BankAccount) => {\n          return bankAccount.bankConnection;\n        });\n\n        // return without duplicates\n        return [...new Map(connections.map((connection: BankConnection) => [connection.id, connection])).values()];\n      })\n    );\n  }\n\n  /**\n   * Listen to EventDispatcherService event related to added Bank connection\n   */\n  private listenToBankConnectionAdded(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.BANK_CONNECTION_ADDED).subscribe(() => {\n      this.fetch().subscribe((bankAccounts: BankAccount[]) => {\n        this.cache = bankAccounts;\n        this.updateCache();\n      });\n    });\n  }\n\n  /**\n   * listen to notifications to update basiq accounts list\n   */\n  private listenNotifications(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.NOTIFICATION_ADDED).subscribe((notification: Notification): void => {\n      if (!notification.isRead && notification.eventType === UserEventTypeClientTypeEnum.BASIQ_NEW_ACCOUNTS) {\n        this.resetCache();\n        this.get().subscribe();\n      }\n    });\n  }\n}\n"]}

package/esm2015/lib/services/http/chart-accounts/chart-accounts-depreciations/chart-accounts-depreciations.service.js

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest.service';
+import { map } from 'rxjs/operators';
+import { ChartAccountsDepreciation } from '../../../../models/chart-accounts/chart-accounts-depreciation';
+import { FinancialYear } from '../../../../models/financial-year/financial-year';
+import * as i0 from "@angular/core";
+/**
+ * Service to work with depreciation chart accounts
+ */
+export class ChartAccountsDepreciationService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.url = 'chart-accounts-depreciations';
+        this.modelClass = ChartAccountsDepreciation;
+        this.isHydra = true;
+    }
+    /**
+     * Get depreciation chart accounts for current financial year
+     */
+    getCurrent() {
+        return this.get()
+            .pipe(map((chartAccountsDepreciations) => {
+            return chartAccountsDepreciations
+                .find((chartAccountsDepreciation) => {
+                return chartAccountsDepreciation.effectiveYear === new FinancialYear().year;
+            });
+        }));
+    }
+}
+ChartAccountsDepreciationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ChartAccountsDepreciationService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+ChartAccountsDepreciationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ChartAccountsDepreciationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ChartAccountsDepreciationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/http/chart-accounts/chart-accounts.service.js

@@ -0,0 +1,89 @@
+import { Inject, Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { ChartAccounts } from '../../../models/chart-accounts/chart-accounts';
+import { ChartAccountsHeading } from '../../../models/chart-accounts/chart-accounts-heading';
+import { CHART_ACCOUNTS_CATEGORIES } from '../../../models/chart-accounts/chart-accounts-categories.const';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Chart accounts service
+ */
+export class ChartAccountsService {
+    constructor(http, environment) {
+        this.http = http;
+        this.environment = environment;
+        this.chartAccountsSubject = new ReplaySubject(1);
+    }
+    /**
+     * get all parent and child chart accounts and group it
+     */
+    getChartAccounts() {
+        if (!this._chartAccounts) {
+            this._chartAccounts = [];
+            this.http.get(`${this.environment.apiV2}/chart-accounts`)
+                .pipe(map((response) => {
+                return response.map((item) => plainToClass(ChartAccounts, item));
+            }))
+                .subscribe((chartAccounts) => {
+                this._chartAccounts = chartAccounts;
+                this.chartAccountsSubject.next(this._chartAccounts);
+            });
+        }
+        return this.chartAccountsSubject.asObservable();
+    }
+    /**
+     * Get list of chart accounts heading
+     * @param categories
+     */
+    getChartAccountsHeadings(categories = CHART_ACCOUNTS_CATEGORIES.all) {
+        return this.getChartAccounts()
+            .pipe(map((chartAccounts) => {
+            const filteredChartAccounts = chartAccounts.filter((ca) => categories.includes(ca.category));
+            const headings = [];
+            filteredChartAccounts.forEach((ca) => {
+                let heading = headings.find((h) => { var _a; return h.id === ((_a = ca.heading) === null || _a === void 0 ? void 0 : _a.id); });
+                if (!heading) {
+                    heading = plainToClass(ChartAccountsHeading, ca.heading);
+                    heading.chartAccounts = [];
+                    headings.push(heading);
+                }
+                heading.chartAccounts.push(ca);
+            });
+            return headings;
+        }));
+    }
+    /**
+     * Get heading of chart accounts by it Id
+     * @param id
+     */
+    getHeadingByChartAccountsId(id) {
+        return this.getChartAccountsById(id)
+            .pipe(map((chartAccounts) => {
+            return chartAccounts.heading;
+        }));
+    }
+    /**
+     * Get chart accounts by Id
+     * @param id
+     */
+    getChartAccountsById(id) {
+        return this.getChartAccounts()
+            .pipe(map((chartAccountsList) => {
+            return chartAccountsList.find((chartAccounts) => chartAccounts.id === id);
+        }));
+    }
+}
+ChartAccountsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ChartAccountsService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+ChartAccountsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ChartAccountsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ChartAccountsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-accounts.service.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/services/http/chart-accounts/chart-accounts.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable, ReplaySubject } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { ChartAccountsCategoryEnum } from '../../../db/Enums/chart-accounts-category.enum';\nimport { ChartAccounts as ChartAccountBase } from '../../../db/Models/chart-accounts';\nimport { plainToClass } from 'class-transformer';\nimport { ChartAccounts } from '../../../models/chart-accounts/chart-accounts';\nimport { ChartAccountsHeading } from '../../../models/chart-accounts/chart-accounts-heading';\nimport { CHART_ACCOUNTS_CATEGORIES } from '../../../models/chart-accounts/chart-accounts-categories.const';\n\n/**\n * Chart accounts service\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class ChartAccountsService {\n  _chartAccounts: ChartAccounts[];\n  chartAccountsSubject: ReplaySubject<ChartAccounts[]> = new ReplaySubject<ChartAccounts[]>(1);\n\n  constructor(\n    private http: HttpClient,\n    @Inject('environment') private environment: any\n  ) {\n  }\n\n  /**\n   * get all parent and child chart accounts and group it\n   */\n  getChartAccounts(): Observable<ChartAccounts[]> {\n    if (!this._chartAccounts) {\n      this._chartAccounts = [];\n      this.http.get(`${this.environment.apiV2}/chart-accounts`)\n        .pipe(\n          map((response: ChartAccountBase[]) => {\n            return response.map((item: ChartAccountBase) => plainToClass(ChartAccounts, item));\n          })\n        )\n        .subscribe((chartAccounts: ChartAccounts[]) => {\n          this._chartAccounts = chartAccounts;\n          this.chartAccountsSubject.next(this._chartAccounts);\n        });\n    }\n\n    return this.chartAccountsSubject.asObservable();\n  }\n\n  /**\n   * Get list of chart accounts heading\n   * @param categories\n   */\n  getChartAccountsHeadings(categories: ChartAccountsCategoryEnum[] = CHART_ACCOUNTS_CATEGORIES.all): Observable<ChartAccountsHeading[]> {\n    return this.getChartAccounts()\n      .pipe(\n        map((chartAccounts: ChartAccounts[]) => {\n          const filteredChartAccounts: ChartAccounts[] = chartAccounts.filter((ca: ChartAccounts) => categories.includes(ca.category));\n          const headings: ChartAccountsHeading[] = [];\n\n          filteredChartAccounts.forEach((ca: ChartAccounts) => {\n            let heading: ChartAccountsHeading = headings.find((h: ChartAccountsHeading) => h.id === ca.heading?.id);\n\n            if (!heading) {\n              heading = plainToClass(ChartAccountsHeading, ca.heading);\n              heading.chartAccounts = [];\n              headings.push(heading);\n            }\n\n            heading.chartAccounts.push(ca);\n          });\n          return headings;\n        })\n      );\n  }\n\n  /**\n   * Get heading of chart accounts by it Id\n   * @param id\n   */\n  getHeadingByChartAccountsId(id: number): Observable<ChartAccountsHeading> {\n    return this.getChartAccountsById(id)\n      .pipe(\n        map((chartAccounts: ChartAccounts) => {\n          return chartAccounts.heading;\n        })\n      );\n  }\n\n  /**\n   * Get chart accounts by Id\n   * @param id\n   */\n  getChartAccountsById(id: number): Observable<ChartAccounts> {\n    return this.getChartAccounts()\n      .pipe(\n        map((chartAccountsList: ChartAccounts[]) => {\n          return chartAccountsList.find((chartAccounts: ChartAccounts) => chartAccounts.id === id);\n        })\n      );\n  }\n}\n"]}