taxtank 0.1.0

package/projects/tt-core/src/lib/services/asset/assets.service.ts

@@ -0,0 +1,51 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { IAsset } from '../../interfaces';
+import { UserSwitcherService } from '../user';
+
+/**
+ * Service to work with assets (documents, receipts, e.t.c.)
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class AssetsService {
+  // client that was switched from manager account
+  impersonatedClient: string;
+
+  constructor(
+    private http: HttpClient,
+    private userSwitcherService: UserSwitcherService,
+    @Inject('environment') private environment: any
+  ) {
+    this.impersonatedClient = this.userSwitcherService.get();
+  }
+
+  /**
+   * Get asset link
+   * @param asset to get the link for
+   */
+  getLink(asset: IAsset): Observable<any> {
+    return this.http.get(`${this.environment.apiV2}/assets/${asset.type}/${asset.id}`);
+  }
+
+  /**
+   * Download asset
+   * @param asset which should be downloaded
+   * @TODO refactor
+   */
+  download(asset: IAsset): string {
+    return `${this.environment.apiV2}/assets/${asset.type}/${asset.id}/download?bearer=${localStorage.getItem('token')}${this.impersonatedClient ? `&_switch_user=${this.impersonatedClient}` : ''}`;
+  }
+
+  // @Todo refactor to event dispatcher
+  /**
+   * Delete asset
+   * @param entityId: id of asset main entity (property, folder, transaction, e.t.c.)
+   * @param asset which should be deleted
+   */
+  delete(entityId: number, asset: IAsset): any {
+    return this.http.delete(`${this.environment.apiV2}/${asset.entityType}/${entityId}/${asset.type}/${asset.id}`);
+  }
+}

package/projects/tt-core/src/lib/services/asset/index.ts

@@ -0,0 +1 @@
+export * from './assets.service';

