taxtank-core 0.0.1 → 0.1.1

package/src/lib/services/loan/loan.service.ts

@@ -0,0 +1,166 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Loan as LoanBase } from '../../db/Models/loan';
+import { map } from 'rxjs/operators';
+import { replace } from '../../functions/array';
+import { HttpClient } from '@angular/common/http';
+import { BaseRestService } from '../base-rest.service';
+import { plainToClass } from 'class-transformer';
+import { Loan } from '../../models/loan/loan';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { BankAccount } from '../../models/bank/bank-account';
+import { AppEvent } from '../../models/event/app-event';
+import { LoanPayout } from '../../models/loan/loan-payout';
+
+/**
+ * Service that handling loans logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class LoanService extends BaseRestService<LoanBase, Loan> {
+  url: string = 'bank-accounts/loans';
+  modelClass: typeof Loan = Loan;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+    this.listenEvents();
+  }
+
+  /**
+   * Listen to Loans events
+   */
+  listenEvents(): void {
+    this.listenToAddedLoans();
+    this.listenToUpdatedBankAccounts();
+  }
+
+  listenToAddedLoans(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.BANK_ACCOUNT_CREATED)
+      .subscribe((bankAccounts: BankAccount[]) => {
+        // fetch loans when loan bank account created
+        if (bankAccounts.find(ba => !!ba.loan)) {
+          this.resetCache();
+        }
+      });
+  }
+
+  listenToUpdatedBankAccounts(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.BANK_ACCOUNT_UPDATED)
+      .subscribe((updatedBankAccount: BankAccount): void => {
+        if (!!updatedBankAccount.loan) {
+          this.resetCache();
+        }
+      });
+  }
+
+  /**
+   * Create Loan
+   */
+  add(model: Loan): Observable<Loan> {
+    return this.addBatch([model])
+      .pipe(
+        map((newLoan: Loan[]): Loan => {
+          return newLoan[0];
+        })
+      );
+  }
+
+  /**
+   * Updated loan
+   * @param loan
+   */
+  update(loan: Loan): Observable<Loan> {
+    return this.http.put(`${this.environment.apiV2}/${this.url}/${loan.id}`, loan)
+      .pipe(
+        map((updatedLoanBase: LoanBase) => {
+          const updatedLoan: Loan = plainToClass(Loan, updatedLoanBase);
+          // if loan type is NOT vehicle - fire EventDispatcher event
+          if (!updatedLoan.isVehicle()) {
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_UPDATED, null));
+          }
+
+          replace(this.cache, updatedLoan);
+          this.updateCache();
+          return updatedLoan;
+        })
+      );
+  }
+
+  /**
+   * Get list of vehicle loans
+   */
+  getVehicleLoans(): Observable<Loan[]> {
+    return this.get()
+      .pipe(
+        map((loans: Loan[]) => {
+          return loans.filter((loan: Loan) => loan.isVehicle());
+        })
+      );
+  }
+
+  /**
+   * Calculate loan payments
+   * @param loan
+   */
+  calculateLoanPayments(loan: Loan): Observable<any> {
+    return this.http.post(`${this.environment.apiV2}/${this.url}/calculation`, loan).pipe(
+      map((response: any) => {
+        return plainToClass(Loan, response);
+      })
+    );
+  }
+
+  /**
+   * Add new loan payout
+   * @param loan
+   * @param paidOutLoan
+   */
+  addPayoutLoan(loan: Loan, paidOutLoan: LoanPayout): Observable<any> {
+    return this.http.post(`${this.environment.apiV2}/loans/${loan.id}/payout`, paidOutLoan).pipe(
+      map((response: any) => {
+          loan.payout = plainToClass(LoanPayout, response);
+          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));
+          // reset cache to fetch loans with updated data
+          this.resetCache();
+        }
+      ));
+  }
+
+  /**
+   * Delete loan payout
+   * @param loan
+   * @param payout
+   */
+  deletePayoutLoan(loan: Loan, payout: LoanPayout): Observable<any> {
+    return this.http.delete(`${this.environment.apiV2}/loans/${loan.id}/payout/${payout.id}`).pipe(
+      map(() => {
+          loan.payout = null;
+          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));
+          // reset cache to fetch loans with updated data
+          this.resetCache();
+        }
+      ));
+  }
+
+  /**
+   * Update loan payout
+   * @param loan
+   * @param paidOutLoan
+   */
+  updatePayoutLoan(loan: Loan, paidOutLoan: LoanPayout): Observable<any> {
+    return this.http.put(`${this.environment.apiV2}/loans/${loan.id}/payout/${paidOutLoan.id}`, paidOutLoan).pipe(
+      map((response: any) => {
+          loan.payout = plainToClass(LoanPayout, response);
+          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.LOAN_PAYOUT_UPDATED, null));
+          // reset cache to fetch loans with updated data
+          this.resetCache();
+        }
+      ));
+  }
+}

