477 lines
12 KiB
TypeScript
477 lines
12 KiB
TypeScript
/*
|
|
This file is part of TALER
|
|
(C) 2016 GNUnet e.V.
|
|
|
|
TALER is free software; you can redistribute it and/or modify it under the
|
|
terms of the GNU General Public License as published by the Free Software
|
|
Foundation; either version 3, or (at your option) any later version.
|
|
|
|
TALER is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
|
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along with
|
|
TALER; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
|
|
*/
|
|
|
|
|
|
/**
|
|
* Popup shown to the user when they click
|
|
* the Taler browser action button.
|
|
*
|
|
* @author Florian Dold
|
|
*/
|
|
|
|
|
|
"use strict";
|
|
|
|
import {substituteFulfillmentUrl} from "../lib/wallet/helpers";
|
|
import BrowserClickedEvent = chrome.browserAction.BrowserClickedEvent;
|
|
import {HistoryRecord, HistoryLevel} from "../lib/wallet/wallet";
|
|
import {
|
|
AmountJson, WalletBalance, Amounts,
|
|
WalletBalanceEntry
|
|
} from "../lib/wallet/types";
|
|
import {abbrev, prettyAmount} from "../lib/wallet/renderHtml";
|
|
|
|
declare var i18n: any;
|
|
|
|
function onUpdateNotification(f: () => void) {
|
|
let port = chrome.runtime.connect({name: "notifications"});
|
|
port.onMessage.addListener((msg, port) => {
|
|
f();
|
|
});
|
|
}
|
|
|
|
|
|
class Router extends preact.Component<any,any> {
|
|
static setRoute(s: string): void {
|
|
window.location.hash = s;
|
|
}
|
|
|
|
static getRoute(): string {
|
|
// Omit the '#' at the beginning
|
|
return window.location.hash.substring(1);
|
|
}
|
|
|
|
static onRoute(f: any): () => void {
|
|
Router.routeHandlers.push(f);
|
|
return () => {
|
|
let i = Router.routeHandlers.indexOf(f);
|
|
this.routeHandlers = this.routeHandlers.splice(i, 1);
|
|
}
|
|
}
|
|
|
|
static routeHandlers: any[] = [];
|
|
|
|
componentWillMount() {
|
|
console.log("router mounted");
|
|
window.onhashchange = () => {
|
|
this.setState({});
|
|
for (let f of Router.routeHandlers) {
|
|
f();
|
|
}
|
|
}
|
|
}
|
|
|
|
componentWillUnmount() {
|
|
console.log("router unmounted");
|
|
}
|
|
|
|
|
|
render(props: any, state: any): JSX.Element {
|
|
let route = window.location.hash.substring(1);
|
|
console.log("rendering route", route);
|
|
let defaultChild: JSX.Element|null = null;
|
|
for (let child of props.children) {
|
|
if (child.attributes["default"]) {
|
|
defaultChild = child;
|
|
}
|
|
if (child.attributes["route"] == route) {
|
|
return <div>{child}</div>;
|
|
}
|
|
}
|
|
if (defaultChild == null) {
|
|
throw Error("unknown route");
|
|
}
|
|
console.log("rendering default route");
|
|
Router.setRoute(defaultChild.attributes["route"]);
|
|
return <div>{defaultChild}</div>;
|
|
}
|
|
}
|
|
|
|
export function main() {
|
|
console.log("popup main");
|
|
|
|
let el = (
|
|
<div>
|
|
<WalletNavBar />
|
|
<div style="margin:1em">
|
|
<Router>
|
|
<WalletBalanceView route="/balance" default/>
|
|
<WalletHistory route="/history"/>
|
|
<WalletDebug route="/debug"/>
|
|
</Router>
|
|
</div>
|
|
</div>
|
|
);
|
|
|
|
preact.render(el, document.getElementById("content")!);
|
|
}
|
|
|
|
interface TabProps extends preact.ComponentProps {
|
|
target: string;
|
|
}
|
|
|
|
function Tab(props: TabProps) {
|
|
let cssClass = "";
|
|
if (props.target == Router.getRoute()) {
|
|
cssClass = "active";
|
|
}
|
|
let onClick = (e: Event) => {
|
|
Router.setRoute(props.target);
|
|
e.preventDefault();
|
|
};
|
|
return (
|
|
<a onClick={onClick} href={props.target} className={cssClass}>
|
|
{props.children}
|
|
</a>
|
|
);
|
|
}
|
|
|
|
|
|
class WalletNavBar extends preact.Component<any,any> {
|
|
cancelSubscription: any;
|
|
|
|
componentWillMount() {
|
|
this.cancelSubscription = Router.onRoute(() => {
|
|
this.setState({});
|
|
});
|
|
}
|
|
|
|
componentWillUnmount() {
|
|
if (this.cancelSubscription) {
|
|
this.cancelSubscription();
|
|
}
|
|
}
|
|
|
|
render() {
|
|
console.log("rendering nav bar");
|
|
return (
|
|
<div class="nav" id="header">
|
|
<Tab target="/balance">
|
|
Balance
|
|
</Tab>
|
|
<Tab target="/history">
|
|
History
|
|
</Tab>
|
|
<Tab target="/debug">
|
|
Debug
|
|
</Tab>
|
|
</div>);
|
|
}
|
|
}
|
|
|
|
|
|
function ExtensionLink(props: any) {
|
|
let onClick = (e: Event) => {
|
|
chrome.tabs.create({
|
|
"url": chrome.extension.getURL(props.target)
|
|
});
|
|
e.preventDefault();
|
|
};
|
|
return (
|
|
<a onClick={onClick} href={props.target}>
|
|
{props.children}
|
|
</a>)
|
|
}
|
|
|
|
class WalletBalanceView extends preact.Component<any, any> {
|
|
balance: WalletBalance;
|
|
gotError = false;
|
|
|
|
componentWillMount() {
|
|
this.updateBalance();
|
|
|
|
onUpdateNotification(() => this.updateBalance());
|
|
}
|
|
|
|
updateBalance() {
|
|
chrome.runtime.sendMessage({type: "balances"}, (resp) => {
|
|
if (resp.error) {
|
|
this.gotError = true;
|
|
console.error("could not retrieve balances", resp);
|
|
this.setState({});
|
|
return;
|
|
}
|
|
this.gotError = false;
|
|
console.log("got wallet", resp);
|
|
this.balance = resp;
|
|
this.setState({});
|
|
});
|
|
}
|
|
|
|
renderEmpty(): JSX.Element {
|
|
let helpLink = (
|
|
<ExtensionLink target="pages/help/empty-wallet.html">
|
|
help
|
|
</ExtensionLink>
|
|
);
|
|
return <div>You have no balance to show. Need some {helpLink}
|
|
getting started?</div>;
|
|
}
|
|
|
|
formatPending(entry: WalletBalanceEntry): JSX.Element {
|
|
let incoming: JSX.Element | undefined;
|
|
let payment: JSX.Element | undefined;
|
|
|
|
console.log("available: ", entry.pendingIncoming ? prettyAmount(entry.available) : null);
|
|
console.log("incoming: ", entry.pendingIncoming ? prettyAmount(entry.pendingIncoming) : null);
|
|
|
|
if (Amounts.isNonZero(entry.pendingIncoming)) {
|
|
incoming = (
|
|
<span>
|
|
<span style="color: darkgreen">
|
|
{"+"}
|
|
{prettyAmount(entry.pendingIncoming)}
|
|
</span>
|
|
{" "}
|
|
incoming
|
|
</span>);
|
|
}
|
|
|
|
if (Amounts.isNonZero(entry.pendingPayment)) {
|
|
payment = (
|
|
<span>
|
|
<span style="color: darkblue">
|
|
{prettyAmount(entry.pendingPayment)}
|
|
</span>
|
|
{" "}
|
|
being spent
|
|
</span>);
|
|
}
|
|
|
|
let l = [incoming, payment].filter((x) => x !== undefined);
|
|
if (l.length == 0) {
|
|
return <span />;
|
|
}
|
|
|
|
if (l.length == 1) {
|
|
return <span>({l})</span>
|
|
}
|
|
return <span>({l[0]}, {l[1]})</span>;
|
|
|
|
}
|
|
|
|
render(): JSX.Element {
|
|
let wallet = this.balance;
|
|
if (this.gotError) {
|
|
return i18n`Error: could not retrieve balance information.`;
|
|
}
|
|
if (!wallet) {
|
|
return this.renderEmpty();
|
|
}
|
|
console.log(wallet);
|
|
let listing = Object.keys(wallet).map((key) => {
|
|
let entry: WalletBalanceEntry = wallet[key];
|
|
return (
|
|
<p>
|
|
{prettyAmount(entry.available)}
|
|
{" "}
|
|
{this.formatPending(entry)}
|
|
</p>
|
|
);
|
|
});
|
|
if (listing.length > 0) {
|
|
return <div>{listing}</div>;
|
|
}
|
|
|
|
return this.renderEmpty();
|
|
}
|
|
}
|
|
|
|
|
|
function formatHistoryItem(historyItem: HistoryRecord) {
|
|
const d = historyItem.detail;
|
|
const t = historyItem.timestamp;
|
|
console.log("hist item", historyItem);
|
|
switch (historyItem.type) {
|
|
case "create-reserve":
|
|
return (
|
|
<p>
|
|
{i18n.parts`Bank requested reserve (${abbrev(d.reservePub)}) for ${prettyAmount(
|
|
d.requestedAmount)}.`}
|
|
</p>
|
|
);
|
|
case "confirm-reserve": {
|
|
// FIXME: eventually remove compat fix
|
|
let exchange = d.exchangeBaseUrl ? URI(d.exchangeBaseUrl).host() : "??";
|
|
let amount = prettyAmount(d.requestedAmount);
|
|
let pub = abbrev(d.reservePub);
|
|
return (
|
|
<p>
|
|
{i18n.parts`Started to withdraw ${amount} from ${exchange} (${pub}).`}
|
|
</p>
|
|
);
|
|
}
|
|
case "offer-contract": {
|
|
let link = chrome.extension.getURL("view-contract.html");
|
|
let linkElem = <a href={link}>{abbrev(d.contractHash)}</a>;
|
|
let merchantElem = <em>{abbrev(d.merchantName, 15)}</em>;
|
|
return (
|
|
<p>
|
|
{i18n.parts`Merchant ${merchantElem} offered contract ${linkElem}.`}
|
|
</p>
|
|
);
|
|
}
|
|
case "depleted-reserve": {
|
|
let exchange = d.exchangeBaseUrl ? URI(d.exchangeBaseUrl).host() : "??";
|
|
let amount = prettyAmount(d.requestedAmount);
|
|
let pub = abbrev(d.reservePub);
|
|
return (<p>
|
|
{i18n.parts`Withdrew ${amount} from ${exchange} (${pub}).`}
|
|
</p>);
|
|
}
|
|
case "pay": {
|
|
let url = substituteFulfillmentUrl(d.fulfillmentUrl,
|
|
{H_contract: d.contractHash});
|
|
let merchantElem = <em>{abbrev(d.merchantName, 15)}</em>;
|
|
let fulfillmentLinkElem = <a href={url} onClick={openTab(url)}>view product</a>;
|
|
return (
|
|
<p>
|
|
{i18n.parts`Paid ${prettyAmount(d.amount)} to merchant ${merchantElem}. (${fulfillmentLinkElem})`}
|
|
</p>);
|
|
}
|
|
default:
|
|
return (<p>i18n`Unknown event (${historyItem.type})`</p>);
|
|
}
|
|
}
|
|
|
|
|
|
class WalletHistory extends preact.Component<any, any> {
|
|
myHistory: any[];
|
|
gotError = false;
|
|
|
|
componentWillMount() {
|
|
this.update();
|
|
onUpdateNotification(() => this.update());
|
|
}
|
|
|
|
update() {
|
|
chrome.runtime.sendMessage({type: "get-history"}, (resp) => {
|
|
console.log("got history response");
|
|
if (resp.error) {
|
|
this.gotError = true;
|
|
console.error("could not retrieve history", resp);
|
|
this.setState({});
|
|
return;
|
|
}
|
|
this.gotError = false;
|
|
console.log("got history", resp.history);
|
|
this.myHistory = resp.history;
|
|
this.setState({});
|
|
});
|
|
}
|
|
|
|
render(): JSX.Element {
|
|
console.log("rendering history");
|
|
let history: HistoryRecord[] = this.myHistory;
|
|
if (this.gotError) {
|
|
return i18n`Error: could not retrieve event history`;
|
|
}
|
|
|
|
if (!history) {
|
|
// We're not ready yet
|
|
return <span />;
|
|
}
|
|
|
|
let subjectMemo: {[s: string]: boolean} = {};
|
|
let listing: any[] = [];
|
|
for (let record of history.reverse()) {
|
|
if (record.subjectId && subjectMemo[record.subjectId]) {
|
|
continue;
|
|
}
|
|
if (record.level != undefined && record.level < HistoryLevel.User) {
|
|
continue;
|
|
}
|
|
subjectMemo[record.subjectId as string] = true;
|
|
|
|
let item = (
|
|
<div className="historyItem">
|
|
<div className="historyDate">
|
|
{(new Date(record.timestamp)).toString()}
|
|
</div>
|
|
{formatHistoryItem(record)}
|
|
</div>
|
|
);
|
|
|
|
listing.push(item);
|
|
}
|
|
|
|
if (listing.length > 0) {
|
|
return <div className="container">{listing}</div>;
|
|
}
|
|
return <p>{i18n`Your wallet has no events recorded.`}</p>
|
|
}
|
|
|
|
}
|
|
|
|
|
|
function reload() {
|
|
try {
|
|
chrome.runtime.reload();
|
|
window.close();
|
|
} catch (e) {
|
|
// Functionality missing in firefox, ignore!
|
|
}
|
|
}
|
|
|
|
function confirmReset() {
|
|
if (confirm("Do you want to IRREVOCABLY DESTROY everything inside your" +
|
|
" wallet and LOSE ALL YOUR COINS?")) {
|
|
chrome.runtime.sendMessage({type: "reset"});
|
|
window.close();
|
|
}
|
|
}
|
|
|
|
|
|
function WalletDebug(props: any) {
|
|
return (<div>
|
|
<p>Debug tools:</p>
|
|
<button onClick={openExtensionPage("popup/popup.html")}>
|
|
wallet tab
|
|
</button>
|
|
<button onClick={openExtensionPage("pages/show-db.html")}>
|
|
show db
|
|
</button>
|
|
<button onClick={openExtensionPage("pages/tree.html")}>
|
|
show tree
|
|
</button>
|
|
<br />
|
|
<button onClick={confirmReset}>
|
|
reset
|
|
</button>
|
|
<button onClick={reload}>
|
|
reload chrome extension
|
|
</button>
|
|
</div>);
|
|
}
|
|
|
|
|
|
function openExtensionPage(page: string) {
|
|
return function() {
|
|
chrome.tabs.create({
|
|
"url": chrome.extension.getURL(page)
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
function openTab(page: string) {
|
|
return function() {
|
|
chrome.tabs.create({
|
|
"url": page
|
|
});
|
|
}
|
|
}
|