package/projects/tt-core/src/lib/services/bank/bank-account-calculation.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { BankAccountCalculationService } from './bank-account-calculation.service';
+
+describe('BankAccountCalculationService', () => {
+  let service: BankAccountCalculationService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(BankAccountCalculationService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/bank/bank-account-calculation.service.ts

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import { BankAccountCollection, BankTransactionCollection, TransactionAllocationCollection } from '../../collections';
+import { BankAccount } from '../../models';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class BankAccountCalculationService {
+  /**
+   * Sum of bank accounts opening balances and their bank transactions allocated amounts
+   */
+  getTaxTankBalance(
+    bankAccounts: BankAccountCollection | BankAccount,
+    bankTransactions: BankTransactionCollection,
+    allocations: TransactionAllocationCollection
+  ): number {
+    // wrap in a collection if a single bank account was provided
+    const bankAccountCollection: BankAccountCollection = bankAccounts instanceof BankAccount ?
+      new BankAccountCollection([bankAccounts]) :
+      bankAccounts;
+
+    return bankTransactions.getByBankAccountsIds(bankAccountCollection.getIds()).getAllocatedAmount(allocations)
+      + bankAccountCollection.getOpeningBalance();
+  }
+
+  /**
+   * get difference between total loans amount and total cash amount
+   */
+  getNetPosition(
+    bankAccounts: BankAccountCollection,
+    bankTransactions: BankTransactionCollection,
+    allocations: TransactionAllocationCollection
+  ): number {
+    return bankAccounts.currentBalance - this.getTaxTankBalance(bankAccounts.getLoanAccounts(), bankTransactions, allocations);
+  }
+}

package/projects/tt-core/src/lib/services/bank/index.ts

@@ -0,0 +1 @@
+export * from './bank-account-calculation.service';

package/projects/tt-core/src/lib/services/data.service.ts

@@ -0,0 +1,61 @@
+import { Injectable } from '@angular/core';
+import { Collection } from '../collections';
+import { plainToClass } from 'class-transformer';
+import { AbstractModel } from '../db/Models';
+import clone from 'lodash/clone';
+
+@Injectable({
+  providedIn: 'root'
+})
+export abstract class DataService<BaseModel, Model extends AbstractModel, CollectionModel extends Collection<Model>> {
+  data: BaseModel[];
+
+  /**
+   * Model class for instances creating
+   */
+  abstract modelClass;
+
+  /**
+   * Collection Model class for instances creating
+   */
+  abstract collectionClass;
+
+  /**
+   * Cached array of service class instances
+   */
+  protected cache: CollectionModel;
+
+  /**
+   * @TODO use excludeExtraneousValues when all models refactored (exposed all needed properties)
+   * Create new instance of class
+   * @param model Single object or array from which will be created model instance(s)
+   */
+  protected createModelInstance(model: object): Model {
+    return plainToClass(this.modelClass, model);
+  }
+
+  protected createCollectionInstance(collectionClass: new (items: Model[]) => CollectionModel, data: any[]): CollectionModel {
+    return new collectionClass(data.map((item) => this.createModelInstance(item)));
+  }
+
+  /**
+   * never return cache directly to prevent update
+   */
+  getCache(): CollectionModel {
+    return clone(this.cache);
+  }
+
+  /**
+   * never return cache directly to prevent update
+   */
+  getCacheFirst(): Model {
+    return this.getCache()?.first;
+  }
+
+  /**
+   * @TODO vik any[] because of problems with base models extending abstractModel
+   */
+  setCache(data: any[]): void {
+    this.cache = this.createCollectionInstance(this.collectionClass, data);
+  }
+}

package/projects/tt-core/src/lib/services/event/event-dispatcher.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { EventDispatcherService } from './event-dispatcher.service';
+
+describe('EventDispatcherService', () => {
+  let service: EventDispatcherService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(EventDispatcherService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/event/event-dispatcher.service.ts

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import { AppEvent, AppEvent2, AppEventTypeEnum } from '../../models';
+import { Observable, Subject } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import { ObservableModel } from '../../db/Models';
+
+/**
+ * @TODO Alex (TT-1777): replace old logic with the new when all services ready
+ * @TODO Alex (TT-1777): rename old logic and keep it for custom events
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class EventDispatcherService {
+  private eventSubject: Subject<AppEvent<any>> = new Subject();
+  private eventSubject2: Subject<AppEvent2> = new Subject();
+
+  /**
+   * subscription to specific event type
+   */
+  on(eventType: AppEventTypeEnum | AppEventTypeEnum[]): Observable<any> {
+    return this.eventSubject.pipe(
+      filter((event: AppEvent<any>): boolean => [].concat(eventType).includes(event.type)),
+      map((event: AppEvent<any>): any => event.payload)
+    );
+  }
+
+  on2(...names: string[]): Observable<ObservableModel[]> {
+    return this.eventSubject2.pipe(
+      filter((event: AppEvent2): boolean => [].concat(names).includes(event.name)),
+      map((event: AppEvent2): any => event.items)
+    );
+  }
+
+  /**
+   * deliver new event
+   */
+  dispatch<T>(event: AppEvent<T>): void {
+    this.eventSubject.next(event);
+  }
+
+  dispatch2(event: AppEvent2): void {
+    this.eventSubject2.next(event);
+  }
+}

package/projects/tt-core/src/lib/services/event/index.ts

@@ -0,0 +1,2 @@
+export * from './event-dispatcher.service';
+export * from './sse.service';

package/projects/tt-core/src/lib/services/event/sse.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { SseService } from './sse.service';
+
+describe('SseService', () => {
+  let service: SseService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(SseService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/event/sse.service.ts

@@ -0,0 +1,44 @@
+import { Inject, Injectable, NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { EventSourcePolyfill } from 'event-source-polyfill/src/eventsource.min.js';
+import { JwtService } from 'taxtank-core/common';
+
+/**
+ * server sent events service
+ * https://symfony.com/doc/current/mercure.html
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class SseService {
+  constructor(
+    private zone: NgZone,
+    private jwtService: JwtService,
+    @Inject('environment') private environment: any
+  ) {
+  }
+
+  /**
+   * list to url for server events
+   */
+  on(topic: string): Observable<object> {
+    const url: URL = new URL(this.environment.mercureUrl);
+    url.searchParams.append('topic', this.jwtService.decodeToken().mercure.subscribe[0].replace('{+path}', topic));
+
+    return new Observable((observer) => {
+      const es: EventSourcePolyfill = new EventSourcePolyfill(url, {
+        headers: {
+          Authorization: 'Bearer ' + this.jwtService.getToken(),
+        }
+      });
+
+      es.onmessage = (event: MessageEvent): void => {
+        this.zone.run((): void => observer.next(event));
+      };
+    })
+      .pipe(
+        map((messageEvent: MessageEvent): object => JSON.parse(messageEvent.data))
+      );
+  }
+}

package/projects/tt-core/src/lib/services/export/export-formatter.service.ts

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import { ExportCell } from '../../models/export/export-cell';
+import { ExportCellTypeEnum } from '../../models/export/export-cell-type.enum';
+import { CurrencyPipe, DatePipe, PercentPipe } from '@angular/common';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ExportFormatterService {
+  constructor(private currencyPipe: CurrencyPipe, private percentPipe: PercentPipe, private datePipe: DatePipe) {}
+
+  format(rows: ExportCell[][]): string[][] {
+    return rows.map((row: ExportCell[]) => row.map((column: ExportCell) => {
+      switch (column.type) {
+        case ExportCellTypeEnum.DATE:
+          return this.datePipe.transform(column.value, 'dd/MM/yyyy').toString();
+        case ExportCellTypeEnum.CURRENCY:
+          return this.currencyPipe.transform(column.value).toString();
+        case ExportCellTypeEnum.PERCENT:
+          return this.percentPipe.transform(column.value).toString();
+        default:
+          return column.value.toString();
+      }})
+    );
+  }
+}

package/projects/tt-core/src/lib/services/export/index.ts

@@ -0,0 +1 @@
+export * from './export-formatter.service';

package/projects/tt-core/src/lib/services/firm/current-firm-branch.service.ts

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { FirmBranch } from '../../models';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CurrentFirmBranchService {
+  firmBranchIds$ = new BehaviorSubject<number[]>([]);
+
+  get(): Observable<number[]> {
+    return this.firmBranchIds$.asObservable();
+  }
+
+  getCache(): number[] {
+    return this.firmBranchIds$.getValue();
+  }
+
+  set(firmBranches: FirmBranch[]): void {
+    this.firmBranchIds$.next(firmBranches.map(branch => branch.id));
+  }
+}

package/projects/tt-core/src/lib/services/firm/index.ts

@@ -0,0 +1 @@
+export * from './current-firm-branch.service';

package/projects/tt-core/src/lib/services/header-title/header-title.service.spec.ts

@@ -0,0 +1,12 @@
+import { TestBed } from '@angular/core/testing';
+
+import { HeaderTitleService } from './header-title.service';
+
+describe('TitleServiceService', () => {
+  beforeEach(() => TestBed.configureTestingModule({}));
+
+  it('should be created', () => {
+    const service: HeaderTitleService = TestBed.get(HeaderTitleService);
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/header-title/header-title.service.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRoute, NavigationEnd, Router } from '@angular/router';
+import { Observable } from 'rxjs';
+import { filter, map, mergeMap } from 'rxjs/operators';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class HeaderTitleService {
+
+  constructor(
+    private router: Router,
+    private activatedRoute: ActivatedRoute,
+  ) {
+  }
+
+  handleTitle(): Observable<any> {
+    return this.router.events.pipe(
+      filter((event: any) => event instanceof NavigationEnd),
+      map(() => this.activatedRoute),
+      map((route: any) => {
+        while (route.firstChild) {
+          route = route.firstChild;
+        }
+        return route;
+      }),
+      filter((route: any) => route.outlet === 'primary'),
+      mergeMap((route: any) => route.data)
+    );
+  }
+}

package/projects/tt-core/src/lib/services/header-title/index.ts

@@ -0,0 +1 @@
+export * from './header-title.service';

package/projects/tt-core/src/lib/services/http/address/address.service.spec.ts

@@ -0,0 +1,12 @@
+import { TestBed } from '@angular/core/testing';
+
+import { AddressService } from './address.service';
+
+describe('AddressService', () => {
+  beforeEach(() => TestBed.configureTestingModule({}));
+
+  it('should be created', () => {
+    const service: AddressService = TestBed.get(AddressService);
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/address/address.service.ts

@@ -0,0 +1,34 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { Country } from '../../../models/address/country';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AddressService {
+  _countries: Country[];
+  countriesSubject: ReplaySubject<Country[]> = new ReplaySubject<Country[]>(1);
+
+  constructor(
+    private http: HttpClient,
+    @Inject('environment') private environment: any
+  ) { }
+
+  getCountries(): Observable<Country[]> {
+    if (!this._countries) {
+      this.http.get(`${this.environment.apiV2}/countries`)
+        .pipe(
+          map((response: object[]) => response.map((item: object) => plainToClass(Country, item)))
+        )
+        .subscribe((countries: Country[]) => {
+          this._countries = countries;
+          this.countriesSubject.next(countries);
+        });
+    }
+
+    return this.countriesSubject.asObservable();
+  }
+}

package/projects/tt-core/src/lib/services/http/address/index.ts

@@ -0,0 +1 @@
+export * from './address.service';

package/projects/tt-core/src/lib/services/http/aussie/aussie.service.ts

@@ -0,0 +1,26 @@
+import { Inject, Injectable } from '@angular/core';
+import { AussieAppointment, AussieStore, AussieStoreInterface } from '../../../models';
+import { RestMethod, RestService } from '../rest';
+import { Collection } from '../../../collections';
+import { Observable } from 'rxjs';
+
+/**
+ * Service that handling banks logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class AussieService extends RestService<AussieStoreInterface, AussieStore, Collection<AussieStore>> {
+  modelClass: typeof AussieStore = AussieStore;
+  collectionClass: typeof Collection = Collection;
+  endpointUri = 'aussie/stores';
+  disabledMethods: RestMethod[] = ['post', 'postBatch', 'put', 'putBatch', 'delete', 'deleteBatch'];
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+  }
+
+  postAppointment(): Observable<any> {
+    return this.http.delete(`${this.environment.apiV2}/aussie/appointments`);
+  }
+}

package/projects/tt-core/src/lib/services/http/aussie/index.ts

@@ -0,0 +1 @@
+export * from './aussie.service';

package/projects/tt-core/src/lib/services/http/bank/bank-account/bank-account.service.spec.ts

@@ -0,0 +1,12 @@
+import { TestBed } from '@angular/core/testing';
+
+import { BankAccountService } from './bank-account.service';
+
+describe('BankAccountService', () => {
+  beforeEach(() => TestBed.configureTestingModule({}));
+
+  it('should be created', () => {
+    const service: BankAccountService = TestBed.get(BankAccountService);
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/bank/bank-account/bank-account.service.ts

@@ -0,0 +1,115 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { BankAccount as BankAccountBase } from '../../../../db/Models';
+import {
+  AppEventTypeEnum,
+  BankAccount,
+  BankConnection,
+  BankTransaction,
+  Notification,
+  PropertyShare
+} from '../../../../models';
+import { RestMethod, RestService } from '../../rest';
+import { IEventListener } from '../../../../interfaces';
+import { BankAccountCollection } from '../../../../collections';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { EventDispatcherService, SseService } from '../../../event';
+import { HttpClient } from '@angular/common/http';
+import { BankAccountStatusEnum } from '../../../../db/Enums';
+import { UserRolesEnum } from 'taxtank-core/common';
+import { UserEventTypeTypeEnum } from '../../../../db/Enums/user-event-type-type.enum';
+
+/**
+ * Service that handling user's bank accounts logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class BankAccountService extends RestService<BankAccountBase, BankAccount, BankAccountCollection> implements IEventListener {
+  endpointUri = 'bank-accounts';
+  modelClass: typeof BankAccount = BankAccount;
+  collectionClass: typeof BankAccountCollection = BankAccountCollection;
+  disabledMethods: RestMethod[] = ['post', 'putBatch', 'delete', 'deleteBatch'];
+  roles = [UserRolesEnum.WORK_TANK, UserRolesEnum.PROPERTY_TANK, UserRolesEnum.SOLE_TANK, UserRolesEnum.MONEY_TANK];
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    protected sseService: SseService,
+    @Inject('environment') protected environment: any,
+  ) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  getActive() {
+    return this.getBy('status', BankAccountStatusEnum.ACTIVE);
+  }
+
+  /**
+   * Listen system notifications and update cache when got basiq notification received
+   */
+  listenEvents(): void {
+    this.listenToEventDispatcherChanges();
+    // @TODO why?
+    this.listenCSE(BankTransaction, this.refreshCache, ['post', 'delete']);
+    this.listenCSE(PropertyShare, this.refreshCache, ['put']);
+    this.listenCSE(BankConnection, this.refreshCache, ['post']);
+    this.listenNotifications();
+    // this.listenConnections();
+  }
+
+  /**
+   * Update bank account current balance
+   * @TODO Vik: refactor once backend updated (should be separated endpoint for BankAccountBalance entity)
+   */
+  updateCurrentBalance(bankAccount: BankAccount): Observable<BankAccount> {
+    return this.http.put(`${this.apiUrl}/${bankAccount.id}/balance`, bankAccount)
+      .pipe(
+        map((response: object) => {
+          const updatedBankAccount: BankAccount = plainToClass(BankAccount, response);
+          this.handleResponse([updatedBankAccount], 'put');
+
+          return updatedBankAccount;
+        })
+      );
+  }
+
+  /**
+   * Listen to EventDispatcherService events
+   */
+  private listenToEventDispatcherChanges(): void {
+    this.eventDispatcherService.on([
+      AppEventTypeEnum.LOAN_PAYOUT_UPDATED,
+      AppEventTypeEnum.BANK_TRANSACTIONS_ADDED
+    ]).subscribe(() => {
+      this.refreshCache();
+    });
+  }
+
+  /**
+   * @TODO remove when TT-3826 is ready
+   * manualConnection moved to basiq, old manual bankAccounts closed to let user add automated bankAccounts (because there is no reliable way to merge)
+   */
+  private listenConnections(): void {
+    this.sseService.on(`bankConnections`).subscribe(() => {
+      this.refreshCache();
+    });
+  }
+
+  private listenNotifications(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.NOTIFICATION_ADDED).subscribe((notification: Notification) => {
+      const events = [
+        UserEventTypeTypeEnum.BASIQ_NEW_ACCOUNTS,
+        UserEventTypeTypeEnum.BASIQ_FIRST_IMPORT_COMPLETE,
+        UserEventTypeTypeEnum.BASIQ_AUTHORIZATION_FAIL,
+      ];
+
+      if (!notification.isRead && events.includes(notification.eventType)) {
+        // @TODO TT-3826 move to unified mercure event
+        this.refreshCache();
+      }
+    });
+  }
+}

package/projects/tt-core/src/lib/services/http/bank/bank-account/index.ts

@@ -0,0 +1 @@
+export * from './bank-account.service';

package/projects/tt-core/src/lib/services/http/bank/bank-connection/bank-connection-messages.enum.ts

@@ -0,0 +1,25 @@
+export enum BankConnectionMessagesEnum {
+  ACTIVATE = 'Live bank feeds are deactivated, activate to start receiving daily bank transactions',
+  ACTIVATED = 'Bank transactions will be delivered daily',
+  DEACTIVATE = 'Deactivate to stop receiving daily bank transactions',
+  CONFIRM_DEACTIVATE = 'We are unable to deliver daily bank transactions to deactivated banks',
+  DEACTIVATED = 'Your live bank feeds are deactivated',
+  RECONNECT = 'There has been an issue with your bank connection. Please reconnect to continue receiving bank transactions',
+  INVALID = 'There has been an issue with your bank connection. Please reconnect to continue receiving bank transactions',
+  INACTIVE = 'This bank is no longer available via Open Banking (commonly due to a merger). Please contact your bank or TaxTank Support for further information.',
+  UPGRADE = 'Upgrade needed from traditional feeds to an Open Banking connection to continue receiving bank transactions',
+  CONFIRM_UPGRADE = 'Upgrading to open banking improves stability and data integrity',
+  AUTOMATE = 'Upgrade from manual imports to an Open Banking connection to receive daily bank transactions',
+  CONFIRM_AUTOMATE = 'When you upgrade we will deactivate your manual bank and create a new bank in TaxTank with live transactions delivered daily. Manual banks can still be viewed at any time',
+  MANAGE = 'Select more banks to share with TaxTank',
+  CONFIRM_MANAGE = 'Reconnect your bank to select more accounts to share with TaxTank',
+  PENDING = 'We are organising banks and accounts, we will let you know when you are good to go',
+  INVALID_CREDENTIALS = 'Invalid credentials',
+  WRONG_LOGIN_DATA = 'Please enter the login you used before',
+  LOGIN_SUCCESS = 'Login success, importing financial data',
+  ACCOUNTS_RETRIEVED = 'Financial data received, you can add bank accounts now',
+  JOB_ID_RECEIVED = 'Receiving information from bank',
+  TEMPORARY_UNAVAILABLE = 'The bank is temporarily unavailable, please check back later',
+  EXPIRING = 'Access to receiving data from this bank expires soon. To ensure uninterrupted access to your bank transactions and continue sharing data for another term, please Reauthorise',
+  EXPIRED = 'Your bank has disconnected because your Access to receiving data from this bank has expired. Please Reauthorise to continue sharing'
+}

package/projects/tt-core/src/lib/services/http/bank/bank-connection/bank-connection.service.spec.ts

@@ -0,0 +1,12 @@
+import { TestBed } from '@angular/core/testing';
+
+import { BankConnectionService } from './bank-connection.service';
+
+describe('BankConnectionService', () => {
+  beforeEach(() => TestBed.configureTestingModule({}));
+
+  it('should be created', () => {
+    const service: BankConnectionService = TestBed.get(BankConnectionService);
+    expect(service).toBeTruthy();
+  });
+});