taxtank-core 0.1.0 → 0.1.1

package/src/lib/models/user-event/user-event-setting-field.enum.ts

@@ -0,0 +1,8 @@
+/**
+ * Enum with user event setting fields
+ */
+export enum UserEventSettingFieldEnum {
+  BY_EMAIL = 'byEmail',
+  BY_NOTIFICATION = 'byNotification',
+  FREQUENCY = 'frequency'
+}

package/src/lib/models/user-event/user-event-setting.ts

@@ -0,0 +1,11 @@
+import { UserEventSetting as UserEventSettingBase } from '../../db/Models/user-event-setting';
+import { UserEventType } from './user-event-type';
+import { Exclude, Type } from 'class-transformer';
+
+export class UserEventSetting extends UserEventSettingBase {
+  @Type(() => UserEventType)
+  userEventType: UserEventType;
+  // flag indicates that the setting is updating  now saved or not
+  @Exclude({ toPlainOnly: true })
+  isUpdating?: boolean = false;
+}

package/src/lib/models/user-event/user-event-type.ts

@@ -0,0 +1,22 @@
+import { UserEventType as UserEventTypeBase } from '../../db/Models/user-event-type';
+import { UserEventCategory } from './user-event-category';
+import { UserEventCategoryEnum } from './user-event-category.enum';
+import { Expose, plainToClass, Transform, Type } from 'class-transformer';
+
+export class UserEventType extends UserEventTypeBase {
+  @Expose({ toClassOnly: true })
+  @Transform(({obj}) => {
+    switch (true) {
+      case String(obj.type).startsWith('1'):
+        return plainToClass(UserEventCategory, {name: 'User\'s events', type: UserEventCategoryEnum.USER});
+      case String(obj.type).startsWith('2'):
+        return plainToClass(UserEventCategory, {name: 'Co-owner\'s events', type: UserEventCategoryEnum.CO_OWNER});
+      case String(obj.type).startsWith('3'):
+        return plainToClass(UserEventCategory, {name: 'Firm\'s events', type: UserEventCategoryEnum.FIRM});
+      default:
+        return plainToClass(UserEventCategory, {name: 'Basiq events', type: UserEventCategoryEnum.BASIQ});
+    }
+  })
+  @Type(() => UserEventCategory)
+  category: UserEventCategory;
+}

package/src/lib/services/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/src/lib/services/address/address.service.ts

@@ -0,0 +1,36 @@
+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) => {
+            return response['hydra:member'].map((item: object) => plainToClass(Country, item));
+          })
+        )
+        .subscribe((countries: Country[]) => {
+          this._countries = countries;
+          this.countriesSubject.next(countries);
+        });
+    }
+
+    return this.countriesSubject.asObservable();
+  }
+}

package/src/lib/services/asset/assets.service.spec.ts

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

