cic-staff-client/src/app/_services/transaction.service.ts

import { Injectable } from '@angular/core';
import {HttpClient} from '@angular/common/http';
import {first, map} from 'rxjs/operators';
import {BehaviorSubject, Observable} from 'rxjs';
import {environment} from '../../environments/environment';
import {Conversion, Transaction} from '../_models';
import {User} from 'cic-client-meta';
import {UserService} from './user.service';
import {parse} from '../../assets/js/parse-vcard';

@Injectable({
  providedIn: 'root'
})
export class TransactionService {
  transactions: Transaction[] = [];
  conversions: Conversion[] = [];
  private transactionList = new BehaviorSubject<Transaction[]>(this.transactions);
  transactionsSubject = this.transactionList.asObservable();
  private conversionList = new BehaviorSubject<Conversion[]>(this.conversions);
  conversionsSubject = this.conversionList.asObservable();
  userInfo: any;

  constructor(
    private http: HttpClient,
    private userService: UserService
  ) { }

  getAllTransactions(offset: number, limit: number): Observable<any> {
    return this.http.get(`${environment.cicCacheUrl}/tx/${offset}/${limit}`)
      .pipe(map(response => {
        return response;
      }));
  }

  getAddressTransactions(address: string, offset: number, limit: number): Observable<any> {
    return this.http.get(`${environment.cicCacheUrl}/tx/${address}/${offset}/${limit}`)
      .pipe(map(response => {
        return response;
      }));
  }

  setTransaction(transaction, cacheSize: number): void {
    const cachedTransaction = this.transactions.find(cachedTx => cachedTx.tx.txHash === transaction.tx.txHash);
    if (cachedTransaction) { return; }
    this.getUser(transaction.from).then(() => {
      transaction.sender = this.userInfo;
      this.getUser(transaction.to).then(() => {
        transaction.recipient = this.userInfo;
        this.transactions.unshift(transaction);
        if (this.transactions.length > cacheSize) {
          this.transactions.length = cacheSize;
        }
        this.transactionList.next(this.transactions);
      });
    });
  }

  setConversion(conversion): void {
    const cachedConversion = this.conversions.find(cachedTx => cachedTx.tx.txHash === conversion.tx.txHash);
    if (cachedConversion) { return; }
    this.getUser(conversion.trader).then(() => {
      conversion.user = this.userInfo;
      this.conversions.push(conversion);
      this.conversionList.next(this.conversions);
    });
  }

  async getUser(address: string): Promise<void> {
    this.userService.getUser(await User.toKey(address)).pipe(first()).subscribe(res => {
      const vcard = parse(atob(res.vcard));
      res.vcard = vcard;
      this.userInfo = res;
    }, error => {
      console.log(error);
    });
  }
}