Updated on 2026-08-14

2021-12-08 15:08:19 +03:00 · 2021-12-08 15:08:19 +03:00 · 18b5afd51e
commit 18b5afd51e
parent a6a59e0863 05f9be0331
7 changed files with 143 additions and 133 deletions
--- a/app/src/main/java/com/tangem/tap/common/DialogManager.kt
+++ b/app/src/main/java/com/tangem/tap/common/DialogManager.kt
@ -10,8 +10,8 @@ import com.tangem.tap.features.onboarding.AddressInfoBottomSheetDialog
 import com.tangem.tap.features.onboarding.products.twins.redux.TwinCardsAction
 import com.tangem.tap.features.onboarding.products.twins.ui.dialog.CreateWalletInterruptDialog
 import com.tangem.tap.features.onboarding.products.wallet.redux.BackupDialog
+import com.tangem.tap.features.onboarding.products.wallet.ui.dialogs.AddMoreBackupCardsDialog
 import com.tangem.tap.features.onboarding.products.wallet.ui.dialogs.BackupInProgressDialog
-import com.tangem.tap.features.onboarding.products.wallet.ui.dialogs.BuyMoreBackupCardsDialog
 import com.tangem.tap.features.onboarding.products.wallet.ui.dialogs.ConfirmDiscardingBackupDialog
 import com.tangem.tap.features.onboarding.products.wallet.ui.dialogs.UnfinishedBackupFoundDialog
 import com.tangem.tap.features.wallet.ui.dialogs.ScanFailsDialog