package/src/lib/services/notification/notification.service.spec.ts

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

package/src/lib/services/notification/notification.service.ts

@@ -0,0 +1,60 @@
+import { Inject, Injectable } from '@angular/core';
+import { ServiceNotification as NotificationBase } from '../../db/Models/service-notification';
+import { Notification } from '../../models/notification/notification';
+import { HttpClient } from '@angular/common/http';
+import { IEventListener } from '../../interfaces/event-listener.interface';
+import { replace } from '../../functions/array';
+import { plainToClass } from 'class-transformer';
+import { BaseRestService } from '../base-rest.service';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { SseService } from '../event/sse.service';
+import { AppEvent } from '../../models/event/app-event';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import clone from 'lodash/clone'
+/**
+ * Service to handle service notifications logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class NotificationService extends BaseRestService<NotificationBase, Notification> implements IEventListener {
+  modelClass: typeof Notification = Notification;
+  url: string = 'service-notifications';
+  isHydra: boolean = true;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any,
+    private sseService: SseService
+  ) {
+    super(http, eventDispatcherService, environment);
+    this.listenEvents();
+  }
+
+  /**
+   * SSE and Event Dispatcher Services listeners
+   */
+  listenEvents(): void {
+    this.listenNotifications();
+  }
+
+  /**
+   * subscribe to new chat messages
+   */
+  private listenNotifications(): void {
+    this.sseService.on(`serviceNotification`).subscribe((notificationBase: NotificationBase): void => {
+      const notification: Notification = plainToClass(Notification, notificationBase);
+      const cache: Notification[] = clone(this.cache);
+      // update existing notification if read and add new notification if not read
+      if (notification.isRead) {
+        replace(cache, notification);
+      } else {
+        cache.unshift(notification);
+      }
+      this.cache = cache;
+      this.cacheSubject.next(this.cache);
+      this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.NOTIFICATION_ADDED, notification));
+    });
+  }
+}

package/src/lib/services/preloader/preloader.service.spec.ts

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

package/src/lib/services/preloader/preloader.service.ts

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { Endpoint } from '../../models/endpoint/endpoint';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class PreloaderService {
+  activePreloaders: BehaviorSubject<Endpoint[]> = new BehaviorSubject<Endpoint[]>([]);
+
+  constructor() { }
+
+  get(): Observable<Endpoint[]> {
+    return this.activePreloaders.asObservable();
+  }
+
+  add(endpoint: Endpoint): void {
+    const activePreloaders: Endpoint[] = this.activePreloaders.getValue();
+    activePreloaders.push(endpoint);
+    this.activePreloaders.next(activePreloaders);
+  }
+
+  delete(endpoint: Endpoint): void {
+    let activePreloaders: Endpoint[] = this.activePreloaders.getValue();
+    activePreloaders = activePreloaders.filter((preloader: Endpoint): boolean => preloader !== endpoint);
+    this.activePreloaders.next(activePreloaders);
+  }
+}

package/src/lib/services/property/corelogic.service.spec.ts

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

package/src/lib/services/property/corelogic.service.ts

@@ -0,0 +1,47 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { CorelogicSuggestion } from '../../models/property/corelogic-suggestion';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CorelogicService {
+  _accessToken: string;
+  accessTokenSubject: ReplaySubject<string> = new ReplaySubject<string>(1);
+
+  constructor(
+    private http: HttpClient,
+    @Inject('environment') private environment: any
+  ) {
+  }
+
+  getAccessToken(force: boolean = false): Observable<string> {
+    if (!this._accessToken || force) {
+      this.http.get(`${this.environment.coreLogicUrl}/access/oauth/token?grant_type=client_credentials&client_id=${this.environment.coreLogicId}&client_secret=${this.environment.coreLogicSecret}`)
+        .pipe(
+          map((response: any) => {
+            return response.access_token;
+          })
+        )
+        .subscribe((token: string) => {
+          this._accessToken = token;
+          this.accessTokenSubject.next(this._accessToken);
+        });
+    }
+
+    return this.accessTokenSubject.asObservable();
+  }
+
+  getSuggestions(query: string, country: string = 'au'): Observable<CorelogicSuggestion[]> {
+    // @TODO handle different countries in future
+    return this.http.get(`${this.environment.coreLogicUrl}/property/${country}/v2/suggest.json?q=${query}`)
+      .pipe(
+        map((response: any) => {
+          return response.suggestions.map((item: object) => plainToClass(CorelogicSuggestion, item));
+        })
+      );
+  }
+}

