kickstarter · Arkariang · Sep 10, 2020 · Sep 8, 2020 · Sep 8, 2020 · Sep 8, 2020
diff --git a/app/src/main/java/com/kickstarter/libs/utils/RewardUtils.java b/app/src/main/java/com/kickstarter/libs/utils/RewardUtils.java
@@ -84,7 +84,8 @@ public static boolean isReward(final @NonNull Reward reward) {
    */
   public static boolean isShippable(final @NonNull Reward reward) {
     final String shippingType = reward.shippingType();
-    return shippingType != null && !Reward.SHIPPING_TYPE_NO_SHIPPING.equals(shippingType);
+    final boolean no_shipping_types = reward.shippingPreferenceType() == Reward.ShippingPreference.NONE;
+    return shippingType != null && !(Reward.SHIPPING_TYPE_NO_SHIPPING.equals(shippingType) || no_shipping_types);
   }
 
   /**

diff --git a/app/src/main/java/com/kickstarter/services/KSApolloClient.kt b/app/src/main/java/com/kickstarter/services/KSApolloClient.kt
@@ -606,24 +606,7 @@ private fun createBackingObject(backingGr: fragment.Backing?): Backing {
     val shippingAmount = backingGr?.shippingAmount()?.fragments()
 
     val reward = backingGr?.reward()?.fragments()?.reward()?.let { reward ->
-        val rewardId = decodeRelayId(reward.id()) ?: -1
-        val rewardAmount = reward.amount().fragments().amount().amount()?.toDouble()
-        val rewardSingleLocation = location?.let { location ->
-            return@let Reward.SingleLocation.builder()
-                    .localizedName(location.displayableName())
-                    .id(decodeRelayId(location.id())?:-1)
-                    .build()
-        }
-
-        return@let Reward.builder()
-                .title(reward.name())
-                .minimum(rewardAmount?: -1.0)
-                .description(reward.description())
-                .isAddOn(false)
-                .estimatedDeliveryOn(DateTime(reward.estimatedDeliveryOn()))
-                .shippingSingleLocation(rewardSingleLocation)
-                .id(rewardId)
-                .build()
+            return@let rewardTransformer(reward)
     }
 
     val backerData = backingGr?.backer()?.fragments()?.user()
@@ -754,7 +737,9 @@ private fun rewardTransformer(rewardGr: fragment.Reward): Reward {
             .isAddOn(true)
             .addOnsItems(items)
             .id(rewardId)
+            .shippingPreference(shippingPreference.name)
             .shippingPreferenceType(shippingPreference)
+            .shippingType(shippingPreference.name)
             .shippingRules(shippingRules)
             .build()
 }

diff --git a/app/src/main/java/com/kickstarter/ui/adapters/RewardAndAddOnsAdapter.kt b/app/src/main/java/com/kickstarter/ui/adapters/RewardAndAddOnsAdapter.kt
@@ -29,10 +29,8 @@ class RewardAndAddOnsAdapter() : KSAdapter() {
     }
 
     fun populateDataForAddOns(rewards: List<Pair<ProjectData,Reward>>) {
-        if (rewards.isNotEmpty()) {
-            setSection(SECTION_ADD_ONS_CARD, rewards)
-            notifyDataSetChanged()
-        }
+        setSection(SECTION_ADD_ONS_CARD, rewards)
+        notifyDataSetChanged()
     }
 
     fun populateDataForReward(reward: Pair<ProjectData, Reward>) {

diff --git a/app/src/main/java/com/kickstarter/ui/fragments/BackingFragment.kt b/app/src/main/java/com/kickstarter/ui/fragments/BackingFragment.kt
@@ -22,6 +22,7 @@ import com.kickstarter.libs.SwipeRefresher
 import com.kickstarter.libs.qualifiers.RequiresFragmentViewModel
 import com.kickstarter.libs.rx.transformers.Transformers
 import com.kickstarter.libs.transformations.CircleTransformation
+import com.kickstarter.libs.utils.ObjectUtils
 import com.kickstarter.libs.utils.ViewUtils
 import com.kickstarter.models.Reward
 import com.kickstarter.ui.adapters.RewardAndAddOnsAdapter
@@ -184,7 +185,7 @@ class BackingFragment : BaseFragment<BackingFragmentViewModel.ViewModel>() {
                 .subscribe { total_summary_amount.text = it }
 
         this.viewModel.outputs.projectDataAndAddOns()
-                .filter { it.second.isNotEmpty() }
+                .filter { ObjectUtils.isNotNull(it) }
                 .distinctUntilChanged()
                 .compose(bindToLifecycle())
                 .compose(Transformers.observeForUI())

diff --git a/app/src/main/java/com/kickstarter/ui/fragments/RewardsFragment.kt b/app/src/main/java/com/kickstarter/ui/fragments/RewardsFragment.kt
@@ -95,7 +95,8 @@ class RewardsFragment : BaseFragment<RewardsFragmentViewModel.ViewModel>(), Rewa
     }
 
     private fun showAlert() {
-        dialog.show()
+        if (this.isVisible)
+            dialog.show()
     }
 
     private fun scrollToReward(position: Int) {
@@ -140,7 +141,7 @@ class RewardsFragment : BaseFragment<RewardsFragmentViewModel.ViewModel>(), Rewa
     }
 
     private fun showPledgeFragment(pledgeData: PledgeData, pledgeReason: PledgeReason) {
-        if (this.fragmentManager?.findFragmentByTag(PledgeFragment::class.java.simpleName) == null) {
+        if (this.isVisible && this.fragmentManager?.findFragmentByTag(PledgeFragment::class.java.simpleName) == null) {
             val pledgeFragment = PledgeFragment.newInstance(pledgeData, pledgeReason)
             this.fragmentManager?.beginTransaction()
                     ?.setCustomAnimations(R.anim.slide_in_right, 0, 0, R.anim.slide_out_right)
@@ -153,7 +154,7 @@ class RewardsFragment : BaseFragment<RewardsFragmentViewModel.ViewModel>(), Rewa
     }
 
     private fun showAddonsFragment(pledgeDataAndReason: Pair<PledgeData, PledgeReason>) {
-        if (this.fragmentManager?.findFragmentByTag(BackingAddOnsFragment::class.java.simpleName) == null) {
+        if (this.isVisible && this.fragmentManager?.findFragmentByTag(BackingAddOnsFragment::class.java.simpleName) == null) {
             val addOnsFragment = BackingAddOnsFragment.newInstance(pledgeDataAndReason)
             this.fragmentManager?.beginTransaction()
                     ?.setCustomAnimations(R.anim.slide_in_right, 0, 0, R.anim.slide_out_right)

diff --git a/app/src/main/java/com/kickstarter/viewmodels/BackingAddOnsFragmentViewModel.kt b/app/src/main/java/com/kickstarter/viewmodels/BackingAddOnsFragmentViewModel.kt
@@ -113,21 +113,14 @@ class BackingAddOnsFragmentViewModel {
             val project = projectData
                     .map { it.project() }
 
-            val rewardPledge = pledgeData
+            val reward = pledgeData
                     .map { it.reward() }
 
             val backing = projectData
                     .map { getBackingFromProjectData(it) }
                     .filter { ObjectUtils.isNotNull(it) }
                     .map { requireNotNull(it) }
 
-            val backingReward = backing
-                    .map { it.reward() }
-                    .filter { ObjectUtils.isNotNull(it) }
-                    .map { requireNotNull(it) }
-
-            val reward = Observable.merge(rewardPledge, backingReward)
-
             val projectAndReward = project
                     .compose<Pair<Project, Reward>>(combineLatestPair(reward))
 
@@ -148,12 +141,6 @@ class Bac
9E7A
kingAddOnsFragmentViewModel {
                     .filter { ObjectUtils.isNotNull(it) }
                     .map { requireNotNull(it) }
 
-            backingShippingRule
-                    .compose(bindToLifecycle())
-                    .subscribe {
-                        this.shippingRuleSelected.onNext(it)
-                    }
-
             // - In case of digital Reward to follow the same flow as the rest of use cases use and empty shippingRule
             reward
                     .filter { isDigital(it) }
@@ -188,7 +175,6 @@ class BackingAddOnsFragmentViewModel {
             shippingRules
                     .filter { it.isNotEmpty() }
                     .compose<Pair<List<ShippingRule>, PledgeReason>>(combineLatestPair(pledgeReason))
-                    .filter { it.second == PledgeReason.PLEDGE }
                     .switchMap { defaultShippingRule(it.first) }
                     .subscribe(this.shippingRuleSelected)
 
@@ -325,11 +311,15 @@ class BackingAddOnsFragmentViewModel {
 
         private fun filterByLocationAndUpdateQuantity(addOns: List<Reward>, pData: ProjectData, rule: ShippingRule, rw: Reward): Triple<ProjectData, List<Reward>, ShippingRule> {
            val filteredAddOns = when (rw.shippingPreference()){
+                Reward.ShippingPreference.UNRESTRICTED.name,
                 Reward.ShippingPreference.UNRESTRICTED.toString().toLowerCase() -> {
                     addOns.filter {
-                        it.shippingPreferenceType() ==  Reward.ShippingPreference.UNRESTRICTED || isDigital(it)
+                        (it.shippingPreferenceType() ==  Reward.ShippingPreference.UNRESTRICTED ) ||
+                                containsLocation(rule, it) ||
+                                isDigital(it)
                     }
                 }
+                Reward.ShippingPreference.RESTRICTED.name,
                 Reward.ShippingPreference.RESTRICTED.toString().toLowerCase() -> {
                     addOns.filter { containsLocation(rule, it) || isDigital(it) }
                 }

diff --git a/app/src/main/java/com/kickstarter/viewmodels/PledgeFragmentViewModel.kt b/app/src/main/java/com/kickstarter/viewmodels/PledgeFragmentViewModel.kt
@@ -296,7 +296,7 @@ interface PledgeFragmentViewModel {
         private val newCardButtonClicked = PublishSubject.create<Void>()
         private val pledgeButtonClicked = PublishSubject.create<Void>()
         private val pledgeInput = PublishSubject.create<String>()
-        private val shippingRule = PublishSubject.create<ShippingRule>()
+        private val shippingRule = BehaviorSubject.create<ShippingRule>()
         private val stripeSetupResultSuccessful = PublishSubject.create<Int>()
         private val stripeSetupResultUnsuccessful = PublishSubject.create<Exception>()
         private val decreaseBonusButtonClicked = PublishSubject.create<Void>()

diff --git a/app/src/main/java/com/kickstarter/viewmodels/ProjectViewModel.kt b/app/src/main/java/com/kickstarter/viewmodels/ProjectViewModel.kt
@@ -545,17 +545,27 @@ interface ProjectViewModel {
             val backing = backedProject
                     .switchMap {
                         this.apolloClient.getProjectBacking(it.slug()?: "")
+                                .doOnSubscribe {
+                                    progressBarIsGone.onNext(false)
+                                }
+                                .doAfterTerminate {
+                                    progressBarIsGone.onNext(true)
+                                }
+                                .materialize()
                     }
+                    .compose(neverError())
+                    .compose(values())
+                    .filter { ObjectUtils.isNotNull(it) }
+                    .share()
 
             // - Update fragments with the backing data
             projectData
-                    .filter { it.project().hasRewards() && it.project().isBacking }
+                    .filter { it.project().hasRewards() }
                     .compose<Pair<ProjectData, Backing>>(combineLatestPair(backing))
                     .map {
                         val updatedProject = it.first.project().toBuilder().backing(it.second).build()
                         projectData(it.first.refTagFromIntent(), it.first.refTagFromCookie(), updatedProject)
                     }
-                    .distinctUntilChanged()
                     .compose(bindToLifecycle())
                     .subscribe(this.updateFragments)
 
@@ -680,7 +690,7 @@ interface ProjectViewModel {
 
             this.fragmentStackCount
                     .compose<Pair<Int, Project>>(combineLatestPair(currentProject))
-                    .map { if (it.second.isBacking) it.first > 3 else it.first > 3}
+                    .map { if (it.second.isBacking) it.first > 4 else it.first > 3 }
                     .distinctUntilChanged()
                     .compose(bindToLifecycle())
                     .subscribe(this.scrimIsVisible)

diff --git a/app/src/main/java/com/kickstarter/viewmodels/RewardsFragmentViewModel.kt b/app/src/main/java/com/kickstarter/viewmodels/RewardsFragmentViewModel.kt
@@ -9,6 +9,8 @@ import com.kickstarter.libs.rx.transformers.Transformers.combineLatestPair
 import com.kickstarter.libs.rx.transformers.Transformers.takeWhen
 import com.kickstarter.libs.utils.BackingUtils
 import com.kickstarter.libs.utils.ObjectUtils
+import com.kickstarter.mock.factories.RewardFactory
+import com.kickstarter.models.Backing
 import com.kickstarter.models.Project
 import com.kickstarter.models.Reward
 import com.kickstarter.ui.data.PledgeData
@@ -78,71 +80,66 @@ class RewardsFragmentViewModel {
                     .map { it.project() }
 
             val backedReward = project
-                    .map { it.backing()?.reward() }
+                    .map { it.backing()?.let { backing -> getReward(backing) } }
                     .filter { ObjectUtils.isNotNull(it) }
                     .map { requireNotNull(it) }
 
-            val backedAddOns = project
-                    .map { it?.backing()?.addOns() }
-                    .filter { ObjectUtils.isNotNull(it) }
-                    .map { requireNotNull(it) }
-
-            val hasAddOnsBacked = backedAddOns
-                    .map { it.isNotEmpty() }
-
             project
                     .filter { it.isBacking }
                     .map { indexOfBackedReward(it) }
                     .distinctUntilChanged()
                     .compose(bindToLifecycle())
                     .subscribe(this.backedRewardPosition)
 
-            // - If the selected Reward do not have AddOns
             val pledgeDataAndReason = this.projectDataInput
                     .compose<Pair<ProjectData, Reward>>(Transformers.takePairWhen(this.rewardClicked))
-                    .filter { !it.second.hasAddons() }
                     .map { pledgeDataAndPledgeReason(it.first, it.second) }
+                    .distinctUntilChanged()
 
             pledgeDataAndReason
                     .filter { it.second == PledgeReason.PLEDGE}
+                    .compose<Pair<PledgeData, PledgeReason>>(takeWhen(this.rewardClicked))
                     .compose(bindToLifecycle())
-                    .subscribe(this.showPledgeFragment)
+                    .subscribe {
+                        val rw = it.first.reward()
 
-            pledgeDataAndReason
-                    .compose<Pair<Pair<PledgeData, PledgeReason>, Reward>>(combineLatestPair(backedReward))
-                    .filter { !it.second.hasAddons() }
-                    .map { it.first }
-                    .compose(bindToLifecycle())
-                    .subscribe(this.showPledgeFragment)
+                        if (rw.hasAddons())
+                            this.showAddOnsFragment.onNext(it)
+                        else
+                            this.showPledgeFragment.onNext(it)
 
-            pledgeDataAndReason
-                    .filter { it.second == PledgeReason.UPDATE_REWARD }
-                    .compose<Pair<Pair<PledgeData, PledgeReason>, Boolean>>(combineLatestPair(hasAddOnsBacked))
-                    .compose(bindToLifecycle())
-                    .subscribe {
-                        if (!it.second && !it.first.first.reward().hasAddons())
-                            this.showPledgeFragment.onNext(it.first)
-                        else this.showAlert.onNext(it.first)
                     }
 
-            // - If the selected Reward have AddOns
-            val pledgeDataAndReasonWithAddOns = this.projectDataInput
-                    .compose<Pair<ProjectData, Reward>>(Transformers.takePairWhen(this.rewardClicked))
-                    .filter { it.second.hasAddons() }
-                    .map { pledgeDataAndPledgeReason(it.first, it.second) }
-
-            pledgeDataAndReasonWithAddOns
-                    .filter { it.second == PledgeReason.PLEDGE }
+            pledgeDataAndReason
+                    .compose<Pair<PledgeData, PledgeReason>>(takeWhen(this.rewardClicked))
+                    .compose<Pair<Pair<PledgeData, PledgeReason>, Reward>>(combineLatestPair(backedReward))
                     .compose(bindToLifecycle())
                     .subscribe {
-                        this.showAddOnsFragment.onNext(it)
+                        val pledgeAndData = it.first
+                        val newRw = it.first.first.reward()
+                        val prevRw = it.second
+                        val reason = it.first.second
+
+                        when(reason) {
+                            PledgeReason.UPDATE_REWARD -> {
+                                if (prevRw.hasAddons() && !newRw.hasAddons())
+                                    this.showAlert.onNext(pledgeAndData)
+
+                                if (!prevRw.hasAddons() && !newRw.hasAddons())
+                                    this.showPledgeFragment.onNext(pledgeAndData)
+
+                                if (prevRw.hasAddons() && newRw.hasAddons()) {
+                                    if (differentShippingTypes(prevRw, newRw)) this.showAlert.onNext(it.first)
+                                    else this.showAddOnsFragment.onNext(pledgeAndData)
+                                }
+
+                                if (!prevRw.hasAddons() && newRw.hasAddons()) {
+                                    this.showAddOnsFragment.onNext(pledgeAndData)
+                                }
+                            }
+                        }
                     }
 
-            pledgeDataAndReasonWithAddOns
-                    .filter { it.second == PledgeReason.UPDATE_REWARD }
-                    .compose(bindToLifecycle())
-                    .subscribe(this.showAlert)
-
             project
                     .map { it.rewards()?.size?: 0 }
                     .compose(bindToLifecycle())
@@ -158,6 +155,20 @@ class RewardsFragmentViewModel {
                     }
         }
 
+        private fun getReward(backingObj: Backing): Reward {
+            return backingObj.reward()?.let { rw ->
+                if (backingObj.addOns().isNullOrEmpty()) rw
+                else rw.toBuilder().hasAddons(true).build()
+            } ?: RewardFactory.noReward()
+        }
+
+        private fun differentShippingTypes(newRW: Reward, backedRW: Reward): Boolean {
+            return if (newRW.id() == backedRW.id()) false
+            else {
+                newRW.shippingType()?.toLowerCase() ?: "" != backedRW.shippingType()?.toLowerCase() ?: ""
+            }
+        }
+
         private fun pledgeDataAndPledgeReason(projectData: ProjectData, reward: Reward): Pair<PledgeData, PledgeReason> {
             val pledgeReason = if (projectData.project().isBacking) PledgeReason.UPDATE_REWARD else PledgeReason.PLEDGE
             val pledgeData = PledgeData.with(PledgeFlowContext.forPledgeReason(pledgeReason), projectData, reward)

diff --git a/app/src/test/java/com/kickstarter/viewmodels/ProjectViewModelTest.kt b/app/src/test/java/com/kickstarter/viewmodels/ProjectViewModelTest.kt
@@ -1388,6 +1388,7 @@ class ProjectViewModelTest : KSRobolectricTestCase() {
                 ProjectDataFactory.project(refreshedProject))
         this.showUpdatePledgeSuccess.assertValueCount(1)
         this.updateFragments.assertValues(ProjectDataFactory.project(initialBackedProject),
+                ProjectDataFactory.project(refreshedProject),
                 ProjectDataFactory.project(refreshedProject))
     }
 
@@ -1413,6 +1414,7 @@ class ProjectViewModelTest : KSRobolectricTestCase() {
                 ProjectDataFactory.project(refreshedProject))
         this.showUpdatePledgeSuccess.assertValueCount(1)
         this.updateFragments.assertValues(ProjectDataFactory.project(initialBackedProject),
+                ProjectDataFactory.project(refreshedProject),
                 ProjectDataFactory.project(refreshedProject))
     }