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

218 lines
8.3 KiB
TypeScript
Raw Normal View History

import {Injectable} from '@angular/core';
import {BehaviorSubject, Observable, Subject} from 'rxjs';
2021-02-16 09:04:22 +01:00
import {HttpClient, HttpHeaders, HttpParams} from '@angular/common/http';
import {environment} from '@src/environments/environment';
import {first} from 'rxjs/operators';
import {ArgPair, Envelope, Phone, Syncable, User} from 'cic-client-meta';
import {AccountDetails} from '@app/_models';
import {LoggingService} from '@app/_services/logging.service';
import {TokenService} from '@app/_services/token.service';
2021-04-20 10:28:40 +02:00
import {AccountIndex} from '@app/_eth';
import {MutableKeyStore, PGPSigner, Signer} from '@app/_pgp';
2021-04-20 10:28:40 +02:00
import {RegistryService} from '@app/_services/registry.service';
import {CICRegistry} from 'cic-client';
import {AuthService} from './auth.service';
const vCard = require('vcard-parser');
@Injectable({
providedIn: 'root'
})
export class UserService {
headers: HttpHeaders = new HttpHeaders({'x-cic-automerge': 'client'});
keystore: MutableKeyStore;
signer: Signer;
2021-04-20 10:28:40 +02:00
registry: CICRegistry;
2021-02-17 11:00:38 +01:00
accountsMeta = [];
accounts: any = [];
2020-12-05 07:29:18 +01:00
private accountsList = new BehaviorSubject<any>(this.accounts);
accountsSubject = this.accountsList.asObservable();
actions: any = '';
private actionsList = new BehaviorSubject<any>(this.actions);
actionsSubject = this.actionsList.asObservable();
staff: any = '';
private staffList = new BehaviorSubject<any>(this.staff);
staffSubject = this.staffList.asObservable();
constructor(
2021-03-21 12:02:18 +01:00
private httpClient: HttpClient,
private loggingService: LoggingService,
2021-04-20 10:28:40 +02:00
private tokenService: TokenService,
private registryService: RegistryService,
private authService: AuthService,
) {
this.authService.init().then(() => {
this.keystore = authService.mutableKeyStore;
this.signer = new PGPSigner(this.keystore);
});
2021-04-20 10:28:40 +02:00
this.registry = registryService.getRegistry();
this.registry.load();
}
2021-02-08 12:47:07 +01:00
resetPin(phone: string): Observable<any> {
const params = new HttpParams().set('phoneNumber', phone);
2021-03-21 12:02:18 +01:00
return this.httpClient.get(`${environment.cicUssdUrl}/pin`, {params});
}
getAccountStatus(phone: string): any {
const params = new HttpParams().set('phoneNumber', phone);
2021-03-21 12:02:18 +01:00
return this.httpClient.get(`${environment.cicUssdUrl}/pin`, {params});
}
getLockedAccounts(offset: number, limit: number): any {
2021-03-21 12:02:18 +01:00
return this.httpClient.get(`${environment.cicUssdUrl}/accounts/locked/${offset}/${limit}`);
}
async changeAccountInfo(address: string, name: string, phoneNumber: string, age: string, type: string, bio: string, gender: string,
businessCategory: string, userLocation: string, location: string, locationType: string,
): Promise<any> {
let accountInfo: any = {
vcard: {
fn: [{}],
n: [{}],
tel: [{}]
},
location: {}
};
accountInfo.vcard.fn[0].value = name;
accountInfo.vcard.n[0].value = name.split(' ');
accountInfo.vcard.tel[0].value = phoneNumber;
accountInfo.products = [bio];
accountInfo.gender = gender;
accountInfo.age = age;
accountInfo.type = type;
accountInfo.category = businessCategory;
accountInfo.location.area = location;
accountInfo.location.area_name = userLocation;
accountInfo.location.area_type = locationType;
accountInfo.vcard = btoa(vCard.generate(accountInfo.vcard));
const accountKey = await User.toKey(address);
this.getAccountDetailsFromMeta(accountKey).pipe(first()).subscribe(async res => {
2021-03-21 12:02:18 +01:00
const syncableAccount: Syncable = Envelope.fromJSON(JSON.stringify(res)).unwrap();
2021-02-17 11:00:38 +01:00
let update = [];
for (const prop in accountInfo) {
update.push(new ArgPair(prop, accountInfo[prop]));
2021-02-17 11:00:38 +01:00
}
syncableAccount.update(update, 'client-branch');
await this.updateMeta(syncableAccount, accountKey, this.headers);
2021-02-17 11:00:38 +01:00
}, async error => {
this.loggingService.sendErrorLevelMessage('Can\'t find account info in meta service', this, {error});
const syncableAccount: Syncable = new Syncable(accountKey, accountInfo);
await this.updateMeta(syncableAccount, accountKey, this.headers);
2021-02-16 09:04:22 +01:00
});
return accountKey;
2021-02-17 11:00:38 +01:00
}
async updateMeta(syncableAccount: Syncable, accountKey: string, headers: HttpHeaders): Promise<any> {
const envelope = await this.wrap(syncableAccount , this.signer);
2021-02-17 11:00:38 +01:00
const reqBody = envelope.toJSON();
2021-03-21 12:02:18 +01:00
this.httpClient.put(`${environment.cicMetaUrl}/${accountKey}`, reqBody , { headers }).pipe(first()).subscribe(res => {
this.loggingService.sendInfoLevelMessage(`Response: ${res}`);
2021-02-16 09:04:22 +01:00
});
2021-02-08 12:47:07 +01:00
}
2020-12-05 07:29:18 +01:00
getAccounts(): void {
2021-03-21 12:02:18 +01:00
this.httpClient.get(`${environment.cicCacheUrl}/accounts`).pipe(first()).subscribe(res => this.accountsList.next(res));
}
2020-12-05 07:29:18 +01:00
getAccountById(id: number): Observable<any> {
2021-03-21 12:02:18 +01:00
return this.httpClient.get(`${environment.cicCacheUrl}/accounts/${id}`);
2020-12-05 07:29:18 +01:00
}
getActions(): void {
2021-03-21 12:02:18 +01:00
this.httpClient.get(`${environment.cicCacheUrl}/actions`).pipe(first()).subscribe(res => this.actionsList.next(res));
}
getActionById(id: string): any {
2021-03-21 12:02:18 +01:00
return this.httpClient.get(`${environment.cicCacheUrl}/actions/${id}`);
2020-12-05 07:29:18 +01:00
}
approveAction(id: string): Observable<any> {
2021-03-21 12:02:18 +01:00
return this.httpClient.post(`${environment.cicCacheUrl}/actions/${id}`, { approval: true });
2020-12-05 07:29:18 +01:00
}
revokeAction(id: string): Observable<any> {
2021-03-21 12:02:18 +01:00
return this.httpClient.post(`${environment.cicCacheUrl}/actions/${id}`, { approval: false });
2020-12-05 07:29:18 +01:00
}
getHistoryByUser(id: string): Observable<any> {
2021-03-21 12:02:18 +01:00
return this.httpClient.get(`${environment.cicCacheUrl}/history/${id}`);
2020-12-05 07:29:18 +01:00
}
getAccountDetailsFromMeta(userKey: string): Observable<any> {
2021-03-21 12:02:18 +01:00
return this.httpClient.get(`${environment.cicMetaUrl}/${userKey}`, { headers: this.headers });
}
getUser(userKey: string): any {
2021-03-21 12:02:18 +01:00
return this.httpClient.get(`${environment.cicMetaUrl}/${userKey}`, { headers: this.headers })
.pipe(first()).subscribe(async res => {
2021-03-21 12:02:18 +01:00
return Envelope.fromJSON(JSON.stringify(res)).unwrap();
});
}
2021-02-17 11:00:38 +01:00
wrap(syncable: Syncable, signer: Signer): Promise<Envelope> {
return new Promise<Envelope>(async (whohoo, doh) => {
2021-02-17 11:00:38 +01:00
syncable.setSigner(signer);
syncable.onwrap = async (env) => {
if (env === undefined) {
doh();
return;
}
whohoo(env);
};
await syncable.sign();
2021-02-17 11:00:38 +01:00
});
}
async loadAccounts(limit: number = 100, offset: number = 0): Promise<void> {
this.resetAccountsList();
2021-04-20 10:28:40 +02:00
const accountIndexAddress = await this.registry.getContractAddressByName('AccountRegistry');
const accountIndexQuery = new AccountIndex(accountIndexAddress);
const accountAddresses = await accountIndexQuery.last(await accountIndexQuery.totalAccounts());
this.loggingService.sendInfoLevelMessage(accountAddresses);
for (const accountAddress of accountAddresses.slice(offset, offset + limit)) {
await this.getAccountByAddress(accountAddress, limit);
}
}
async getAccountByAddress(accountAddress: string, limit: number = 100): Promise<Observable<AccountDetails>> {
let accountSubject = new Subject<any>();
this.getAccountDetailsFromMeta(await User.toKey(accountAddress)).pipe(first()).subscribe(async res => {
const account = Envelope.fromJSON(JSON.stringify(res)).unwrap();
this.accountsMeta.push(account);
const accountInfo = account.m.data;
accountInfo.balance = await this.tokenService.getTokenBalance(accountInfo.identities.evm['bloxberg:8996'][0]);
accountInfo.vcard = vCard.parse(atob(accountInfo.vcard));
this.accounts.unshift(accountInfo);
if (this.accounts.length > limit) {
this.accounts.length = limit;
}
this.accountsList.next(this.accounts);
accountSubject.next(accountInfo);
});
return accountSubject.asObservable();
}
async getAccountByPhone(phoneNumber: string, limit: number = 100): Promise<Observable<AccountDetails>> {
let accountSubject = new Subject<any>();
this.getAccountDetailsFromMeta(await Phone.toKey(phoneNumber)).pipe(first()).subscribe(async res => {
const response = Envelope.fromJSON(JSON.stringify(res)).unwrap();
const address = '0x' + response.m.data;
const account = await this.getAccountByAddress(address, limit);
account.subscribe(result => {
accountSubject.next(result);
});
});
return accountSubject.asObservable();
}
resetAccountsList(): void {
this.accounts = [];
this.accountsList.next(this.accounts);
}
searchAccountByName(name: string): any { return; }
}