1 files changed, 107 insertions, 35 deletions

diff --git a/wallet/src/main/java/net/taler/wallet/transactions/TransactionDetailFragment.kt b/wallet/src/main/java/net/taler/wallet/transactions/TransactionDetailFragment.kt
index 678bed2..09ca05b 100644
--- a/wallet/src/main/java/net/taler/wallet/transactions/TransactionDetailFragment.kt
+++ b/wallet/src/main/java/net/taler/wallet/transactions/TransactionDetailFragment.kt
@@ -17,31 +17,33 @@
 package net.taler.wallet.transactions
 
 import android.os.Bundle
-import android.view.Menu
-import android.view.MenuInflater
-import android.view.MenuItem
-import androidx.annotation.StringRes
+import android.util.Log
+import android.view.View
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.activityViewModels
 import androidx.navigation.fragment.findNavController
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import net.taler.common.showError
 import net.taler.wallet.MainViewModel
 import net.taler.wallet.R
+import net.taler.wallet.TAG
+import net.taler.wallet.showError
+import net.taler.wallet.transactions.TransactionAction.Abort
+import net.taler.wallet.transactions.TransactionAction.Delete
+import net.taler.wallet.transactions.TransactionAction.Fail
+import net.taler.wallet.transactions.TransactionAction.Resume
+import net.taler.wallet.transactions.TransactionAction.Retry
+import net.taler.wallet.transactions.TransactionAction.Suspend
 
 abstract class TransactionDetailFragment : Fragment() {
 
     private val model: MainViewModel by activityViewModels()
-    val transactionManager by lazy { model.transactionManager }
-    val devMode by lazy { model.devMode }
+    protected val transactionManager by lazy { model.transactionManager }
+    protected val balanceManager by lazy { model.balanceManager }
+    protected val devMode get() = model.devMode.value == true
 
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setHasOptionsMenu(model.devMode.value == true)
-    }
-
-    @Deprecated("Deprecated in Java")
-    override fun onActivityCreated(savedInstanceState: Bundle?) {
-        super.onActivityCreated(savedInstanceState)
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
         transactionManager.selectedTransaction.observe(viewLifecycleOwner) {
             requireActivity().apply {
                 it?.generalTitleRes?.let {
@@ -51,44 +53,114 @@ abstract class TransactionDetailFragment : Fragment() {
         }
     }
 
-    @Deprecated("Deprecated in Java")
-    override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
-        inflater.inflate(R.menu.transactions_detail, menu)
+    private fun dialogTitle(t: TransactionAction): Int = when (t) {
+        Delete -> R.string.transactions_delete_dialog_title
+        Abort -> R.string.transactions_abort_dialog_title
+        Fail -> R.string.transactions_fail_dialog_title
+        else -> error("unsupported action: $t")
     }
 
-    @Deprecated("Deprecated in Java")
-    override fun onOptionsItemSelected(item: MenuItem): Boolean {
-        return when (item.itemId) {
-            else -> super.onOptionsItemSelected(item)
-        }
+    private fun dialogMessage(t: TransactionAction): Int = when (t) {
+        Delete -> R.string.transactions_delete_dialog_message
+        Abort -> R.string.transactions_abort_dialog_message
+        Fail -> R.string.transactions_fail_dialog_message
+        else -> error("unsupported action: $t")
     }
 
-    @StringRes
-    protected open val deleteDialogTitle = R.string.transactions_delete
-
-    @StringRes
-    protected open val deleteDialogMessage = R.string.transactions_delete_dialog_message
+    private fun dialogButton(t: TransactionAction): Int = when (t) {
+        Delete -> R.string.transactions_delete
+        Abort -> R.string.transactions_abort
+        Fail -> R.string.transactions_fail
+        else -> error("unsupported")
+    }
 
-    @StringRes
-    protected open val deleteDialogButton = R.string.transactions_delete
+    protected fun onTransitionButtonClicked(t: Transaction, ta: TransactionAction) = when (ta) {
+        Delete -> showDialog(ta) { deleteTransaction(t) }
+        Abort -> showDialog(ta) { abortTransaction(t) }
+        Fail -> showDialog(ta) { failTransaction(t) }
+        Retry -> retryTransaction(t)
+        Suspend -> suspendTransaction(t)
+        Resume -> resumeTransaction(t)
+    }
 
-    protected fun onDeleteButtonClicked(t: Transaction) {
+    private fun showDialog(tt: TransactionAction, onAction: () -> Unit) {
         MaterialAlertDialogBuilder(requireContext(), R.style.MaterialAlertDialog_Material3)
-            .setTitle(deleteDialogTitle)
-            .setMessage(deleteDialogMessage)
+            .setTitle(dialogTitle(tt))
+            .setMessage(dialogMessage(tt))
             .setNeutralButton(R.string.cancel) { dialog, _ ->
                 dialog.cancel()
             }
-            .setNegativeButton(deleteDialogButton) { dialog, _ ->
-                deleteTransaction(t)
+            .setNegativeButton(dialogButton(tt)) { dialog, _ ->
+                onAction()
                 dialog.dismiss()
             }
             .show()
     }
 
     private fun deleteTransaction(t: Transaction) {
-        transactionManager.deleteTransaction(t.transactionId)
+        transactionManager.deleteTransaction(t.transactionId) {
+            Log.e(TAG, "Error deleteTransaction $it")
+            if (model.devMode.value == true) {
+                showError(it)
+            } else {
+                showError(it.userFacingMsg)
+            }
+        }
         findNavController().popBackStack()
     }
 
+    private fun retryTransaction(t: Transaction) {
+        transactionManager.retryTransaction(t.transactionId) {
+            Log.e(TAG, "Error retryTransaction $it")
+            if (model.devMode.value == true) {
+                showError(it)
+            } else {
+                showError(it.userFacingMsg)
+            }
+        }
+    }
+
+    private fun abortTransaction(t: Transaction) {
+        transactionManager.abortTransaction(t.transactionId) {
+            Log.e(TAG, "Error abortTransaction $it")
+            if (model.devMode.value == true) {
+                showError(it)
+            } else {
+                showError(it.userFacingMsg)
+            }
+        }
+    }
+
+    private fun failTransaction(t: Transaction) {
+        transactionManager.failTransaction(t.transactionId) {
+            Log.e(TAG, "Error failTransaction $it")
+            if (model.devMode.value == true) {
+                showError(it)
+            } else {
+                showError(it.userFacingMsg)
+            }
+        }
+    }
+
+    private fun suspendTransaction(t: Transaction) {
+        transactionManager.suspendTransaction(t.transactionId) {
+            Log.e(TAG, "Error suspendTransaction $it")
+            if (model.devMode.value == true) {
+                showError(it)
+            } else {
+                showError(it.userFacingMsg)
+            }
+        }
+    }
+
+    private fun resumeTransaction(t: Transaction) {
+        transactionManager.resumeTransaction(t.transactionId) {
+            Log.e(TAG, "Error resumeTransaction $it")
+            if (model.devMode.value == true) {
+                showError(it)
+            } else {
+                showError(it.userFacingMsg)
+            }
+        }
+    }
 }