cic-staff-client/src/app/pages/accounts/account-details/account-details.component.ts

import {ChangeDetectionStrategy, Component, OnInit, ViewChild} from '@angular/core';
import {MatTableDataSource} from '@angular/material/table';
import {SelectionModel} from '@angular/cdk/collections';
import {MatPaginator} from '@angular/material/paginator';
import {MatSort} from '@angular/material/sort';
import {BlockSyncService, LocationService, LoggingService, TokenService, TransactionService, UserService} from '@app/_services';
import {ActivatedRoute, Params, Router} from '@angular/router';
import {first} from 'rxjs/operators';
import {FormBuilder, FormGroup, Validators} from '@angular/forms';
import {CustomErrorStateMatcher} from '@app/_helpers';
import {Envelope, User} from 'cic-client-meta';
const vCard = require('vcard-parser');

@Component({
  selector: 'app-account-details',
  templateUrl: './account-details.component.html',
  styleUrls: ['./account-details.component.scss'],
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class AccountDetailsComponent implements OnInit {
  transactionsDataSource: MatTableDataSource<any>;
  transactionsDisplayedColumns = ['sender', 'recipient', 'value', 'created', 'type'];
  transactionsDefaultPageSize = 10;
  transactionsPageSizeOptions = [10, 20, 50, 100];
  @ViewChild('TransactionTablePaginator', {static: true}) transactionTablePaginator: MatPaginator;
  @ViewChild('TransactionTableSort', {static: true}) transactionTableSort: MatSort;

  userDataSource: MatTableDataSource<any>;
  userDisplayedColumns = ['name', 'phone', 'created', 'balance', 'location'];
  usersDefaultPageSize = 10;
  usersPageSizeOptions = [10, 20, 50, 100];
  @ViewChild('UserTablePaginator', {static: true}) userTablePaginator: MatPaginator;
  @ViewChild('UserTableSort', {static: true}) userTableSort: MatSort;

  historyDataSource: MatTableDataSource<any>;
  historyDisplayedColumns = ['user', 'action', 'staff', 'timestamp'];
  @ViewChild('HistoryTablePaginator', {static: true}) historyTablePaginator: MatPaginator;
  @ViewChild('HistoryTableSort', {static: true}) historyTableSort: MatSort;

  accountInfoForm: FormGroup;
  account: any;
  accountAddress: string;
  accountBalance: number;
  metaAccount: any;
  accounts: any[] = [];
  accountsType = 'all';
  date: string;
  time: number;
  isDisbursing = false;
  locations: any;
  transaction: any;
  transactions: any[];
  transactionsType = 'all';
  matcher = new CustomErrorStateMatcher();
  submitted: boolean = false;
  bloxbergLink: string;

  constructor(
    private formBuilder: FormBuilder,
    private locationService: LocationService,
    private transactionService: TransactionService,
    private userService: UserService,
    private route: ActivatedRoute,
    private router: Router,
    private tokenService: TokenService,
    private loggingService: LoggingService,
    private blockSyncService: BlockSyncService
  ) {
    this.accountInfoForm = this.formBuilder.group({
      name: ['', Validators.required],
      phoneNumber: ['', Validators.required],
      age: ['', Validators.required],
      type: ['', Validators.required],
      bio: ['', Validators.required],
      gender: ['', Validators.required],
      businessCategory: ['', Validators.required],
      userLocation: ['', Validators.required],
      location: ['', Validators.required],
      locationType: ['', Validators.required],
    });
    this.route.paramMap.subscribe(async (params: Params) => {
      this.accountAddress = params.get('id');
      this.bloxbergLink = 'https://blockexplorer.bloxberg.org/address/' + this.accountAddress + '/transactions';
      this.userService.getAccountDetailsFromMeta(await User.toKey(this.accountAddress)).pipe(first()).subscribe(res => {
        this.metaAccount = Envelope.fromJSON(JSON.stringify(res.body)).unwrap();
        this.account = this.metaAccount.m.data;
        this.loggingService.sendInfoLevelMessage(this.account);
        this.tokenService.getTokenBalance(this.accountAddress).then(r => this.accountBalance = r);
        this.account.vcard = vCard.parse(atob(this.account.vcard));
        this.accountInfoForm.patchValue({
          name: this.account.vcard?.fn[0].value,
          phoneNumber: this.account.vcard?.tel[0].value,
          age: this.account.age,
          type: this.account.type,
          bio: this.account.products,
          gender: this.account.gender,
          businessCategory: this.account.category,
          userLocation: this.account.location.area_name,
          location: this.account.location.area,
          locationType: this.account.location.area_type,
        });
      });
      this.userService.getHistoryByUser(this.accountAddress).pipe(first()).subscribe(response => {
        this.historyDataSource = new MatTableDataSource<any>(response.body);
        this.historyDataSource.paginator = this.historyTablePaginator;
        this.historyDataSource.sort = this.historyTableSort;
      });
      this.blockSyncService.blockSync(this.accountAddress);
    });
    this.userService.getAccounts();
    this.locationService.getLocations();
    this.locationService.locationsSubject.subscribe(locations => {
      this.locations = locations;
    });
  }

  ngOnInit(): void {
    this.userService.accountsSubject.subscribe(accounts => {
      this.userDataSource = new MatTableDataSource<any>(accounts);
      this.userDataSource.paginator = this.userTablePaginator;
      this.userDataSource.sort = this.userTableSort;
      this.accounts = accounts;
    });

    this.transactionService.transactionsSubject.subscribe(transactions => {
      this.transactionsDataSource = new MatTableDataSource<any>(transactions);
      this.transactionsDataSource.paginator = this.transactionTablePaginator;
      this.transactionsDataSource.sort = this.transactionTableSort;
      this.transactions = transactions;
    });

    const d = new Date();
    this.date = `${d.getDate()}/${d.getMonth()}/${d.getFullYear()}`;
  }

  addTransfer(): void {
    this.isDisbursing = !this.isDisbursing;
  }

  doTransactionFilter(value: string): void {
    this.transactionsDataSource.filter = value.trim().toLocaleLowerCase();
  }

  doUserFilter(value: string): void {
    this.userDataSource.filter = value.trim().toLocaleLowerCase();
  }

  doHistoryFilter(value: string): void {
    this.historyDataSource.filter = value.trim().toLocaleLowerCase();
  }

  viewTransaction(transaction): void {
    this.transaction = transaction;
  }

  viewAccount(account): void {
    this.router.navigateByUrl(`/accounts/${account.id}`);
  }

  get accountInfoFormStub(): any { return this.accountInfoForm.controls; }

  saveInfo(): void {
    this.submitted = true;
    if (this.accountInfoForm.invalid) { return; }
    this.userService.changeAccountInfo(
      this.account.address,
      this.accountInfoFormStub.name.value,
      this.accountInfoFormStub.phoneNumber.value,
      this.accountInfoFormStub.age.value,
      this.accountInfoFormStub.type.value,
      this.accountInfoFormStub.bio.value,
      this.accountInfoFormStub.gender.value,
      this.accountInfoFormStub.businessCategory.value,
      this.accountInfoFormStub.userLocation.value,
      this.accountInfoFormStub.location.value,
      this.accountInfoFormStub.locationType.value,
      this.metaAccount
    ).then(res => this.loggingService.sendInfoLevelMessage(`Response: ${res}`));
    this.submitted = false;
  }

  filterAccounts(): void {
    if (this.accountsType === 'all') {
      this.userService.accountsSubject.subscribe(accounts => {
        this.userDataSource.data = accounts;
        this.accounts = accounts;
      });
    } else {
      this.userDataSource.data = this.accounts.filter(account => account.type === this.accountsType);
    }
  }

  filterTransactions(): void {
    if (this.transactionsType === 'all') {
      this.transactionService.transactionsSubject.subscribe(transactions => {
        this.transactionsDataSource.data = transactions;
        this.transactions = transactions;
      });
    } else {
      this.transactionsDataSource.data = this.transactions.filter(transaction => transaction.type === this.transactionsType);
    }
  }

  resetPin(): void {
    this.userService.resetPin(this.account.phone).pipe(first()).subscribe(res => {
      this.loggingService.sendInfoLevelMessage(`Response: ${res.body}`);
    });
  }

  public trackByName(index, item): string {
    return item.name;
  }
}