@ -79,7 +79,7 @@ class DialogManager : StoreSubscriber<GlobalState> {
                TransactionDialog.create(state.dialog.dialogData, context)
            is WalletConnectDialog.PersonalSign ->
                PersonalSignDialog.create(state.dialog.data, context)
-            is BackupDialog.BuyMoreBackupCards -> BuyMoreBackupCardsDialog.create(context)
+            is BackupDialog.AddMoreBackupCards -> AddMoreBackupCardsDialog.create(context)
            is BackupDialog.BackupInProgress -> BackupInProgressDialog.create(context)
            is BackupDialog.UnfinishedBackupFound -> UnfinishedBackupFoundDialog.create(context)
            is BackupDialog.ConfirmDiscardingBackup -> ConfirmDiscardingBackupDialog.create(context)
--- a/app/src/main/java/com/tangem/tap/features/home/redux/HomeMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/home/redux/HomeMiddleware.kt
@ -27,8 +27,7 @@ class HomeMiddleware {
    companion object {
        val handler = homeMiddleware

-        const val CARD_SHOP_URI =
-            "https://shop.tangem.com/?afmc=1i&utm_campaign=1i&utm_source=leaddyno&utm_medium=affiliate"
+        const val CARD_SHOP_URI = "http://cards.tangem.com/"
    }
 }

--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/redux/OnboardingWalletMiddleware.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/redux/OnboardingWalletMiddleware.kt
@ -14,8 +14,8 @@ import com.tangem.tap.common.redux.navigation.NavigationAction
 import com.tangem.tap.domain.extensions.hasWallets
 import com.tangem.tap.domain.tasks.product.ScanResponse
 import com.tangem.tap.features.home.redux.HomeAction
-import com.tangem.tap.features.home.redux.HomeMiddleware
 import com.tangem.tap.features.onboarding.products.note.redux.OnboardingNoteAction
+import com.tangem.tap.features.onboarding.products.wallet.redux.OnboardingWalletMiddleware.Companion.BUY_WALLET_URL
 import kotlinx.coroutines.launch
 import org.rekotlin.Action
 import org.rekotlin.Middleware
@ -23,6 +23,8 @@ import org.rekotlin.Middleware
 class OnboardingWalletMiddleware {
    companion object {
        val handler = onboardingWalletMiddleware
+
+        const val BUY_WALLET_URL = "https://wallet.tangem.com/"
    }
 }

@ -143,129 +145,138 @@ class BackupMiddleware {
    val backupMiddleware: Middleware<AppState> = { dispatch, state ->
        { next ->
            { action ->
-                val backupState = state()?.onboardingWalletState?.backupState
-                when (action) {
-                    is BackupAction.StartBackup -> {
-                        backupService.discardSavedBackup()
-                    }
-                    is BackupAction.ScanPrimaryCard -> {
-                        backupService.readPrimaryCard { result ->
-                            when (result) {
-                                is CompletionResult.Success -> {
-                                    store.dispatchOnMain(BackupAction.StartAddingBackupCards)
-                                }
-                                is CompletionResult.Failure -> {
-                                }
-                            }
-                        }
-                    }
-                    is BackupAction.AddBackupCard -> {
-                        backupService.addBackupCard { result ->
-                            when (result) {
-                                is CompletionResult.Success -> {
-                                    store.dispatchOnMain(BackupAction.AddBackupCard.Success)
-                                }
-                                is CompletionResult.Failure -> {
-
-                                }
-                            }
-                        }
-                    }
-                    is BackupAction.GoToShop -> {
-                        store.dispatchOpenUrl(HomeMiddleware.CARD_SHOP_URI)
-                    }
-                    is BackupAction.FinishAddingBackupCards -> {
-                        if (backupService.addedBackupCardsCount == 1) {
-                            store.dispatchOnMain(GlobalAction.ShowDialog(BackupDialog.BuyMoreBackupCards))
-                        }
-                        if (backupService.addedBackupCardsCount == 2) {
-                            store.dispatchOnMain(BackupAction.ShowAccessCodeInfoScreen)
-                        }
-                    }
-                    is BackupAction.CheckAccessCode -> {
-                        if (action.accessCode.length < 4) {
-                            store.dispatch(BackupAction.SetAccessCodeError(
-                                AccessCodeError.CodeTooShort
-                            ))
-                        } else {
-                            store.dispatch(BackupAction.SaveFirstAccessCode(action.accessCode))
-                        }
-                    }
-                    is BackupAction.SaveAccessCodeConfirmation -> {
-                        if (action.accessCodeConfirmation == backupState?.accessCode) {
-                            backupService.setAccessCode(action.accessCodeConfirmation)
-                            store.dispatch(BackupAction.PrepareToWritePrimaryCard)
-                        } else {
-                            store.dispatch(BackupAction.SetAccessCodeError(
-                                AccessCodeError.CodesDoNotMatch
-                            ))
-                        }
-                    }
-                    is BackupAction.WritePrimaryCard -> {
-                        backupService.proceedBackup { result ->
-                            when (result) {
-                                is CompletionResult.Success -> {
-                                    store.dispatchOnMain(
-                                        BackupAction.PrepareToWriteBackupCard(1)
-                                    )
-                                }
-                                is CompletionResult.Failure -> {
-                                }
-                            }
-                        }
-                    }
-                    is BackupAction.WriteBackupCard -> {
-                        backupService.proceedBackup { result ->
-                            when (result) {
-                                is CompletionResult.Success -> {
-                                    if (backupService.currentState == BackupService.State.Finished) {
-                                        store.dispatchOnMain(BackupAction.FinishBackup)
-                                    } else {
-                                        store.dispatchOnMain(
-                                            BackupAction.PrepareToWriteBackupCard(action.cardNumber + 1)
-                                        )
-                                    }
-                                }
-                                is CompletionResult.Failure -> {
-
-                                }
-                            }
-                        }
-                    }
-                    is BackupAction.FinishBackup -> {
-                        (listOf(backupState?.primaryCardId,
-                            store.state.globalState.onboardingState.onboardingManager?.scanResponse?.card?.cardId) +
-                                backupState?.backupCardIds as List<String>)
-                            .distinct().filterNotNull()
-                            .forEach { cardId ->
-                                preferencesStorage.usedCardsPrefStorage.activationFinished(cardId)
-                            }
-                    }
-                    is BackupAction.DiscardBackup -> {
-                        backupService.discardSavedBackup()
-                    }
-                    is BackupAction.DiscardSavedBackup -> {
-                        backupService.primaryCardId?.let {
-                            preferencesStorage.usedCardsPrefStorage.activationFinished(it)
-                        }
-                        backupService.discardSavedBackup()
-                    }
-                    is BackupAction.CheckForUnfinishedBackup -> {
-                        if (backupService.hasIncompletedBackup) {
-                            store.dispatch(GlobalAction.ShowDialog(BackupDialog.UnfinishedBackupFound))
-                        }
-                    }
-                    is BackupAction.ResumeBackup -> {
-                        store.dispatch(GlobalAction.Onboarding.Start(null, true))
-                        store.dispatch(OnboardingWalletAction.ProceedBackup)
-                        store.dispatch(NavigationAction.NavigateTo(AppScreen.OnboardingWallet))
-                    }
-                    is BackupAction.DismissBackup -> {
-                        store.dispatch(BackupAction.FinishBackup)
-                    }
-                }
+                if (action is BackupAction) handleBackupAction(action)
                next(action)
            }
        }
    }
+}
+
+private fun handleBackupAction(action: BackupAction) {
+    val backupState = store.state.onboardingWalletState.backupState
+
+    val globalState = store.state.globalState
+    val onboardingManager = globalState.onboardingState.onboardingManager
+
+    val scanResponse = onboardingManager?.scanResponse
+    val card = scanResponse?.card
+
+    when (action) {
+        is BackupAction.StartBackup -> {
+            backupService.discardSavedBackup()
+        }
+        is BackupAction.ScanPrimaryCard -> {
+            backupService.readPrimaryCard(cardId = card?.cardId) { result ->
+                when (result) {
+                    is CompletionResult.Success -> {
+                        store.dispatchOnMain(BackupAction.StartAddingBackupCards)
+                    }
+                    is CompletionResult.Failure -> {
+                    }
+                }
+            }
+        }
+        is BackupAction.AddBackupCard -> {
+            backupService.addBackupCard { result ->
+                when (result) {
+                    is CompletionResult.Success -> {
+                        store.dispatchOnMain(BackupAction.AddBackupCard.Success)
+                    }
+                    is CompletionResult.Failure -> {
+
+                    }
+                }
+            }
+        }
+        is BackupAction.GoToShop -> {
+            store.dispatchOpenUrl(BUY_WALLET_URL)
+        }
+        is BackupAction.FinishAddingBackupCards -> {
+            if (backupService.addedBackupCardsCount == 1) {
+                store.dispatchOnMain(GlobalAction.ShowDialog(BackupDialog.AddMoreBackupCards))
+            }
+            if (backupService.addedBackupCardsCount == 2) {
+                store.dispatchOnMain(BackupAction.ShowAccessCodeInfoScreen)
+            }
+        }
+        is BackupAction.CheckAccessCode -> {
+            if (action.accessCode.length < 4) {
+                store.dispatch(BackupAction.SetAccessCodeError(
+                    AccessCodeError.CodeTooShort
+                ))
+            } else {
+                store.dispatch(BackupAction.SaveFirstAccessCode(action.accessCode))
+            }
+        }
+        is BackupAction.SaveAccessCodeConfirmation -> {
+            if (action.accessCodeConfirmation == backupState.accessCode) {
+                backupService.setAccessCode(action.accessCodeConfirmation)
+                store.dispatch(BackupAction.PrepareToWritePrimaryCard)
+            } else {
+                store.dispatch(BackupAction.SetAccessCodeError(
+                    AccessCodeError.CodesDoNotMatch
+                ))
+            }
+        }
+        is BackupAction.WritePrimaryCard -> {
+            backupService.proceedBackup { result ->
+                when (result) {
+                    is CompletionResult.Success -> {
+                        store.dispatchOnMain(
+                            BackupAction.PrepareToWriteBackupCard(1)
+                        )
+                    }
+                    is CompletionResult.Failure -> {
+                    }
+                }
+            }
+        }
+        is BackupAction.WriteBackupCard -> {
+            backupService.proceedBackup { result ->
+                when (result) {
+                    is CompletionResult.Success -> {
+                        if (backupService.currentState == BackupService.State.Finished) {
+                            store.dispatchOnMain(BackupAction.FinishBackup)
+                        } else {
+                            store.dispatchOnMain(
+                                BackupAction.PrepareToWriteBackupCard(action.cardNumber + 1)
+                            )
+                        }
+                    }
+                    is CompletionResult.Failure -> {
+
+                    }
+                }
+            }
+        }
+        is BackupAction.FinishBackup -> {
+            (listOf(backupState.primaryCardId, card?.cardId) + backupState.backupCardIds)
+                .distinct().filterNotNull()
+                .forEach { cardId ->
+                    preferencesStorage.usedCardsPrefStorage.activationFinished(cardId)
+                }
+        }
+        is BackupAction.DiscardBackup -> {
+            backupService.discardSavedBackup()
+        }
+        is BackupAction.DiscardSavedBackup -> {
+            backupService.primaryCardId?.let {
+                preferencesStorage.usedCardsPrefStorage.activationFinished(it)
+            }
+            backupService.discardSavedBackup()
+        }
+        is BackupAction.CheckForUnfinishedBackup -> {
+            if (backupService.hasIncompletedBackup) {
+                store.dispatch(GlobalAction.ShowDialog(BackupDialog.UnfinishedBackupFound))
+            }
+        }
+        is BackupAction.ResumeBackup -> {
+            store.dispatch(GlobalAction.Onboarding.Start(null, true))
+            store.dispatch(OnboardingWalletAction.ProceedBackup)
+            store.dispatch(NavigationAction.NavigateTo(AppScreen.OnboardingWallet))
+        }
+        is BackupAction.DismissBackup -> {
+            store.dispatch(BackupAction.FinishBackup)
+        }
+    }
 }
--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/redux/OnboardingWalletState.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/redux/OnboardingWalletState.kt
@ -74,7 +74,7 @@ sealed class BackupStep {
 }

 sealed class BackupDialog: StateDialog {
-    object BuyMoreBackupCards : StateDialog
+    object AddMoreBackupCards : StateDialog
    object BackupInProgress : StateDialog
    object UnfinishedBackupFound : StateDialog
    object ConfirmDiscardingBackup : StateDialog
--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/OnboardingWalletFragment.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/OnboardingWalletFragment.kt
@ -17,8 +17,8 @@ import com.tangem.tap.common.leapfrogWidget.LeapfrogWidget
 import com.tangem.tap.common.postUi
 import com.tangem.tap.features.FragmentOnBackPressedHandler
 import com.tangem.tap.features.addBackPressHandler
-import com.tangem.tap.features.home.redux.HomeMiddleware
 import com.tangem.tap.features.onboarding.products.wallet.redux.*
+import com.tangem.tap.features.onboarding.products.wallet.redux.OnboardingWalletMiddleware.Companion.BUY_WALLET_URL
 import com.tangem.tap.features.onboarding.products.wallet.ui.dialogs.AccessCodeDialog
 import com.tangem.tap.store
 import com.tangem.wallet.R
@ -363,7 +363,7 @@ class OnboardingWalletFragment : Fragment(R.layout.fragment_onboarding_wallet),
    override fun onOptionsItemSelected(item: MenuItem): Boolean {
        return when (item.itemId) {
            R.id.shop_menu -> {
-                store.dispatchOpenUrl(HomeMiddleware.CARD_SHOP_URI)
+                store.dispatchOpenUrl(BUY_WALLET_URL)
                true
            }
            else -> super.onOptionsItemSelected(item)
--- a/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/dialogs/AddMoreBackupCardsDialog.kt
+++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/dialogs/AddMoreBackupCardsDialog.kt
@ -7,7 +7,7 @@ import com.tangem.tap.features.onboarding.products.wallet.redux.BackupAction
 import com.tangem.tap.store
 import com.tangem.wallet.R

-class BuyMoreBackupCardsDialog {
+class AddMoreBackupCardsDialog {
        companion object {
            fun create(context: Context): AlertDialog {
                return AlertDialog.Builder(context).apply {
@ -16,8 +16,8 @@ class BuyMoreBackupCardsDialog {
                    setPositiveButton(R.string.common_continue) { _, _ ->
                        store.dispatch(BackupAction.ShowAccessCodeInfoScreen)
                    }
-                    setNegativeButton(R.string.onboarding_button_buy_more_cards) { _, _ ->
-                        store.dispatch(BackupAction.GoToShop)
+                    setNegativeButton(R.string.onboarding_button_add_more_cards) { _, _ ->
+
                    }
                    setOnDismissListener {
                        store.dispatch(GlobalAction.HideDialog)
--- a/app/src/main/res/values/strings_untranslated.xml
+++ b/app/src/main/res/values/strings_untranslated.xml
@ -218,7 +218,7 @@
    <string name="onboarding_button_add_backup_card" translatable="false">+ Add backup card</string>
    <string name="onboarding_button_backup_card_format" translatable="false">Scan the card #%d</string>
    <string name="onboarding_button_scan_origin_card" translatable="false">Scan primary card</string>
-    <string name="onboarding_button_buy_more_cards" translatable="false">Buy more cards</string>
+    <string name="onboarding_button_add_more_cards" translatable="false">Add more cards</string>

    <string name="onboarding_title_backup_card" translatable="false">Backup your wallet</string>
    <string name="onboarding_title_no_backup_cards" translatable="false">No backup cards</string>