From 838cedcdd0de4835fbd8c302bb2350e7a4bdce6a Mon Sep 17 00:00:00 2001
From: Florian Dold <florian@dold.me>
Date: Wed, 27 Mar 2024 13:18:28 +0100
Subject: -remove more reward remains

---
 packages/taler-wallet-core/src/reward.ts | 167 +------------------------------
 1 file changed, 5 insertions(+), 162 deletions(-)

(limited to 'packages/taler-wallet-core/src/reward.ts')

diff --git a/packages/taler-wallet-core/src/reward.ts b/packages/taler-wallet-core/src/reward.ts
index b8cf41326..85e8c6606 100644
--- a/packages/taler-wallet-core/src/reward.ts
+++ b/packages/taler-wallet-core/src/reward.ts
@@ -40,12 +40,9 @@ import {
 import { RewardRecord, RewardRecordStatus } from "./db.js";
 import {
   constructTransactionIdentifier,
-  notifyTransition,
 } from "./transactions.js";
 import { InternalWalletState, WalletExecutionContext } from "./wallet.js";
 
-const logger = new Logger("operations/tip.ts");
-
 export class RewardTransactionContext implements TransactionContext {
   public transactionId: TransactionIdStr;
   public taskId: TaskIdStr;
@@ -65,177 +62,23 @@ export class RewardTransactionContext implements TransactionContext {
   }
 
   async deleteTransaction(): Promise<void> {
-    const { wex, walletRewardId } = this;
-    await wex.db.runReadWriteTx(["rewards", "tombstones"], async (tx) => {
-      const tipRecord = await tx.rewards.get(walletRewardId);
-      if (tipRecord) {
-        await tx.rewards.delete(walletRewardId);
-        await tx.tombstones.put({
-          id: TombstoneTag.DeleteReward + ":" + walletRewardId,
-        });
-      }
-    });
+    throw Error("unsupported operation");
   }
 
   async suspendTransaction(): Promise<void> {
-    const { wex, walletRewardId, transactionId, taskId } = this;
-    const transitionInfo = await wex.db.runReadWriteTx(
-      ["rewards"],
-      async (tx) => {
-        const tipRec = await tx.rewards.get(walletRewardId);
-        if (!tipRec) {
-          logger.warn(`transaction tip ${walletRewardId} not found`);
-          return;
-        }
-        let newStatus: RewardRecordStatus | undefined = undefined;
-        switch (tipRec.status) {
-          case RewardRecordStatus.Done:
-          case RewardRecordStatus.SuspendedPickup:
-          case RewardRecordStatus.Aborted:
-          case RewardRecordStatus.DialogAccept:
-          case RewardRecordStatus.Failed:
-            break;
-          case RewardRecordStatus.PendingPickup:
-            newStatus = RewardRecordStatus.SuspendedPickup;
-            break;
-
-          default:
-            assertUnreachable(tipRec.status);
-        }
-        if (newStatus != null) {
-          const oldTxState = computeRewardTransactionStatus(tipRec);
-          tipRec.status = newStatus;
-          const newTxState = computeRewardTransactionStatus(tipRec);
-          await tx.rewards.put(tipRec);
-          return {
-            oldTxState,
-            newTxState,
-          };
-        }
-        return undefined;
-      },
-    );
-    notifyTransition(wex, transactionId, transitionInfo);
+    throw Error("unsupported operation");
   }
 
   async abortTransaction(): Promise<void> {
-    const { wex, walletRewardId, transactionId } = this;
-    const transitionInfo = await wex.db.runReadWriteTx(
-      ["rewards"],
-      async (tx) => {
-        const tipRec = await tx.rewards.get(walletRewardId);
-        if (!tipRec) {
-          logger.warn(`transaction tip ${walletRewardId} not found`);
-          return;
-        }
-        let newStatus: RewardRecordStatus | undefined = undefined;
-        switch (tipRec.status) {
-          case RewardRecordStatus.Done:
-          case RewardRecordStatus.Aborted:
-          case RewardRecordStatus.PendingPickup:
-          case RewardRecordStatus.DialogAccept:
-          case RewardRecordStatus.Failed:
-            break;
-          case RewardRecordStatus.SuspendedPickup:
-            newStatus = RewardRecordStatus.Aborted;
-            break;
-          default:
-            assertUnreachable(tipRec.status);
-        }
-        if (newStatus != null) {
-          const oldTxState = computeRewardTransactionStatus(tipRec);
-          tipRec.status = newStatus;
-          const newTxState = computeRewardTransactionStatus(tipRec);
-          await tx.rewards.put(tipRec);
-          return {
-            oldTxState,
-            newTxState,
-          };
-        }
-        return undefined;
-      },
-    );
-    notifyTransition(wex, transactionId, transitionInfo);
+    throw Error("unsupported operation");
   }
 
   async resumeTransaction(): Promise<void> {
-    const { wex: ws, walletRewardId, transactionId, taskId: retryTag } = this;
-    const transitionInfo = await ws.db.runReadWriteTx(
-      ["rewards"],
-      async (tx) => {
-        const rewardRec = await tx.rewards.get(walletRewardId);
-        if (!rewardRec) {
-          logger.warn(`transaction reward ${walletRewardId} not found`);
-          return;
-        }
-        let newStatus: RewardRecordStatus | undefined = undefined;
-        switch (rewardRec.status) {
-          case RewardRecordStatus.Done:
-          case RewardRecordStatus.PendingPickup:
-          case RewardRecordStatus.Aborted:
-          case RewardRecordStatus.DialogAccept:
-          case RewardRecordStatus.Failed:
-            break;
-          case RewardRecordStatus.SuspendedPickup:
-            newStatus = RewardRecordStatus.PendingPickup;
-            break;
-          default:
-            assertUnreachable(rewardRec.status);
-        }
-        if (newStatus != null) {
-          const oldTxState = computeRewardTransactionStatus(rewardRec);
-          rewardRec.status = newStatus;
-          const newTxState = computeRewardTransactionStatus(rewardRec);
-          await tx.rewards.put(rewardRec);
-          return {
-            oldTxState,
-            newTxState,
-          };
-        }
-        return undefined;
-      },
-    );
-    notifyTransition(ws, transactionId, transitionInfo);
+    throw Error("unsupported operation");
   }
 
   async failTransaction(): Promise<void> {
-    const { wex: ws, walletRewardId, transactionId, taskId: retryTag } = this;
-    const transitionInfo = await ws.db.runReadWriteTx(
-      ["rewards"],
-      async (tx) => {
-        const tipRec = await tx.rewards.get(walletRewardId);
-        if (!tipRec) {
-          logger.warn(`transaction tip ${walletRewardId} not found`);
-          return;
-        }
-        let newStatus: RewardRecordStatus | undefined = undefined;
-        switch (tipRec.status) {
-          case RewardRecordStatus.Done:
-          case RewardRecordStatus.Aborted:
-          case RewardRecordStatus.Failed:
-            break;
-          case RewardRecordStatus.PendingPickup:
-          case RewardRecordStatus.DialogAccept:
-          case RewardRecordStatus.SuspendedPickup:
-            newStatus = RewardRecordStatus.Failed;
-            break;
-          default:
-            assertUnreachable(tipRec.status);
-        }
-        if (newStatus != null) {
-          const oldTxState = computeRewardTransactionStatus(tipRec);
-          tipRec.status = newStatus;
-          const newTxState = computeRewardTransactionStatus(tipRec);
-          await tx.rewards.put(tipRec);
-          return {
-            oldTxState,
-            newTxState,
-          };
-        }
-        return undefined;
-      },
-    );
-    notifyTransition(ws, transactionId, transitionInfo);
+    throw Error("unsupported operation");
   }
 }
 
-- 
cgit v1.2.3