package/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/asset.interface';
+import { UserSwitcherService } from '../user/user-switcher.service';
+
+/**
+ * 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/src/lib/services/auth/auth.service.ts

@@ -0,0 +1,48 @@
+import { BehaviorSubject } from 'rxjs';
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { JwtService } from './jwt.service';
+import { map } from 'rxjs/operators';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AuthService {
+  isLoggedInSubject: BehaviorSubject<boolean>;
+
+  constructor(
+    private http: HttpClient,
+    private jwtService: JwtService,
+    @Inject('environment') private environment: any
+  ) {
+    this.isLoggedInSubject = new BehaviorSubject(!this.jwtService.isTokenExpired());
+  }
+
+  setAuth(response: any) {
+    this.jwtService.saveTokens(response);
+    this.isLoggedInSubject.next(true);
+  }
+
+  login(username: string, password: string) {
+    return this.http.post(`${this.environment.apiV2}/login_check`, {username, password}).pipe(
+      map((response: any) => {
+        this.setAuth(response);
+        return response;
+      })
+    );
+  }
+
+  refresh(refreshToken: string) {
+    return this.http.post(`${this.environment.apiV2}/token/refresh`, { refreshToken }).pipe(
+      map((response: any) => {
+        this.setAuth(response);
+        return response;
+      })
+    );
+  }
+
+  logoutFront(url: string = '/login'): void {
+    localStorage.clear();
+    location.replace(url);
+  }
+}

package/src/lib/services/auth/jwt.service.ts

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import { JwtHelperService } from '@auth0/angular-jwt';
+import { User } from '../../models/user/user';
+
+const NAME_TOKEN = 'token';
+const NAME_REFRESH_TOKEN = 'refreshToken';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class JwtService extends JwtHelperService {
+  getToken(): string {
+    return localStorage[NAME_TOKEN];
+  }
+
+  getRefreshToken(): string {
+    return localStorage[NAME_REFRESH_TOKEN];
+  }
+
+  saveTokens(tokens: { token: string, refreshToken: string }): void {
+    localStorage[NAME_TOKEN] = tokens.token;
+    localStorage[NAME_REFRESH_TOKEN] = tokens.refreshToken;
+  }
+
+  destroyTokens(): void {
+    localStorage.removeItem(NAME_TOKEN);
+    localStorage.removeItem(NAME_REFRESH_TOKEN);
+  }
+
+  getUser(): User {
+    return this.decodeToken<User>();
+  }
+
+  isMe(userId: number): boolean {
+    return this.getUser().id === userId;
+  }
+}

package/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/src/lib/services/bank/bank-account-calculation.service.ts

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import { BankAccountCollection } from '../../collections/bank-account.collection';
+import { BankTransactionCollection } from '../../collections/bank-transaction.collection';
+import { TransactionAllocationCollection } from '../../collections/transaction-allocation.collection';
+import { BankTransactionCalculationService } from './bank-transaction-calculation.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class BankAccountCalculationService {
+  constructor(
+    private bankTransactionCalculationService: BankTransactionCalculationService
+  ) {
+  }
+
+  /**
+   * Sum of bank accounts opening balances and their bank transactions allocated amounts
+   */
+  getTaxTankBalance(
+    bankAccounts: BankAccountCollection,
+    bankTransactions: BankTransactionCollection,
+    allocations: TransactionAllocationCollection
+  ): number {
+    return bankAccounts.getOpeningBalance() +
+      this.bankTransactionCalculationService.getAllocatedAmount(bankTransactions.getByBankAccountsIds(bankAccounts.getIds()), allocations);
+  }
+
+  /**
+   * 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/src/lib/services/bank/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/src/lib/services/bank/bank-account.service.ts

@@ -0,0 +1,120 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { BankAccount as BankAccountBase } from '../../db/Models/bank-account';
+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 { EventDispatcherService } from '../event/event-dispatcher.service';
+import { AppEvent } from '../../models/event/app-event';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+
+/**
+ * Service that handling user's bank accounts logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class BankAccountService extends BaseRestService<BankAccountBase, BankAccount> {
+  // api url parameter for bank accounts
+  url: string = 'bank-accounts';
+  modelClass = BankAccount;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+    this.listenEvents();
+  }
+
+  /**
+   * Listen system notifications and update cache when got basiq notification received
+   */
+  listenEvents(): void {
+    this.listenToPropertyOwnerUpdated();
+  }
+
+  /**
+   * Created manual bank account
+   * @param bankAccounts
+   * @param queryParams
+   */
+  addBatch(bankAccounts: BankAccount[], queryParams: object = {}): Observable<BankAccount[]> {
+    return this.http.post(`${this.environment.apiV2}/${this.url}`, bankAccounts)
+      .pipe(
+        map((newBankAccountsBase: BankAccountBase[]) => {
+          const newBankAccounts: BankAccount[] = newBankAccountsBase.map((bankAccountBase: BankAccountBase): BankAccount => plainToClass(BankAccount, bankAccountBase));
+          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_CREATED, newBankAccounts));
+          const tempCache: BankAccount[] = _.cloneDeep(this.cache);
+          tempCache.push(...newBankAccounts);
+          this.cache = tempCache;
+          this.updateCache();
+          return newBankAccounts;
+        })
+      );
+  }
+
+  /**
+   * Update bank account and fire event
+   */
+  update(bankAccount: BankAccount): Observable<BankAccount> {
+    return super.update(bankAccount).pipe(
+      map((updatedBankAccount: BankAccount) => {
+        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: BankAccount): Observable<any> {
+    return this.http.put(`${this.environment.apiV2}/${this.url}/${bankAccount.id}/opening-balances/${bankAccount.getCurrentYearBalance().id}`, bankAccount.getCurrentYearBalance())
+      .pipe(
+        map((response: object) => {
+          const tempCache: BankAccount[] = _.cloneDeep(this.cache);
+
+          replace(tempCache[tempCache.findIndex((ba: BankAccount) => ba.id === bankAccount.id)].balances, response);
+          this.cache = tempCache;
+          this.updateCache();
+        })
+      );
+  }
+
+  /**
+   * Update bank account current balance
+   */
+  updateCurrentBalance(bankAccount: BankAccount): Observable<BankAccount> {
+    return this.http.put(`${this.environment.apiV2}/${this.url}/${bankAccount.id}/balance`, bankAccount)
+      .pipe(
+        map((response: object) => {
+          const updatedBankAccount: BankAccount = plainToClass(BankAccount, response);
+
+          replace(this.cache, updatedBankAccount);
+          this.updateCache();
+
+          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_UPDATED, updatedBankAccount));
+          return updatedBankAccount;
+        })
+      );
+  }
+
+  /**
+   * Listen to EventDispatcherService event related to updated Property Owner Updated
+   */
+  private listenToPropertyOwnerUpdated(): void {
+    this.eventDispatcherService.on([AppEventTypeEnum.PROPERTY_OWNER_UPDATED, AppEventTypeEnum.LOAN_PAYOUT_UPDATED]).subscribe(() => {
+      this.fetch().subscribe((bankAccounts: BankAccount[]) => {
+        this.cache = bankAccounts;
+        this.updateCache();
+      });
+    });
+  }
+}