package/src/lib/services/property/property-calculation.service.spec.ts

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

package/src/lib/services/property/property-calculation.service.ts

@@ -0,0 +1,166 @@
+import { Injectable } from '@angular/core';
+import { combineLatest, Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { BankAccountCollection } from '../../collections/bank-account.collection';
+import { DepreciationCollection } from '../../collections/depreciation.collection';
+import { LoanCollection } from '../../collections/loan.collection';
+import { PropertyCollection } from '../../collections/property.collection';
+import { TransactionCollection } from '../../collections/transaction.collection';
+import { Property } from '../../models/property/property';
+import { BankAccount } from '../../models/bank/bank-account';
+
+/**
+ * Service with calculations methods for properties related with other entities.
+ * Logic here works like collections methods but for several entities
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class PropertyCalculationService {
+  getTaxPosition(transactions: TransactionCollection, depreciations: DepreciationCollection): number {
+    // @TODO hack: math abs added because we have mismatching of real values signs
+    return transactions.cashPosition - Math.abs(depreciations.claimAmount);
+  }
+
+  getTaxPosition$(
+    transactions$: Observable<TransactionCollection>,
+    depreciations$: Observable<DepreciationCollection>
+  ): Observable<number> {
+    return combineLatest([
+      transactions$,
+      depreciations$
+    ]).pipe(
+      map(([transactions, depreciations]: [TransactionCollection, DepreciationCollection]): number => {
+        return this.getTaxPosition(transactions, depreciations);
+      })
+    );
+  }
+
+  taxPositionGrowth(properties: PropertyCollection, transactions: TransactionCollection, depreciations: DepreciationCollection): number {
+    const taxPosition: number = this.getTaxPosition(transactions, depreciations);
+    // check if taxPosition = 0 to avoid division by zero
+    if (!taxPosition) {
+      return 0;
+    }
+
+    return (taxPosition - properties.forecastedTaxPosition) / taxPosition;
+  }
+
+  taxPositionGrowth$(
+    properties$: Observable<PropertyCollection>,
+    transactions$: Observable<TransactionCollection>,
+    depreciations$: Observable<DepreciationCollection>
+  ): Observable<number> {
+    return combineLatest([
+      properties$,
+      transactions$,
+      depreciations$
+    ]).pipe(
+      map(([properties, transactions, depreciations]: [PropertyCollection, TransactionCollection, DepreciationCollection]): number => {
+        return this.taxPositionGrowth(properties, transactions, depreciations);
+      })
+    );
+  }
+
+  getRentalReturn(properties: PropertyCollection, transactions: TransactionCollection): number {
+    return transactions.claimIncome / properties.marketValue;
+  }
+
+  getLoanAmount(properties: PropertyCollection, bankAccounts: BankAccountCollection, loans: LoanCollection): number {
+    return properties.items.reduce((totalAmount: number, property: Property): number => {
+      return totalAmount + bankAccounts.items
+        .reduce((propertyAmount: number, bankAccount: BankAccount): number => {
+          return propertyAmount + bankAccount.getPropertyPercentage(property.id) * (loans.getByBankAccountId(bankAccount.id)?.amount || 0);
+        }, 0);
+    }, 0);
+  }
+
+  getLoanValue(properties: PropertyCollection, bankAccounts: BankAccountCollection): number {
+    return properties.items.reduce((totalAmount: number, property: Property): number => {
+      return totalAmount + bankAccounts.items
+        .reduce((propertyAmount: number, bankAccount: BankAccount): number => {
+          return propertyAmount + bankAccount.getPropertyBalanceAmount(property.id);
+        }, 0);
+    }, 0);
+  }
+
+  /**
+   * LVR
+   */
+
+  getLvr(properties: PropertyCollection, bankAccounts: BankAccountCollection): number {
+    // Math abs is required for correct percentage calculation
+    return Math.abs(this.getLoanValue(properties, bankAccounts)) / properties.marketValue;
+  }
+
+  getLvr$(
+    properties$: Observable<PropertyCollection>,
+    bankAccounts$: Observable<BankAccountCollection>
+  ): Observable<number> {
+    return combineLatest([
+      properties$,
+      bankAccounts$
+    ]).pipe(
+      map(([properties, bankAccounts]: [PropertyCollection, BankAccountCollection]): number => {
+        return this.getLvr(properties, bankAccounts);
+      })
+    );
+  }
+
+  getLvrCommencement(properties: PropertyCollection, loans: LoanCollection, bankAccounts: BankAccountCollection): number {
+    // Math abs is required for correct percentage calculation
+    return Math.abs(this.getLoanAmount(properties, bankAccounts, loans)) / properties.purchasePrice;
+  }
+
+  getLvrCommencement$(
+    properties$: Observable<PropertyCollection>,
+    bankAccounts$: Observable<BankAccountCollection>,
+    loans$: Observable<LoanCollection>
+  ): Observable<number> {
+    return combineLatest([
+      properties$,
+      bankAccounts$,
+      loans$
+    ]).pipe(
+      map(([properties, bankAccounts, loans]: [PropertyCollection, BankAccountCollection, LoanCollection]): number => {
+        return this.getLvrCommencement(properties, loans, bankAccounts);
+      })
+    );
+  }
+
+  getLvrGrowth(properties: PropertyCollection, bankAccounts: BankAccountCollection, loans: LoanCollection): number {
+    const lvr: number = this.getLvr(properties, bankAccounts);
+    if (!lvr) {
+      // check if lvr = 0 to avoid division by zero
+      return 0;
+    }
+
+    return (lvr - this.getLvrCommencement(properties, loans, bankAccounts)) / lvr;
+  }
+
+  getLvrGrowth$(
+    properties$: Observable<PropertyCollection>,
+    bankAccounts$: Observable<BankAccountCollection>,
+    loans$: Observable<LoanCollection>
+  ): Observable<number> {
+    return combineLatest([
+      properties$,
+      bankAccounts$,
+      loans$
+    ]).pipe(
+      map(([properties, bankAccounts, loans]: [PropertyCollection, BankAccountCollection, LoanCollection]): number => {
+        return this.getLvrGrowth(properties, bankAccounts, loans);
+      })
+    );
+  }
+
+  getEquityPosition(properties: PropertyCollection, bankAccounts: BankAccountCollection): number {
+    // Math abs is required for correct percentage calculation
+    return properties.marketValue - Math.abs(this.getLoanValue(properties, bankAccounts));
+  }
+
+  getPurchaseEquity(properties: PropertyCollection, bankAccounts: BankAccountCollection, loans: LoanCollection): number {
+    // Math abs is required for correct percentage calculation
+    return properties.purchasePrice - Math.abs(this.getLoanAmount(properties, bankAccounts, loans));
+  }
+}

