1 files changed, 111 insertions, 65 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 bfafb80..09ca05b 100644
--- a/wallet/src/main/java/net/taler/wallet/transactions/TransactionDetailFragment.kt
+++ b/wallet/src/main/java/net/taler/wallet/transactions/TransactionDetailFragment.kt
@@ -16,105 +16,151 @@
 
 package net.taler.wallet.transactions
 
-import android.content.Intent
-import android.net.Uri
 import android.os.Bundle
-import android.view.Menu
-import android.view.MenuInflater
-import android.view.MenuItem
-import android.widget.TextView
-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.Amount
-import net.taler.common.startActivitySafe
+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()
-    private val transactionManager by lazy { model.transactionManager }
-    protected val transaction: Transaction? get() = transactionManager.selectedTransaction
+    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)
-        requireActivity().apply {
-            transaction?.generalTitleRes?.let {
-                title = getString(it)
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+        transactionManager.selectedTransaction.observe(viewLifecycleOwner) {
+            requireActivity().apply {
+                it?.generalTitleRes?.let {
+                    title = getString(it)
+                }
             }
         }
     }
 
-    @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")
     }
 
-    protected fun bindOrderAndFee(
-        orderSummaryView: TextView,
-        orderAmountView: TextView,
-        orderIdView: TextView,
-        feeView: TextView,
-        info: TransactionInfo,
-        raw: Amount,
-        fee: Amount,
-    ) {
-        orderAmountView.text = raw.toString()
-        feeView.text = getString(R.string.amount_negative, fee.toString())
-        orderSummaryView.text = if (info.fulfillmentMessage == null) {
-            info.summary
-        } else {
-            "${info.summary}\n\n${info.fulfillmentMessage}"
-        }
-        if (info.fulfillmentUrl?.startsWith("http", ignoreCase = true) == true) {
-            val i = Intent().apply {
-                data = Uri.parse(info.fulfillmentUrl)
-            }
-            orderSummaryView.setOnClickListener { requireContext().startActivitySafe(i) }
-        }
-        orderIdView.text = getString(R.string.transaction_order_id, info.orderId)
+    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 deleteDialogTitle = R.string.transactions_delete
-    @StringRes
-    protected open val deleteDialogMessage = R.string.transactions_delete_dialog_message
-    @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)
+            }
+        }
+    }
 }