Implement refactor to utilize new donation configuration endpoint.

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/internal/donor/InternalDonorErrorConfigurationViewModel.kt

@@ -11,6 +11,9 @@ import org.signal.donations.StripeDeclineCode
 import org.thoughtcrime.securesms.badges.Badges
 import org.thoughtcrime.securesms.badges.models.Badge
 import org.thoughtcrime.securesms.components.settings.app.subscription.errors.UnexpectedSubscriptionCancellation
+import org.thoughtcrime.securesms.components.settings.app.subscription.getBoostBadges
+import org.thoughtcrime.securesms.components.settings.app.subscription.getGiftBadges
+import org.thoughtcrime.securesms.components.settings.app.subscription.getSubscriptionLevels
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
 import org.thoughtcrime.securesms.jobs.SubscriptionReceiptRequestResponseJob
 import org.thoughtcrime.securesms.keyvalue.SignalStore
@@ -29,28 +32,28 @@ class InternalDonorErrorConfigurationViewModel : ViewModel() {
     val giftBadges: Single<List<Badge>> = Single
       .fromCallable {
         ApplicationDependencies.getDonationsService()
-          .getGiftBadges(Locale.getDefault())
+          .getDonationsConfiguration(Locale.getDefault())
       }
       .flatMap { it.flattenResult() }
-      .map { results -> results.values.map { Badges.fromServiceBadge(it) } }
+      .map { it.getGiftBadges() }
       .subscribeOn(Schedulers.io())
 
     val boostBadges: Single<List<Badge>> = Single
       .fromCallable {
         ApplicationDependencies.getDonationsService()
-          .getBoostBadge(Locale.getDefault())
+          .getDonationsConfiguration(Locale.getDefault())
       }
       .flatMap { it.flattenResult() }
-      .map { listOf(Badges.fromServiceBadge(it)) }
+      .map { it.getBoostBadges() }
       .subscribeOn(Schedulers.io())
 
     val subscriptionBadges: Single<List<Badge>> = Single
       .fromCallable {
         ApplicationDependencies.getDonationsService()
-          .getSubscriptionLevels(Locale.getDefault())
+          .getDonationsConfiguration(Locale.getDefault())
       }
       .flatMap { it.flattenResult() }
-      .map { levels -> levels.levels.values.map { Badges.fromServiceBadge(it.badge) } }
+      .map { config -> config.getSubscriptionLevels().values.map { Badges.fromServiceBadge(it.badge) } }
       .subscribeOn(Schedulers.io())
 
     disposables += Single.zip(giftBadges, boostBadges, subscriptionBadges) { g, b, s ->

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/DonationsConfigurationExtensions.kt

@@ -0,0 +1,123 @@
+package org.thoughtcrime.securesms.components.settings.app.subscription
+
+import org.signal.core.util.money.FiatMoney
+import org.signal.core.util.money.PlatformCurrencyUtil
+import org.thoughtcrime.securesms.badges.Badges
+import org.thoughtcrime.securesms.badges.models.Badge
+import org.whispersystems.signalservice.internal.push.DonationsConfiguration
+import org.whispersystems.signalservice.internal.push.DonationsConfiguration.BOOST_LEVEL
+import org.whispersystems.signalservice.internal.push.DonationsConfiguration.GIFT_LEVEL
+import org.whispersystems.signalservice.internal.push.DonationsConfiguration.LevelConfiguration
+import org.whispersystems.signalservice.internal.push.DonationsConfiguration.SUBSCRIPTION_LEVELS
+import java.math.BigDecimal
+import java.util.Currency
+
+private const val CARD = "CARD"
+private const val PAYPAL = "PAYPAL"
+
+/**
+ * Transforms the DonationsConfiguration into a Set<FiatMoney> which has been properly filtered
+ * for available currencies on the platform and based off user device availability.
+ *
+ * CARD   - Google Pay & Credit Card
+ * PAYPAL - PayPal
+ *
+ * @param level                    The subscription level to get amounts for
+ * @param paymentMethodAvailability Predicate object which checks whether different payment methods are availble.
+ */
+fun DonationsConfiguration.getSubscriptionAmounts(
+  level: Int,
+  paymentMethodAvailability: PaymentMethodAvailability = DefaultPaymentMethodAvailability
+): Set<FiatMoney> {
+  require(SUBSCRIPTION_LEVELS.contains(level))
+
+  return getFilteredCurrencies(paymentMethodAvailability).map { (code, config) ->
+    val amount: BigDecimal = config.subscription[level]!!
+    FiatMoney(amount, Currency.getInstance(code.uppercase()))
+  }.toSet()
+}
+
+/**
+ * Currently, we only support a single gift badge at level GIFT_LEVEL
+ */
+fun DonationsConfiguration.getGiftBadges(): List<Badge> {
+  val configuration = levels[GIFT_LEVEL]
+  return listOfNotNull(configuration?.badge?.let { Badges.fromServiceBadge(it) })
+}
+
+/**
+ * Currently, we only support a single gift badge amount per currency
+ */
+fun DonationsConfiguration.getGiftBadgeAmounts(paymentMethodAvailability: PaymentMethodAvailability = DefaultPaymentMethodAvailability): Map<Currency, FiatMoney> {
+  return getFilteredCurrencies(paymentMethodAvailability).filter {
+    it.value.oneTime[GIFT_LEVEL]?.isNotEmpty() == true
+  }.mapKeys {
+    Currency.getInstance(it.key.uppercase())
+  }.mapValues {
+    FiatMoney(it.value.oneTime[GIFT_LEVEL]!!.first(), it.key)
+  }
+}
+
+/**
+ * Currently, we only support a single boost badge at level BOOST_LEVEL
+ */
+fun DonationsConfiguration.getBoostBadges(): List<Badge> {
+  val configuration = levels[BOOST_LEVEL]
+  return listOfNotNull(configuration?.badge?.let { Badges.fromServiceBadge(it) })
+}
+
+fun DonationsConfiguration.getBoostAmounts(paymentMethodAvailability: PaymentMethodAvailability = DefaultPaymentMethodAvailability): Map<Currency, List<FiatMoney>> {
+  return getFilteredCurrencies(paymentMethodAvailability).filter {
+    it.value.oneTime[BOOST_LEVEL]?.isNotEmpty() == true
+  }.mapKeys {
+    Currency.getInstance(it.key.uppercase())
+  }.mapValues { (currency, config) ->
+    config.oneTime[BOOST_LEVEL]!!.map { FiatMoney(it, currency) }
+  }
+}
+
+fun DonationsConfiguration.getBadge(level: Int): Badge {
+  require(level == GIFT_LEVEL || level == BOOST_LEVEL || SUBSCRIPTION_LEVELS.contains(level))
+  return Badges.fromServiceBadge(levels[level]!!.badge)
+}
+
+fun DonationsConfiguration.getSubscriptionLevels(): Map<Int, LevelConfiguration> {
+  return levels.filterKeys { SUBSCRIPTION_LEVELS.contains(it) }.toSortedMap()
+}
+
+private fun DonationsConfiguration.getFilteredCurrencies(paymentMethodAvailability: PaymentMethodAvailability): Map<String, DonationsConfiguration.CurrencyConfiguration> {
+  val userPaymentMethods = paymentMethodAvailability.toSet()
+  val availableCurrencyCodes = PlatformCurrencyUtil.getAvailableCurrencyCodes()
+  return currencies.filter { (code, config) ->
+    val areAllMethodsAvailable = config.supportedPaymentMethods.containsAll(userPaymentMethods)
+    availableCurrencyCodes.contains(code.uppercase()) && areAllMethodsAvailable
+  }
+}
+
+/**
+ * This interface is available to ease unit testing of the extension methods in
+ * this file. In all normal situations, you can just allow the methods to use the
+ * default value.
+ */
+interface PaymentMethodAvailability {
+  fun isPayPalAvailable(): Boolean
+  fun isGooglePayOrCreditCardAvailable(): Boolean
+
+  fun toSet(): Set<String> {
+    val set = mutableSetOf<String>()
+    if (isPayPalAvailable()) {
+      set.add(PAYPAL)
+    }
+
+    if (isGooglePayOrCreditCardAvailable()) {
+      set.add(CARD)
+    }
+
+    return set
+  }
+}
+
+private object DefaultPaymentMethodAvailability : PaymentMethodAvailability {
+  override fun isPayPalAvailable(): Boolean = InAppDonations.isPayPalAvailable()
+  override fun isGooglePayOrCreditCardAvailable(): Boolean = InAppDonations.isCreditCardAvailable() || InAppDonations.isGooglePayAvailable()
+}

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/InAppDonations.kt

@@ -2,10 +2,9 @@ package org.thoughtcrime.securesms.components.settings.app.subscription
 
 import org.signal.donations.PaymentSourceType
 import org.thoughtcrime.securesms.components.settings.app.subscription.donate.DonateToSignalType
-import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
+import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.util.FeatureFlags
 import org.thoughtcrime.securesms.util.LocaleFeatureFlags
-import org.thoughtcrime.securesms.util.PlayServicesUtil
 
 /**
  * Helper object to determine in-app donations availability.
@@ -42,29 +41,21 @@ object InAppDonations {
   /**
    * Whether the user is in a region that supports credit cards, based off local phone number.
    */
-  private fun isCreditCardAvailable(): Boolean {
+  fun isCreditCardAvailable(): Boolean {
     return FeatureFlags.creditCardPayments() && !LocaleFeatureFlags.isCreditCardDisabled()
   }
 
   /**
    * Whether the user is in a region that supports PayPal, based off local phone number.
    */
-  private fun isPayPalAvailable(): Boolean {
+  fun isPayPalAvailable(): Boolean {
     return (FeatureFlags.paypalOneTimeDonations() || FeatureFlags.paypalRecurringDonations()) && !LocaleFeatureFlags.isPayPalDisabled()
   }
 
   /**
-   * Whether the user is in a region that supports GooglePay, based off local phone number.
+   * Whether the user is using a device that supports GooglePay, based off Wallet API and phone number.
    */
-  private fun isGooglePayAvailable(): Boolean {
-    return isPlayServicesAvailable() && !LocaleFeatureFlags.isGooglePayDisabled()
-  }
-
-  /**
-   * Whether Play Services is available. This will *not* tell you whether a user has Google Pay set up, but is
-   * enough information to determine whether we can display Google Pay as an option.
-   */
-  private fun isPlayServicesAvailable(): Boolean {
-    return PlayServicesUtil.getPlayServicesStatus(ApplicationDependencies.getApplication()) == PlayServicesUtil.PlayServicesStatus.SUCCESS
+  fun isGooglePayAvailable(): Boolean {
+    return SignalStore.donationsValues().isGooglePayReady && !LocaleFeatureFlags.isGooglePayDisabled()
   }
 }

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/MonthlyDonationRepository.kt

@@ -4,7 +4,6 @@ import io.reactivex.rxjava3.core.Completable
 import io.reactivex.rxjava3.core.Single
 import io.reactivex.rxjava3.schedulers.Schedulers
 import org.signal.core.util.logging.Log
-import org.signal.core.util.money.FiatMoney
 import org.thoughtcrime.securesms.badges.Badges
 import org.thoughtcrime.securesms.components.settings.app.subscription.errors.DonationError
 import org.thoughtcrime.securesms.components.settings.app.subscription.errors.DonationErrorSource
@@ -20,15 +19,12 @@ import org.thoughtcrime.securesms.subscription.LevelUpdate
 import org.thoughtcrime.securesms.subscription.LevelUpdateOperation
 import org.thoughtcrime.securesms.subscription.Subscriber
 import org.thoughtcrime.securesms.subscription.Subscription
-import org.thoughtcrime.securesms.util.PlatformCurrencyUtil
 import org.whispersystems.signalservice.api.services.DonationsService
 import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription
 import org.whispersystems.signalservice.api.subscriptions.IdempotencyKey
 import org.whispersystems.signalservice.api.subscriptions.SubscriberId
-import org.whispersystems.signalservice.api.subscriptions.SubscriptionLevels
 import org.whispersystems.signalservice.internal.EmptyResponse
 import org.whispersystems.signalservice.internal.ServiceResponse
-import java.util.Currency
 import java.util.Locale
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
@@ -52,29 +48,23 @@ class MonthlyDonationRepository(private val donationsService: DonationsService)
     }
   }
 
-  fun getSubscriptions(): Single<List<Subscription>> = Single
-    .fromCallable { donationsService.getSubscriptionLevels(Locale.getDefault()) }
-    .subscribeOn(Schedulers.io())
-    .flatMap(ServiceResponse<SubscriptionLevels>::flattenResult)
-    .map { subscriptionLevels ->
-      subscriptionLevels.levels.map { (code, level) ->
-        Subscription(
-          id = code,
-          name = level.name,
-          badge = Badges.fromServiceBadge(level.badge),
-          prices = level.currencies.filter {
-            PlatformCurrencyUtil
-              .getAvailableCurrencyCodes()
-              .contains(it.key)
-          }.map { (currencyCode, price) ->
-            FiatMoney(price, Currency.getInstance(currencyCode))
-          }.toSet(),
-          level = code.toInt()
-        )
-      }.sortedBy {
-        it.level
+  fun getSubscriptions(): Single<List<Subscription>> {
+    return Single
+      .fromCallable { donationsService.getDonationsConfiguration(Locale.getDefault()) }
+      .subscribeOn(Schedulers.io())
+      .flatMap { it.flattenResult() }
+      .map { config ->
+        config.getSubscriptionLevels().map { (level, levelConfig) ->
+          Subscription(
+            id = level.toString(),
+            level = level,
+            name = levelConfig.name,
+            badge = Badges.fromServiceBadge(levelConfig.badge),
+            prices = config.getSubscriptionAmounts(level)
+          )
+        }
       }
-    }
+  }
 
   fun syncAccountRecord(): Completable {
     return Completable.fromAction {

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/OneTimeDonationRepository.kt

@@ -6,7 +6,6 @@ import io.reactivex.rxjava3.schedulers.Schedulers
 import org.signal.core.util.logging.Log
 import org.signal.core.util.money.FiatMoney
 import org.signal.donations.PaymentSourceType
-import org.thoughtcrime.securesms.badges.Badges
 import org.thoughtcrime.securesms.badges.models.Badge
 import org.thoughtcrime.securesms.components.settings.app.subscription.boost.Boost
 import org.thoughtcrime.securesms.components.settings.app.subscription.errors.DonationError
@@ -18,12 +17,8 @@ import org.thoughtcrime.securesms.jobmanager.JobTracker
 import org.thoughtcrime.securesms.jobs.BoostReceiptRequestResponseJob
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.recipients.RecipientId
-import org.thoughtcrime.securesms.util.PlatformCurrencyUtil
-import org.whispersystems.signalservice.api.profiles.SignalServiceProfile
 import org.whispersystems.signalservice.api.services.DonationsService
-import org.whispersystems.signalservice.internal.ServiceResponse
 import org.whispersystems.signalservice.internal.push.DonationProcessor
-import java.math.BigDecimal
 import java.util.Currency
 import java.util.Locale
 import java.util.concurrent.CountDownLatch
@@ -46,14 +41,15 @@ class OneTimeDonationRepository(private val donationsService: DonationsService)
   }
 
   fun getBoosts(): Single<Map<Currency, List<Boost>>> {
-    return Single.fromCallable { donationsService.boostAmounts }
+    return Single.fromCallable { donationsService.getDonationsConfiguration(Locale.getDefault()) }
       .subscribeOn(Schedulers.io())
-      .flatMap(ServiceResponse<Map<String, List<BigDecimal>>>::flattenResult)
-      .map { result ->
-        result
-          .filter { PlatformCurrencyUtil.getAvailableCurrencyCodes().contains(it.key) }
-          .mapKeys { (code, _) -> Currency.getInstance(code) }
-          .mapValues { (currency, prices) -> prices.map { Boost(FiatMoney(it, currency)) } }
+      .flatMap { it.flattenResult() }
+      .map { config ->
+        config.getBoostAmounts().mapValues { (_, value) ->
+          value.map {
+            Boost(it)
+          }
+        }
       }
   }
 
@@ -61,11 +57,11 @@ class OneTimeDonationRepository(private val donationsService: DonationsService)
     return Single
       .fromCallable {
         ApplicationDependencies.getDonationsService()
-          .getBoostBadge(Locale.getDefault())
+          .getDonationsConfiguration(Locale.getDefault())
       }
       .subscribeOn(Schedulers.io())
-      .flatMap(ServiceResponse<SignalServiceProfile.Badge>::flattenResult)
-      .map(Badges::fromServiceBadge)
+      .flatMap { it.flattenResult() }
+      .map { it.getBoostBadges().first() }
   }
 
   fun waitForOneTimeRedemption(

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/DonateToSignalViewModel.kt

@@ -12,6 +12,7 @@ import io.reactivex.rxjava3.subjects.PublishSubject
 import org.signal.core.util.StringUtil
 import org.signal.core.util.logging.Log
 import org.signal.core.util.money.FiatMoney
+import org.signal.core.util.money.PlatformCurrencyUtil
 import org.thoughtcrime.securesms.components.settings.app.subscription.MonthlyDonationRepository
 import org.thoughtcrime.securesms.components.settings.app.subscription.OneTimeDonationRepository
 import org.thoughtcrime.securesms.components.settings.app.subscription.boost.Boost
@@ -25,7 +26,6 @@ import org.thoughtcrime.securesms.subscription.LevelUpdate
 import org.thoughtcrime.securesms.subscription.Subscriber
 import org.thoughtcrime.securesms.subscription.Subscription
 import org.thoughtcrime.securesms.util.InternetConnectionObserver
-import org.thoughtcrime.securesms.util.PlatformCurrencyUtil
 import org.thoughtcrime.securesms.util.rx.RxStore
 import org.whispersystems.signalservice.api.subscriptions.ActiveSubscription
 import org.whispersystems.signalservice.api.subscriptions.SubscriberId

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/donate/gateway/GatewaySelectorViewModel.kt

@@ -8,6 +8,7 @@ import io.reactivex.rxjava3.kotlin.subscribeBy
 import org.signal.donations.PaymentSourceType
 import org.thoughtcrime.securesms.components.settings.app.subscription.InAppDonations
 import org.thoughtcrime.securesms.components.settings.app.subscription.StripeRepository
+import org.thoughtcrime.securesms.keyvalue.SignalStore
 import org.thoughtcrime.securesms.util.rx.RxStore
 
 class GatewaySelectorViewModel(
@@ -39,9 +40,11 @@ class GatewaySelectorViewModel(
   private fun checkIfGooglePayIsAvailable() {
     disposables += repository.isGooglePayAvailable().subscribeBy(
       onComplete = {
+        SignalStore.donationsValues().isGooglePayReady = true
         store.update { it.copy(isGooglePayAvailable = true) }
       },
       onError = {
+        SignalStore.donationsValues().isGooglePayReady = false
         store.update { it.copy(isGooglePayAvailable = false) }
       }
     )

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/receipts/detail/DonationReceiptDetailRepository.kt

@@ -2,6 +2,7 @@ package org.thoughtcrime.securesms.components.settings.app.subscription.receipts
 
 import io.reactivex.rxjava3.core.Single
 import io.reactivex.rxjava3.schedulers.Schedulers
+import org.thoughtcrime.securesms.components.settings.app.subscription.getSubscriptionLevels
 import org.thoughtcrime.securesms.database.SignalDatabase
 import org.thoughtcrime.securesms.database.model.DonationReceiptRecord
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
@@ -13,10 +14,10 @@ class DonationReceiptDetailRepository {
       .fromCallable {
         ApplicationDependencies
           .getDonationsService()
-          .getSubscriptionLevels(Locale.getDefault())
+          .getDonationsConfiguration(Locale.getDefault())
       }
       .flatMap { it.flattenResult() }
-      .map { it.levels[subscriptionLevel.toString()] ?: throw Exception("Subscription level $subscriptionLevel not found") }
+      .map { it.getSubscriptionLevels()[subscriptionLevel] ?: throw Exception("Subscription level $subscriptionLevel not found") }
       .map { it.name }
       .subscribeOn(Schedulers.io())
   }

app/src/main/java/org/thoughtcrime/securesms/components/settings/app/subscription/receipts/list/DonationReceiptListRepository.kt

@@ -3,6 +3,8 @@ package org.thoughtcrime.securesms.components.settings.app.subscription.receipts
 import io.reactivex.rxjava3.core.Single
 import io.reactivex.rxjava3.schedulers.Schedulers
 import org.thoughtcrime.securesms.badges.Badges
+import org.thoughtcrime.securesms.components.settings.app.subscription.getBoostBadges
+import org.thoughtcrime.securesms.components.settings.app.subscription.getSubscriptionLevels
 import org.thoughtcrime.securesms.database.model.DonationReceiptRecord
 import org.thoughtcrime.securesms.dependencies.ApplicationDependencies
 import java.util.Locale
@@ -12,23 +14,23 @@ class DonationReceiptListRepository {
     val boostBadges: Single<List<DonationReceiptBadge>> = Single
       .fromCallable {
         ApplicationDependencies.getDonationsService()
-          .getBoostBadge(Locale.getDefault())
+          .getDonationsConfiguration(Locale.getDefault())
       }
       .map { response ->
         if (response.result.isPresent) {
-          listOf(DonationReceiptBadge(DonationReceiptRecord.Type.BOOST, -1, Badges.fromServiceBadge(response.result.get())))
+          listOf(DonationReceiptBadge(DonationReceiptRecord.Type.BOOST, -1, response.result.get().getBoostBadges().first()))
         } else {
           emptyList()
         }
       }
 
     val subBadges: Single<List<DonationReceiptBadge>> = Single
-      .fromCallable { ApplicationDependencies.getDonationsService().getSubscriptionLevels(Locale.getDefault()) }
+      .fromCallable { ApplicationDependencies.getDonationsService().getDonationsConfiguration(Locale.getDefault()) }
       .map { response ->
         if (response.result.isPresent) {
-          response.result.get().levels.map {
+          response.result.get().getSubscriptionLevels().map {
             DonationReceiptBadge(
-              level = it.key.toInt(),
+              level = it.key,
               badge = Badges.fromServiceBadge(it.value.badge),
               type = DonationReceiptRecord.Type.RECURRING
             )