package/src/lib/services/bank/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();
+  });
+});

package/src/lib/services/bank/bank-connection.service.ts

@@ -0,0 +1,42 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { BankConnection as BankConnectionBase } from '../../db/Models/bank-connection';
+import { plainToClass } from 'class-transformer';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+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';
+
+/**
+ * BankConnection means user account at specific bank (usually each user has only one at the same bank)
+ * service handles BankConnection management
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class BankConnectionService extends BaseRestService<BankConnectionBase, BankConnection> {
+  modelClass = BankConnection;
+  url: string = 'bank-connections';
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+  }
+
+  post(bankConnection: BankConnection): Observable<BankConnection> {
+    return this.http.post(`${this.environment.apiV2}/${this.url}`, bankConnection)
+      .pipe(
+        map((bankConnectionBase: BankConnectionBase) => {
+          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_CONNECTION_ADDED, null));
+
+          return plainToClass(BankConnection, bankConnectionBase);
+        })
+      );
+  }
+}

package/src/lib/services/bank/bank-transaction-calculation.service.spec.ts

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

package/src/lib/services/bank/bank-transaction-calculation.service.ts

@@ -0,0 +1,71 @@
+import { Injectable } from '@angular/core';
+import { BankTransactionCollection } from '../../collections/bank-transaction.collection';
+import { BankTransaction } from '../../models/bank/bank-transaction';
+import { TransactionAllocationCollection } from '../../collections/transaction-allocation.collection';
+
+/**
+ * @TODO move to collection
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class BankTransactionCalculationService {
+  /**
+   * Sum of allocations for passed bank transactions
+   */
+  getAllocatedAmount(bankTransactions: BankTransactionCollection, allocations: TransactionAllocationCollection): number {
+    return allocations.getByBankTransactionsIds(bankTransactions.getIds()).amount;
+  }
+
+  /**
+   * Difference between total bank transactions amount and sum of allocations for passed bank transactions
+   */
+  getUnallocatedAmount(bankTransactionCollection: BankTransactionCollection, allocations: TransactionAllocationCollection) {
+    return bankTransactionCollection.getAmount() - allocations.amount;
+  }
+
+  /**
+   * Check if bank transaction is allocated
+   */
+  isAllocated(bankTransaction: BankTransaction, allocations: TransactionAllocationCollection): boolean {
+    return bankTransaction.amount === this.getAllocatedAmount(new BankTransactionCollection([bankTransaction]), allocations);
+  }
+
+  /**
+   * Get collection of allocated bank transactions
+   * @TODO Alex: consider to move to collection
+   */
+  getAllocatedBankTransactions(bankTransactions: BankTransactionCollection, allocations: TransactionAllocationCollection): BankTransactionCollection {
+    return new BankTransactionCollection(
+      bankTransactions.items.filter((bankTransaction: BankTransaction): boolean => {
+        return this.isAllocated(bankTransaction, allocations);
+      })
+    );
+  }
+
+  /**
+   * Get collection of unallocated bank transactions
+   * @TODO Alex: consider to move to collection
+   */
+  getUnallocatedBankTransactions(bankTransactions: BankTransactionCollection, allocations: TransactionAllocationCollection): BankTransactionCollection {
+    return new BankTransactionCollection(
+      bankTransactions.items.filter((bankTransaction: BankTransaction): boolean => {
+        return !this.isAllocated(bankTransaction, allocations);
+      })
+    );
+  }
+
+  /**
+   * Allocated sum of credit transactions
+   */
+  getCreditAmount(bankTransactions: BankTransactionCollection, allocations: TransactionAllocationCollection): number {
+    return allocations.getByBankTransactionsIds(bankTransactions.creditTransactions.getIds()).amount;
+  }
+
+  /**
+   * Allocated sum of debit transactions
+   */
+  getDebitAmount(bankTransactions: BankTransactionCollection, allocations: TransactionAllocationCollection): number {
+    return allocations.getByBankTransactionsIds(bankTransactions.debitTransactions.getIds()).amount;
+  }
+}

package/src/lib/services/bank/bank-transaction.service.spec.ts

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