package/src/lib/services/property/property-capital-cost.service.ts

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { PropertyCapitalCost as PropertyCapitalCostBase } from '../../db/Models/property-capital-cost';
+import { plainToClass } from 'class-transformer';
+import { BaseRestService } from '../base-rest.service';
+import { PropertyCapitalCost } from '../../models/property/property-capital-cost';
+import { Property } from '../../models/property/property';
+
+/**
+ * Service to work with capital costs
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class PropertyCapitalCostService extends BaseRestService<PropertyCapitalCostBase, PropertyCapitalCost> {
+  url: string = 'capital-costs';
+  modelClass: typeof PropertyCapitalCost = PropertyCapitalCost;
+
+  /**
+   * Get property capital costs
+   * @param property which params will be taken for list of property capital costs
+   */
+  getByProperty(property: Property): Observable<PropertyCapitalCost[]> {
+    // get list of capital costs items
+    return this.get()
+      .pipe(
+        map((capitalCosts: PropertyCapitalCost[]) => {
+          // property capital costs array
+          return capitalCosts.map((capitalCost: PropertyCapitalCost) => {
+            // return new Property capital cost object with capital cost and amount
+            return plainToClass(PropertyCapitalCost, {
+              capitalCost,
+              amount: property.capitalCosts.find((existingCapitalCost: PropertyCapitalCost): boolean => {
+                return existingCapitalCost.capitalCost.id === capitalCost.id;
+              })?.amount || null
+            });
+          });
+        })
+      );
+  }
+}

package/src/lib/services/property/property-category.service.spec.ts

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

package/src/lib/services/property/property-category.service.ts

@@ -0,0 +1,15 @@
+import { Injectable } from '@angular/core';
+import { PropertyCategory as PropertyCategoryBase } from '../../db/Models/property-category';
+import { BaseRestService } from '../base-rest.service';
+import { PropertyCategory } from '../../models/property/property-category';
+
+/**
+ * Service for work with Property Categories
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class PropertyCategoryService extends BaseRestService<PropertyCategoryBase, PropertyCategory>{
+  modelClass: typeof PropertyCategory = PropertyCategory;
+  url: string = 'properties/categories';
+}

package/src/lib/services/property/property-document.service.spec.ts

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