rudimentary search

src/headless/taler-wallet-cli.ts

@@ -232,10 +232,15 @@ walletCli
   });
 
 walletCli
-  .subcommand("", "transactions", { help: "Show transactions." })
+  .subcommand("transactions", "transactions", { help: "Show transactions." })
+  .maybeOption("currency", ["--currency"], clk.STRING)
+  .maybeOption("search", ["--search"], clk.STRING)
   .action(async (args) => {
     await withWallet(args, async (wallet) => {
-      const pending = await wallet.getTransactions({});
+      const pending = await wallet.getTransactions({
+        currency: args.transactions.currency,
+        search: args.transactions.search,
+      });
       console.log(JSON.stringify(pending, undefined, 2));
     });
   });

src/operations/transactions.ts

@@ -75,10 +75,8 @@ function getRefundStats(
       Amounts.parseOrThrow(perm.refund_fee),
     ).amount;
     if (pr.refundsRefreshCost[rk]) {
-      amountEffective = Amounts.sub(
+      amountEffective = Amounts.sub(amountEffective, pr.refundsRefreshCost[rk])
-        amountEffective,
+        .amount;
-        pr.refundsRefreshCost[rk],
-      ).amount;
     }
   }
 
@@ -100,6 +98,32 @@ function getRefundStats(
   };
 }
 
+function shouldSkipCurrency(
+  transactionsRequest: TransactionsRequest | undefined,
+  currency: string,
+): boolean {
+  if (!transactionsRequest?.currency) {
+    return false;
+  }
+  return transactionsRequest.currency.toLowerCase() !== currency.toLowerCase();
+}
+
+function shouldSkipSearch(
+  transactionsRequest: TransactionsRequest | undefined,
+  fields: string[],
+): boolean {
+  if (!transactionsRequest?.search) {
+    return false;
+  }
+  const needle = transactionsRequest.search.trim();
+  for (const f of fields) {
+    if (f.indexOf(needle) >= 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
 /**
  * Retrive the full event history for this wallet.
  */
@@ -130,34 +154,44 @@ export async function getTransactions(
     async (tx) => {
       tx.iter(Stores.withdrawalGroups).forEach((wsr) => {
         if (
-          transactionsRequest?.currency &&
+          shouldSkipCurrency(
-          wsr.rawWithdrawalAmount.currency != transactionsRequest.currency
+            transactionsRequest,
+            wsr.rawWithdrawalAmount.currency,
+          )
         ) {
           return;
         }
-        if (wsr.rawWithdrawalAmount.currency)
+
-          if (wsr.timestampFinish) {
+        if (shouldSkipSearch(transactionsRequest, [])) {
-            transactions.push({
+          return;
-              type: TransactionType.Withdrawal,
+        }
-              amountEffective: Amounts.stringify(wsr.denomsSel.totalCoinValue),
+
-              amountRaw: Amounts.stringify(wsr.denomsSel.totalWithdrawCost),
+        if (transactionsRequest?.search)
-              confirmed: true,
+          if (wsr.rawWithdrawalAmount.currency)
-              exchangeBaseUrl: wsr.exchangeBaseUrl,
+            if (wsr.timestampFinish) {
-              pending: !wsr.timestampFinish,
+              transactions.push({
-              timestamp: wsr.timestampStart,
+                type: TransactionType.Withdrawal,
-              transactionId: makeEventId(
+                amountEffective: Amounts.stringify(
-                TransactionType.Withdrawal,
+                  wsr.denomsSel.totalCoinValue,
-                wsr.withdrawalGroupId,
+                ),
-              ),
+                amountRaw: Amounts.stringify(wsr.denomsSel.totalWithdrawCost),
-            });
+                confirmed: true,
-          }
+                exchangeBaseUrl: wsr.exchangeBaseUrl,
+                pending: !wsr.timestampFinish,
+                timestamp: wsr.timestampStart,
+                transactionId: makeEventId(
+                  TransactionType.Withdrawal,
+                  wsr.withdrawalGroupId,
+                ),
+              });
+            }
       });
 
       tx.iter(Stores.reserves).forEach((r) => {
-        if (
+        if (shouldSkipCurrency(transactionsRequest, r.currency)) {
-          transactionsRequest?.currency &&
+          return;
-          r.currency != transactionsRequest.currency
+        }
-        ) {
+        if (shouldSkipSearch(transactionsRequest, [])) {
           return;
         }
         if (r.reserveStatus !== ReserveRecordStatus.WAIT_CONFIRM_BANK) {
@@ -170,7 +204,9 @@ export async function getTransactions(
           type: TransactionType.Withdrawal,
           confirmed: false,
           amountRaw: Amounts.stringify(r.bankInfo.denomSel.totalWithdrawCost),
-          amountEffective: Amounts.stringify(r.bankInfo.denomSel.totalCoinValue),
+          amountEffective: Amounts.stringify(
+            r.bankInfo.denomSel.totalCoinValue,
+          ),
           exchangeBaseUrl: r.exchangeBaseUrl,
           pending: true,
           timestamp: r.timestampCreated,
@@ -184,11 +220,16 @@ export async function getTransactions(
 
       tx.iter(Stores.purchases).forEachAsync(async (pr) => {
         if (
-          transactionsRequest?.currency &&
+          shouldSkipCurrency(
-          pr.contractData.amount.currency != transactionsRequest.currency
+            transactionsRequest,
+            pr.contractData.amount.currency,
+          )
         ) {
           return;
         }
+        if (shouldSkipSearch(transactionsRequest, [pr.contractData.summary])) {
+          return;
+        }
         const proposal = await tx.get(Stores.proposals, pr.proposalId);
         if (!proposal) {
           return;