From 9f6e6bcbbfb45d31cdeb972894c8281762e1ee7a Mon Sep 17 00:00:00 2001 From: Tangem Date: Wed, 16 Feb 2022 13:31:52 +0300 Subject: [PATCH 1/6] Updated on 2026-08-14 --- .../wallet/models/PendingTransaction.kt | 13 ++++++++--- .../middlewares/MultiWalletMiddleware.kt | 23 +++++++++++++++---- .../ui/adapters/PendingTransactionsAdapter.kt | 2 +- 3 files changed, 30 insertions(+), 8 deletions(-) diff --git a/app/src/main/java/com/tangem/tap/features/wallet/models/PendingTransaction.kt b/app/src/main/java/com/tangem/tap/features/wallet/models/PendingTransaction.kt index a449bb17ea..722b2c7d03 100644 --- a/app/src/main/java/com/tangem/tap/features/wallet/models/PendingTransaction.kt +++ b/app/src/main/java/com/tangem/tap/features/wallet/models/PendingTransaction.kt @@ -6,10 +6,12 @@ import com.tangem.blockchain.common.TransactionStatus import com.tangem.blockchain.common.Wallet import com.tangem.tap.common.extensions.toFormattedString import com.tangem.tap.domain.extensions.toSendableAmounts +import java.math.BigDecimal data class PendingTransaction( val address: String?, - val amount: String?, + val amount: BigDecimal?, + val amountUi: String?, val currency: String, val type: PendingTransactionType ) @@ -38,6 +40,7 @@ fun TransactionData.toPendingTransaction(walletAddress: String): PendingTransact return PendingTransaction( if (address == "unknown") null else address, + this.amount.value, this.amount.value?.toFormattedString(amount.decimals), this.amount.currencySymbol, type @@ -61,8 +64,12 @@ fun List.toPendingTransactionsForToken(token: Token, walletAddr return this.mapNotNull { it.toPendingTransactionForToken(token, walletAddress) } } -fun Wallet.getPendingTransactions(): List { - return recentTransactions.toPendingTransactions(address) +fun Wallet.getPendingTransactions(type: PendingTransactionType? = null): List { + val txs = recentTransactions.toPendingTransactions(address) + return when(type) { + null -> txs + else -> txs.filter { it.type == type } + } } fun Wallet.hasPendingTransactions(): Boolean { diff --git a/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/MultiWalletMiddleware.kt b/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/MultiWalletMiddleware.kt index df4c9120f7..25da5ead8b 100644 --- a/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/MultiWalletMiddleware.kt +++ b/app/src/main/java/com/tangem/tap/features/wallet/redux/middlewares/MultiWalletMiddleware.kt @@ -13,6 +13,8 @@ import com.tangem.tap.common.redux.navigation.NavigationAction import com.tangem.tap.currenciesRepository import com.tangem.tap.domain.extensions.makeWalletManagerForApp import com.tangem.tap.domain.extensions.makeWalletManagersForApp +import com.tangem.tap.features.wallet.models.PendingTransactionType +import com.tangem.tap.features.wallet.models.getPendingTransactions import com.tangem.tap.features.wallet.redux.Currency import com.tangem.tap.features.wallet.redux.WalletAction import com.tangem.tap.features.wallet.redux.WalletState @@ -22,6 +24,7 @@ import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.async import kotlinx.coroutines.launch import kotlinx.coroutines.withContext +import java.math.BigDecimal class MultiWalletMiddleware { fun handle( @@ -206,13 +209,25 @@ class MultiWalletMiddleware { scope.launch { when (val result = rentProvider.minimalBalanceForRentExemption()) { is Result.Success -> { + fun isNeedToShowWarning(balance: BigDecimal, rentExempt: BigDecimal): Boolean = balance >= rentExempt + + val balance = walletManager.wallet.fundsAvailable(AmountType.Coin) + val outgoingTxs = walletManager.wallet.getPendingTransactions(PendingTransactionType.Outgoing) + val rentExempt = result.data + val show = if (outgoingTxs.isEmpty()) { + isNeedToShowWarning(balance, rentExempt) + } else { + val outgoingAmount = outgoingTxs.sumOf { it.amount ?: BigDecimal.ZERO } + val rest = balance.minus(outgoingAmount) + isNeedToShowWarning(rest, rentExempt) + } + if (!show) return@launch + val currency = walletManager.wallet.blockchain.currency - val minRent = ("${rentProvider.rentAmount().stripZeroPlainString()} $currency") - val rentExempt = ("${result.data.stripZeroPlainString()} $currency") store.dispatchOnMain(WalletAction.SetWalletRent( blockchain = walletManager.wallet.blockchain, - minRent = minRent, - rentExempt = rentExempt + minRent = ("${rentProvider.rentAmount().stripZeroPlainString()} $currency"), + rentExempt = ("${rentExempt.stripZeroPlainString()} $currency") )) } is Result.Failure -> {} diff --git a/app/src/main/java/com/tangem/tap/features/wallet/ui/adapters/PendingTransactionsAdapter.kt b/app/src/main/java/com/tangem/tap/features/wallet/ui/adapters/PendingTransactionsAdapter.kt index 09c6094d38..31ab7c4368 100644 --- a/app/src/main/java/com/tangem/tap/features/wallet/ui/adapters/PendingTransactionsAdapter.kt +++ b/app/src/main/java/com/tangem/tap/features/wallet/ui/adapters/PendingTransactionsAdapter.kt @@ -62,7 +62,7 @@ class PendingTransactionsAdapter } view.tv_pending_transaction.text = view.context.getString(transactionDescriptionRes) - transaction.amount?.let { view.tv_pending_transaction_amount.text = "$it " } + transaction.amountUi?.let { view.tv_pending_transaction_amount.text = "$it " } view.tv_pending_transaction_currency.text = "${transaction.currency}" if (transaction.address != null) { From 304bc23a3cd6fffd2a52c5c8d58327a7303b10ce Mon Sep 17 00:00:00 2001 From: Tangem Date: Fri, 18 Feb 2022 12:40:46 +0300 Subject: [PATCH 2/6] Updated on 2026-08-14 --- app/build.gradle | 11 +- app/src/main/AndroidManifest.xml | 3 + .../main/java/com/tangem/tap/MainActivity.kt | 24 +- .../java/com/tangem/tap/TapApplication.kt | 7 +- .../tap/common/shop/data/ProductType.kt | 8 + .../tap/common/shop/data/TangemProduct.kt | 7 + .../tangem/tap/common/shop/data/TotalSum.kt | 6 + .../common/shop/googlepay/GooglePayService.kt | 148 +++++++ .../common/shop/googlepay/GooglePayUtil.kt | 137 +++++++ .../tap/common/shop/shopify/ShopifyService.kt | 384 ++++++++++++++++++ .../tap/common/shop/shopify/ShopifyShop.kt | 7 + .../tap/common/shop/shopify/data/Checkout.kt | 134 ++++++ .../common/shop/shopify/data/CheckoutItem.kt | 8 + .../common/shop/shopify/data/Collection.kt | 50 +++ build.gradle | 2 +- 15 files changed, 932 insertions(+), 4 deletions(-) create mode 100644 app/src/main/java/com/tangem/tap/common/shop/data/ProductType.kt create mode 100644 app/src/main/java/com/tangem/tap/common/shop/data/TangemProduct.kt create mode 100644 app/src/main/java/com/tangem/tap/common/shop/data/TotalSum.kt create mode 100644 app/src/main/java/com/tangem/tap/common/shop/googlepay/GooglePayService.kt create mode 100644 app/src/main/java/com/tangem/tap/common/shop/googlepay/GooglePayUtil.kt create mode 100644 app/src/main/java/com/tangem/tap/common/shop/shopify/ShopifyService.kt create mode 100644 app/src/main/java/com/tangem/tap/common/shop/shopify/ShopifyShop.kt create mode 100644 app/src/main/java/com/tangem/tap/common/shop/shopify/data/Checkout.kt create mode 100644 app/src/main/java/com/tangem/tap/common/shop/shopify/data/CheckoutItem.kt create mode 100644 app/src/main/java/com/tangem/tap/common/shop/shopify/data/Collection.kt diff --git a/app/build.gradle b/app/build.gradle index 222ad32676..3a4885cc13 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -38,7 +38,7 @@ android { } debug_beta { initWith release - debuggable false + debuggable true versionNameSuffix "-beta" applicationIdSuffix ".debug" buildConfigField 'String', 'CONFIG_ENVIRONMENT', '\"prod\"' @@ -129,6 +129,15 @@ dependencies { // animation implementation "com.airbnb.android:lottie:3.4.0" + // Shopify + implementation('com.shopify.mobilebuysdk:buy3:12.0.0') { + exclude group: "com.shopify.graphql.support" + exclude module: 'joda-time' + } + + // Google Pay + implementation 'com.google.android.gms:play-services-wallet:19.1.0' + testImplementation 'junit:junit:4.13.2' testImplementation "com.google.truth:truth:1.1.3" androidTestImplementation 'androidx.test.ext:junit:1.1.3' diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index f358215715..b38eacf816 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -39,6 +39,9 @@ tools:ignore="GoogleAppIndexingWarning" tools:replace="android:fullBackupContent"> + { + store.dispatch( + ShopAction.BuyWithGooglePay.HandleGooglePayResponse(resultCode, data) + ) + } + } + } } \ No newline at end of file diff --git a/app/src/main/java/com/tangem/tap/TapApplication.kt b/app/src/main/java/com/tangem/tap/TapApplication.kt index 1d84bd399c..74e957f6c3 100644 --- a/app/src/main/java/com/tangem/tap/TapApplication.kt +++ b/app/src/main/java/com/tangem/tap/TapApplication.kt @@ -12,6 +12,7 @@ import com.tangem.tap.common.images.PicassoHelper import com.tangem.tap.common.redux.AppState import com.tangem.tap.common.redux.appReducer import com.tangem.tap.common.redux.global.GlobalAction +import com.tangem.tap.common.shop.TangemShopService import com.tangem.tap.domain.configurable.config.ConfigManager import com.tangem.tap.domain.configurable.config.FeaturesLocalLoader import com.tangem.tap.domain.configurable.config.FeaturesRemoteLoader @@ -37,6 +38,7 @@ val store = Store( lateinit var preferencesStorage: PreferencesStorage lateinit var currenciesRepository: CurrenciesRepository lateinit var walletConnectRepository: WalletConnectRepository +lateinit var shopService: TangemShopService class TapApplication : Application() { override fun onCreate() { @@ -72,7 +74,10 @@ class TapApplication : Application() { val localLoader = FeaturesLocalLoader(this, moshi) val remoteLoader = FeaturesRemoteLoader(moshi) val configManager = ConfigManager(localLoader, remoteLoader) - configManager.load { store.dispatch(GlobalAction.SetConfigManager(configManager)) } + configManager.load { + store.dispatch(GlobalAction.SetConfigManager(configManager)) + shopService = TangemShopService(this, configManager.config.shopify!!) + } val warningsManager = WarningMessagesManager(RemoteWarningLoader(moshi)) warningsManager.load { store.dispatch(GlobalAction.SetWarningManager(warningsManager)) } } diff --git a/app/src/main/java/com/tangem/tap/common/shop/data/ProductType.kt b/app/src/main/java/com/tangem/tap/common/shop/data/ProductType.kt new file mode 100644 index 0000000000..89116f8096 --- /dev/null +++ b/app/src/main/java/com/tangem/tap/common/shop/data/ProductType.kt @@ -0,0 +1,8 @@ +package com.tangem.tap.common.shop.data + +import com.tangem.tap.common.shop.TangemShopService + +enum class ProductType(val sku: String) { + WALLET_2_CARDS(TangemShopService.TANGEM_WALLET_2_CARDS_SKU), + WALLET_3_CARDS(TangemShopService.TANGEM_WALLET_3_CARDS_SKU) +} \ No newline at end of file diff --git a/app/src/main/java/com/tangem/tap/common/shop/data/TangemProduct.kt b/app/src/main/java/com/tangem/tap/common/shop/data/TangemProduct.kt new file mode 100644 index 0000000000..022af2b4ea --- /dev/null +++ b/app/src/main/java/com/tangem/tap/common/shop/data/TangemProduct.kt @@ -0,0 +1,7 @@ +package com.tangem.tap.common.shop.data + +data class TangemProduct( + val type: ProductType, + val totalSum: TotalSum? = null, + val appliedDiscount: String? = null +) \ No newline at end of file diff --git a/app/src/main/java/com/tangem/tap/common/shop/data/TotalSum.kt b/app/src/main/java/com/tangem/tap/common/shop/data/TotalSum.kt new file mode 100644 index 0000000000..a9e920745f --- /dev/null +++ b/app/src/main/java/com/tangem/tap/common/shop/data/TotalSum.kt @@ -0,0 +1,6 @@ +package com.tangem.tap.common.shop.data + +data class TotalSum( + val finalValue: String? = null, + val beforeDiscount: String? = null, +) \ No newline at end of file diff --git a/app/src/main/java/com/tangem/tap/common/shop/googlepay/GooglePayService.kt b/app/src/main/java/com/tangem/tap/common/shop/googlepay/GooglePayService.kt new file mode 100644 index 0000000000..13c3913ebe --- /dev/null +++ b/app/src/main/java/com/tangem/tap/common/shop/googlepay/GooglePayService.kt @@ -0,0 +1,148 @@ +package com.tangem.tap.common.shop + +import android.app.Activity +import android.app.Activity.RESULT_CANCELED +import android.app.Activity.RESULT_OK +import android.content.Intent +import android.util.Log +import com.google.android.gms.common.api.ApiException +import com.google.android.gms.wallet.* +import com.tangem.common.core.TangemSdkError +import com.tangem.tap.common.shop.googlepay.GooglePayUtil +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext +import org.json.JSONException +import org.json.JSONObject +import timber.log.Timber +import kotlin.coroutines.resume +import kotlin.coroutines.suspendCoroutine + +class GooglePayService(private val paymentsClient: PaymentsClient, private val activity: Activity) { + +// var responseCallback: ((Result) -> Unit)? = null + + suspend fun checkIfGooglePayAvailable(): Result { + + val isReadyToPayJson = GooglePayUtil.isReadyToPayRequest() ?: return Result.success(false) + val request = IsReadyToPayRequest.fromJson(isReadyToPayJson.toString()) + + val task = paymentsClient.isReadyToPay(request) + return withContext(Dispatchers.IO) { + suspendCoroutine { continuation -> + task.addOnCompleteListener { completedTask -> + try { + val result = completedTask.getResult(ApiException::class.java) + continuation.resume(Result.success(true)) + } catch (exception: ApiException) { + // Process error + Timber.w("isReadyToPay failed: $exception") + continuation.resume(Result.failure(exception)) + } + } + } + } + } + + fun payWithGooglePay(totalPriceCents: String, currencyCode: String, merchantID: String) { + val paymentDataRequestJson = GooglePayUtil.getPaymentDataRequest( + totalPriceCents, + currencyCode = currencyCode, + countryCode = "RU", + merchantID = merchantID + ) + if (paymentDataRequestJson == null) { + Timber.e("RequestPayment: can't fetch payment data request") + return + } + val request = PaymentDataRequest.fromJson(paymentDataRequestJson.toString()) + + AutoResolveHelper.resolveTask( + paymentsClient.loadPaymentData(request), activity, LOAD_PAYMENT_DATA_REQUEST_CODE + ) + } + + fun handleResponseFromGooglePay(resultCode: Int, data: Intent?): Result { + val result = when (resultCode) { + RESULT_OK -> { + val paymentData = data?.let { intent -> PaymentData.getFromIntent(intent) } + if (paymentData == null) { + Result.failure(Exception("No payment data")) + } else { + Result.success(paymentData) + } + } + RESULT_CANCELED -> { + Result.failure(TangemSdkError.UserCancelled()) + } + AutoResolveHelper.RESULT_ERROR -> { + val statusCode = AutoResolveHelper.getStatusFromIntent(data)?.statusCode + if (statusCode == null) { + Result.failure(Exception("Unknown Status")) + } else { + Result.failure(Exception("$statusCode")) + } + + } + else -> Result.failure(Exception("Unknown Status")) + } +// responseCallback?.invoke(result) + return result + } + + fun parsePaymentData(paymentData: PaymentData): GooglePayResponse? { + val paymentInformation = paymentData.toJson() + + try { + // Token will be null if PaymentDataRequest was not constructed using fromJson(String). + val paymentMethodData = + JSONObject(paymentInformation).getJSONObject("paymentMethodData") + val addressJson = paymentMethodData.getJSONObject("info") + .getJSONObject("billingAddress") + + val address = Address( + name = addressJson.getString("name"), + postalCode = addressJson.getString("postalCode"), + countryCode = addressJson.getString("countryCode"), + phoneNumber = addressJson.getString("phoneNumber"), + address1 = addressJson.getString("address1"), + address2 = addressJson.getString("address2"), + address3 = addressJson.getString("address3"), + locality = addressJson.getString("locality"), + administrativeArea = addressJson.getString("administrativeArea"), + sortingCode = addressJson.getString("sortingCode"), + ) + + val token = paymentMethodData + .getJSONObject("tokenizationData") + .getString("token") + + return GooglePayResponse(address, token) + + } catch (e: JSONException) { + Log.e("handlePaymentSuccess", "Error: " + e.toString()) + } + return null + } + + companion object { + const val LOAD_PAYMENT_DATA_REQUEST_CODE = 315 + } +} + +data class GooglePayResponse( + val billingAddress: Address, + val token: String, +) + +data class Address( + val name: String, + val postalCode: String, + val countryCode: String, + val phoneNumber: String, + val address1: String, + val address2: String, + val address3: String, + val locality: String, + val administrativeArea: String, + val sortingCode: String +) \ No newline at end of file diff --git a/app/src/main/java/com/tangem/tap/common/shop/googlepay/GooglePayUtil.kt b/app/src/main/java/com/tangem/tap/common/shop/googlepay/GooglePayUtil.kt new file mode 100644 index 0000000000..610ab10c9d --- /dev/null +++ b/app/src/main/java/com/tangem/tap/common/shop/googlepay/GooglePayUtil.kt @@ -0,0 +1,137 @@ +package com.tangem.tap.common.shop.googlepay + +import android.app.Activity +import com.google.android.gms.wallet.PaymentsClient +import com.google.android.gms.wallet.Wallet +import com.google.android.gms.wallet.WalletConstants +import org.json.JSONArray +import org.json.JSONException +import org.json.JSONObject + +object GooglePayUtil { + private val baseRequest = JSONObject().apply { + put("apiVersion", 2) + put("apiVersionMinor", 0) + } + + private fun gatewayTokenizationSpecification(merchantID: String): JSONObject { + return JSONObject().apply { + put("type", "PAYMENT_GATEWAY") + put( + "parameters", JSONObject( + mapOf( + "gateway" to "shopify", + "gatewayMerchantId" to merchantID + ) + ) + ) + } + } + + private val allowedCardNetworks = JSONArray( + listOf( + "AMEX", + "DISCOVER", + "INTERAC", + "JCB", + "MASTERCARD", + "VISA" + ) + ) + + private val allowedCardAuthMethods = JSONArray( + listOf( + "PAN_ONLY", + "CRYPTOGRAM_3DS" + ) + ) + + private fun baseCardPaymentMethod(): JSONObject { + return JSONObject().apply { + + val parameters = JSONObject().apply { + put("allowedAuthMethods", allowedCardAuthMethods) + put("allowedCardNetworks", allowedCardNetworks) + put("billingAddressRequired", true) + put("billingAddressParameters", JSONObject().apply { + put("format", "FULL") + }) + } + + put("type", "CARD") + put("parameters", parameters) + } + } + + private fun cardPaymentMethod(merchantID: String): JSONObject { + val cardPaymentMethod = baseCardPaymentMethod() + cardPaymentMethod.put("tokenizationSpecification", gatewayTokenizationSpecification(merchantID)) + + return cardPaymentMethod + } + + fun createPaymentsClient(activity: Activity): PaymentsClient { + val walletOptions = Wallet.WalletOptions.Builder() + .setEnvironment(PAYMENTS_ENVIRONMENT) + .build() + + return Wallet.getPaymentsClient(activity, walletOptions) + } + + fun isReadyToPayRequest(): JSONObject? { + return try { + baseRequest.apply { + put("allowedPaymentMethods", JSONArray().put(baseCardPaymentMethod())) + } + + } catch (e: JSONException) { + null + } + } + + private fun getTransactionInfo( + price: String, + countryCode: String, + currencyCode: String + ): JSONObject { + return JSONObject().apply { + put("totalPrice", price) + put("totalPriceStatus", "FINAL") + put("countryCode", countryCode) + put("currencyCode", currencyCode) + } + } + + private val merchantInfo: JSONObject = + JSONObject().put("merchantName", "Example Merchant") + + + fun getPaymentDataRequest( + price: String, + countryCode: String, + currencyCode: String, + merchantID: String + ): JSONObject? { + try { + return baseRequest.apply { + put("allowedPaymentMethods", JSONArray().put(cardPaymentMethod(merchantID))) + put("transactionInfo", getTransactionInfo(price, countryCode, currencyCode)) + put("merchantInfo", merchantInfo) + + // An optional shipping address requirement is a top-level property of the + // PaymentDataRequest JSON object. + val shippingAddressParameters = JSONObject().apply { + put("phoneNumberRequired", false) +// put("allowedCountryCodes", JSONArray(listOf("US", "GB"))) + } + put("shippingAddressParameters", shippingAddressParameters) + put("shippingAddressRequired", true) + } + } catch (e: JSONException) { + return null + } + } +} + + +const val PAYMENTS_ENVIRONMENT = WalletConstants.ENVIRONMENT_TEST \ No newline at end of file diff --git a/app/src/main/java/com/tangem/tap/common/shop/shopify/ShopifyService.kt b/app/src/main/java/com/tangem/tap/common/shop/shopify/ShopifyService.kt new file mode 100644 index 0000000000..da24d1337d --- /dev/null +++ b/app/src/main/java/com/tangem/tap/common/shop/shopify/ShopifyService.kt @@ -0,0 +1,384 @@ +package com.tangem.tap.common.shop + +import android.app.Application +import com.shopify.buy3.GraphCallResult +import com.shopify.buy3.GraphClient +import com.shopify.buy3.RetryHandler +import com.shopify.buy3.Storefront.* +import com.shopify.graphql.support.ID +import com.shopify.graphql.support.Input +import com.tangem.tap.common.shop.shopify.ShopifyShop +import com.tangem.tap.common.shop.shopify.data.CheckoutItem +import com.tangem.tap.common.shop.shopify.data.checkoutFieldsFragment +import com.tangem.tap.common.shop.shopify.data.collectionFieldsFragment +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext +import java.util.concurrent.TimeUnit +import kotlin.coroutines.resume +import kotlin.coroutines.suspendCoroutine + + +class ShopifyService(private val application: Application, val shop: ShopifyShop) { + val client: GraphClient by lazy { initClient() } + + + suspend fun getShopName(): Result { + val query = query { rootQuery: QueryRootQuery -> + rootQuery + .shop { shopQuery: ShopQuery -> + shopQuery + .name() + } + } + return when (val result = queryAsync(query)) { + is GraphCallResult.Success -> { + val name = result.response.data!!.shop.name + Result.success(name) + } + is GraphCallResult.Failure -> { + Result.failure(result.error) + } + } + } + + suspend fun getProducts(collectionTitleFilter: String? = null): Result> { + val filter = collectionTitleFilter?.let { "title:\"$it\"" } + + val query = query { rootQuery: QueryRootQuery -> + rootQuery + .collections( + { arg -> arg.first(250).query(filter) }, + ) { collectionConnectionQuery -> + collectionConnectionQuery.collectionFieldsFragment() + } + } + return when (val result = queryAsync(query)) { + is GraphCallResult.Success -> { + val products = result.response.data!!.collections.edges + .map { it.node.products } + .flatMap { it.edges } + .map { it.node } + Result.success(products) + } + is GraphCallResult.Failure -> { + Result.failure(result.error) + } + } + } + + suspend fun checkout(pollUntilOrder: Boolean, checkoutID: ID): Result { + + val query = query { rootQuery: QueryRootQuery -> + rootQuery + .node(checkoutID) { query -> + query.onCheckout { checkoutQuery -> + with(checkoutQuery) { + checkoutFieldsFragment() + } + } + } + } + val retryHandler = RetryHandler.build( + 1, TimeUnit.SECONDS + ) { + this.retryWhen { result -> + when (result) { + is GraphCallResult.Success -> { + val checkout = result.response.data?.node as? Checkout + checkout == null + } + is GraphCallResult.Failure -> false + } + } + } + + val result = if (pollUntilOrder) queryAsync(query, retryHandler) else queryAsync(query) + return when (result) { + is GraphCallResult.Success -> { + val checkout = result.response.data!!.node as? Checkout + if (checkout != null) { + Result.success(checkout) + } else { + Result.failure(ShopifyError.Unknown) + } + + } + is GraphCallResult.Failure -> { + Result.failure(result.error) + } + } + } + + suspend fun createCheckout( + checkoutItems: List, + checkoutID: ID? = null + ): Result { + + + val storefrontLineItems: MutableList = checkoutItems + .map { CheckoutLineItemInput(it.quantity, it.id) }.toMutableList() + + val query = if (checkoutID != null) { + mutation { mutationQuery: MutationQuery -> + mutationQuery + .checkoutLineItemsReplace( + storefrontLineItems, checkoutID + ) { payloadQuery: CheckoutLineItemsReplacePayloadQuery -> + payloadQuery + .checkout { checkoutQuery: CheckoutQuery -> + checkoutQuery.checkoutFieldsFragment() + } + .userErrors() { userErrorQuery: CheckoutUserErrorQuery -> + userErrorQuery + .field() + .message() + } + } + } + } else { + val input = CheckoutCreateInput() + .setLineItemsInput( + Input.value(storefrontLineItems) + ) + mutation { mutationQuery: MutationQuery -> + mutationQuery + .checkoutCreate( + input + ) { payloadQuery: CheckoutCreatePayloadQuery -> + payloadQuery + .checkout { checkoutQuery: CheckoutQuery -> + checkoutQuery.checkoutFieldsFragment() + } + .checkoutUserErrors() { userErrorQuery: CheckoutUserErrorQuery -> + userErrorQuery + .field() + .message() + } + } + } + } + return runCheckoutMutation(query) + } + + suspend fun applyDiscount(discountCode: String, checkoutID: ID): Result { + val query = mutation { mutationQuery: MutationQuery -> + mutationQuery + .checkoutDiscountCodeApplyV2( + discountCode, checkoutID + ) { payloadQuery: CheckoutDiscountCodeApplyV2PayloadQuery -> + payloadQuery + .checkout { checkoutQuery: CheckoutQuery -> + checkoutQuery.checkoutFieldsFragment() + } + .checkoutUserErrors() { userErrorQuery: CheckoutUserErrorQuery -> + userErrorQuery + .field() + .message() + } + } + } + return runCheckoutMutation(query) + } + + suspend fun removeDiscount(checkoutID: ID): Result { + val query = mutation { mutationQuery: MutationQuery -> + mutationQuery + .checkoutDiscountCodeRemove( + checkoutID + ) { payloadQuery: CheckoutDiscountCodeRemovePayloadQuery -> + payloadQuery + .checkout { checkoutQuery: CheckoutQuery -> + checkoutQuery.checkoutFieldsFragment() + } + .checkoutUserErrors() { userErrorQuery: CheckoutUserErrorQuery -> + userErrorQuery + .field() + .message() + } + } + } + return runCheckoutMutation(query) + } + + suspend fun updateAddress( + address: MailingAddress, + checkoutID: ID, + waitForShippingRates: Boolean + ): Result { + val input = MailingAddressInput() + .setAddress1(address.address1) + .setAddress2(address.address2) + .setCity(address.city) + .setCountry(address.country) + .setFirstName(address.firstName) + .setLastName(address.lastName) + .setPhone(address.phone) + .setProvince(address.province) + .setZip(address.zip) + + val query = mutation { mutationQuery: MutationQuery -> + mutationQuery + .checkoutShippingAddressUpdateV2( + input, checkoutID + ) { shippingAddressUpdatePayloadQuery: CheckoutShippingAddressUpdateV2PayloadQuery -> + shippingAddressUpdatePayloadQuery + .checkout { checkoutQuery: CheckoutQuery -> + checkoutQuery.checkoutFieldsFragment() + } + .checkoutUserErrors { userErrorQuery: CheckoutUserErrorQuery -> + userErrorQuery + .field() + .message() + } + } + } + + return runCheckoutMutation(query) + } + + suspend fun updateEmail(email: String?, checkoutID: ID): Result { + val query = mutation { mutationQuery: MutationQuery -> + mutationQuery + .checkoutEmailUpdateV2( + checkoutID, email + ) { emailUpdatePayloadQuery: CheckoutEmailUpdateV2PayloadQuery -> + emailUpdatePayloadQuery + .checkout { checkoutQuery: CheckoutQuery -> + checkoutQuery.checkoutFieldsFragment() + } + .checkoutUserErrors() { userErrorQuery: CheckoutUserErrorQuery -> + userErrorQuery + .field() + .message() + } + } + } + return runCheckoutMutation(query) + } + + suspend fun updateShippingRate(handle: String?, checkoutID: ID): Result { + val query = mutation { mutationQuery: MutationQuery -> + mutationQuery + .checkoutShippingLineUpdate( + checkoutID, handle + ) { shippingLineUpdatePayloadQuery: CheckoutShippingLineUpdatePayloadQuery -> + shippingLineUpdatePayloadQuery + .checkout { checkoutQuery: CheckoutQuery -> + checkoutQuery.checkoutFieldsFragment() + } + .checkoutUserErrors() { userErrorQuery: CheckoutUserErrorQuery -> + userErrorQuery + .field() + .message() + } + } + } + return runCheckoutMutation(query) + } + + suspend fun completeWithTokenizedPayment( + payment: TokenizedPaymentInputV3, + checkoutID: ID + ): Result { + + val query = mutation { mutationQuery: MutationQuery -> + mutationQuery + .checkoutCompleteWithTokenizedPaymentV3( + checkoutID, payment + ) { payloadQuery: CheckoutCompleteWithTokenizedPaymentV3PayloadQuery -> + payloadQuery + .payment { paymentQuery: PaymentQuery -> + paymentQuery + .ready() + .errorMessage() + } + .checkout { checkoutQuery: CheckoutQuery -> + checkoutQuery + .ready() + } + .checkoutUserErrors() { userErrorQuery: CheckoutUserErrorQuery -> + userErrorQuery + .field() + .message() + } + } + } + return runCheckoutMutation(query) + } + + fun startGooglePaySession() { +// PaySession() + } + + private suspend fun runCheckoutMutation(mutation: MutationQuery): Result { + return when (val result = mutationQueryAsync(mutation)) { + is GraphCallResult.Success -> { + val checkout = result.response.data!!.checkoutCreate?.checkout + ?: result.response.data!!.checkoutDiscountCodeApplyV2?.checkout + ?: result.response.data!!.checkoutDiscountCodeRemove?.checkout + ?: result.response.data!!.checkoutShippingAddressUpdateV2?.checkout + ?: result.response.data!!.checkoutEmailUpdateV2?.checkout + ?: result.response.data!!.checkoutShippingLineUpdate?.checkout + ?: result.response.data!!.checkoutCompleteWithTokenizedPaymentV3.checkout + + Result.success(checkout) + } + is GraphCallResult.Failure -> Result.failure(result.error) + } + } + + private suspend fun queryAsync( + query: QueryRootQuery, + retryHandler: RetryHandler + ): GraphCallResult = + withContext(Dispatchers.IO) { + suspendCoroutine { continuation -> + client.queryGraph(query).enqueue(retryHandler = retryHandler) { result -> + continuation.resume(result) + } + } + } + + private suspend fun queryAsync( + query: QueryRootQuery, + ): GraphCallResult = + withContext(Dispatchers.IO) { + suspendCoroutine { continuation -> + client.queryGraph(query).enqueue { result -> + continuation.resume(result) + } + } + } + + private suspend fun mutationQueryAsync(query: MutationQuery): GraphCallResult = + withContext(Dispatchers.IO) { + suspendCoroutine { continuation -> + client.mutateGraph(query).enqueue { result -> + continuation.resume(result) + } + } + } + + + private fun initClient(): GraphClient { + return GraphClient.build( + application, + shop.domain, + shop.storefrontApiKey + ) { +// httpCache(application.filesDir) { +// cacheMaxSizeBytes = (1024 * 1024 * 10) +// defaultCachePolicy = +// HttpCachePolicy.Default.CACHE_FIRST.expireAfter(20, TimeUnit.MINUTES) +// } + } + + } +} + + +sealed class ShopifyError : Throwable() { + object Unknown : ShopifyError() + object GooglePayFailed : ShopifyError() + class UserError(val errorMessage: String) +} \ No newline at end of file diff --git a/app/src/main/java/com/tangem/tap/common/shop/shopify/ShopifyShop.kt b/app/src/main/java/com/tangem/tap/common/shop/shopify/ShopifyShop.kt new file mode 100644 index 0000000000..a2244b7442 --- /dev/null +++ b/app/src/main/java/com/tangem/tap/common/shop/shopify/ShopifyShop.kt @@ -0,0 +1,7 @@ +package com.tangem.tap.common.shop.shopify + +data class ShopifyShop( + val domain: String, + val storefrontApiKey: String, + val merchantID: String, +) \ No newline at end of file diff --git a/app/src/main/java/com/tangem/tap/common/shop/shopify/data/Checkout.kt b/app/src/main/java/com/tangem/tap/common/shop/shopify/data/Checkout.kt new file mode 100644 index 0000000000..849c1f33c3 --- /dev/null +++ b/app/src/main/java/com/tangem/tap/common/shop/shopify/data/Checkout.kt @@ -0,0 +1,134 @@ +package com.tangem.tap.common.shop.shopify.data + +import com.shopify.buy3.Storefront + +fun Storefront.CheckoutQuery.checkoutFieldsFragment() { + // id() + ready() + webUrl() + currencyCode() + lineItemsSubtotalPrice { it.amount() } + totalPriceV2 { + it.currencyCode() + it.amount() } + lineItems({ arg -> arg.first(250) }) { + it.edges { + it.node { +// it.id() + it.title() + it.quantity() + it.variant() { + it.priceV2() { it.amount() } + } + } + } + } + shippingLine { + it.handle() + it.title() + it.priceV2 { it.amount() } + } + availableShippingRates { + it.ready() + it.shippingRates { + it.handle() + it.title() + it.priceV2 { it.amount() } + } + } + shippingAddress { + it.address1() + it.address2() + it.city() +// .company() + it.country() +// .countryCodeV2() + it.firstName() +// .formatted() +// .formattedArea() +// .id() + it.lastName() +// .latitude() +// .longitude() +// .name() + it.phone() + it.province() +// .provinceCode() + it.zip() + } + discountApplications({ arg -> arg.first(250) }) { + it.edges { + it.node { + it.onDiscountCodeApplication { + it.code() +// .applicable() +// .allocationMethod() +// .targetSelection() +// .targetType() + it.value { + it.onMoneyV2 { + it.amount() + } + it.onPricingPercentageValue { + it.percentage() + } + } + } + } + } + } + order { + it.cancelReason() + it.canceledAt() + it.currencyCode() +// .currentSubtotalPrice() +// .currentTotalDuties() +// .currentTotalPrice() +// .currentTotalTax() + it.customerLocale() + it.customerUrl() +// .discountApplications() + it.edited() + it.email() + it.financialStatus() + it.fulfillmentStatus() +// .id() +// .lineItems() +// .metafield() +// .metafields() + it.name() + it.orderNumber() +// .originalTotalDuties() +// .originalTotalPrice() + it.phone() + it.processedAt() + it.shippingAddress { + it.address1() + it.address2() + it.city() + it.company() + it.country() + it.countryCodeV2() + it.firstName() + it.formatted() + it.formattedArea() +// .id() + it.lastName() + it.latitude() + it.longitude() + it.name() + it.phone() + it.province() + it.provinceCode() + it.zip() + } +// .shippingDiscountAllocations() + it.statusUrl() +// .subtotalPriceV2() +// .successfulFulfillments() +// .totalPriceV2() +// .totalRefundedV2() +// .totalShippingPriceV2() +// .totalTaxV2() + } +} \ No newline at end of file diff --git a/app/src/main/java/com/tangem/tap/common/shop/shopify/data/CheckoutItem.kt b/app/src/main/java/com/tangem/tap/common/shop/shopify/data/CheckoutItem.kt new file mode 100644 index 0000000000..5dc508df40 --- /dev/null +++ b/app/src/main/java/com/tangem/tap/common/shop/shopify/data/CheckoutItem.kt @@ -0,0 +1,8 @@ +package com.tangem.tap.common.shop.shopify.data + +import com.shopify.graphql.support.ID + +data class CheckoutItem( + val id: ID, + val quantity: Int +) \ No newline at end of file diff --git a/app/src/main/java/com/tangem/tap/common/shop/shopify/data/Collection.kt b/app/src/main/java/com/tangem/tap/common/shop/shopify/data/Collection.kt new file mode 100644 index 0000000000..572a7b68c7 --- /dev/null +++ b/app/src/main/java/com/tangem/tap/common/shop/shopify/data/Collection.kt @@ -0,0 +1,50 @@ +package com.tangem.tap.common.shop.shopify.data + +import com.shopify.buy3.Storefront + +fun Storefront.CollectionConnectionQuery.collectionFieldsFragment() { + edges { collectionEdgeQuery -> + collectionEdgeQuery + .node { collectionQuery -> + collectionQuery + .title() + .products({ arg -> arg.first(250) } + ) { productConnectionQuery -> + productConnectionQuery + .edges { productEdgeQuery -> + productEdgeQuery + .node { productQuery -> + productQuery.title() + .productType() + .description() + .variants({ arg -> arg.first(10) }) { variantConnectionQuery -> + variantConnectionQuery.edges { variantQuery -> + variantQuery.node { + it.title() + it.sku() + it.currentlyNotInStock() + it.priceV2 { + it.amount() + it.currencyCode() + } + it.compareAtPriceV2 { + it.amount() + it.currencyCode() + } + it.compareAtPriceV2 { + it.amount() + } + it.product { + it.title() + .productType() + .description() + } + } + } + } + } + } + } + } + } +} \ No newline at end of file diff --git a/build.gradle b/build.gradle index 0ac373259b..23b9e4d0bc 100644 --- a/build.gradle +++ b/build.gradle @@ -10,7 +10,7 @@ buildscript { classpath "com.android.tools.build:gradle:${versions.build_gradle}" classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$versions.kotlin" classpath "com.github.dcendents:android-maven-gradle-plugin:2.1" - classpath 'com.google.gms:google-services:4.3.8' + classpath 'com.google.gms:google-services:4.3.10' classpath 'com.google.firebase:firebase-crashlytics-gradle:2.7.1' } } From 20421a758cb1d0e6ea5ef24fc69ed36c48235825 Mon Sep 17 00:00:00 2001 From: Tangem Date: Fri, 18 Feb 2022 12:42:00 +0300 Subject: [PATCH 3/6] Updated on 2026-08-14 --- .../tap/common/extensions/Navigation.kt | 2 + .../com/tangem/tap/common/redux/AppReducer.kt | 4 +- .../com/tangem/tap/common/redux/AppState.kt | 6 +- .../redux/navigation/NavigationState.kt | 1 + .../tap/common/shop/TangemShopService.kt | 216 ++++++++++ .../configurable/config/ConfigManager.kt | 10 +- .../domain/configurable/config/JsonModels.kt | 3 + .../tap/features/home/redux/HomeMiddleware.kt | 3 +- .../wallet/ui/OnboardingWalletFragment.kt | 4 +- ...kupCardsWidget.kt => WalletCardsWidget.kt} | 2 +- .../tap/features/shop/redux/ShopAction.kt | 38 ++ .../tap/features/shop/redux/ShopMiddleware.kt | 116 ++++++ .../tap/features/shop/redux/ShopReducer.kt | 68 ++++ .../tap/features/shop/redux/ShopState.kt | 25 ++ .../tap/features/shop/ui/ShopFragment.kt | 167 ++++++++ app/src/main/res/color/selector_chip_shop.xml | 11 + .../res/color/selector_chip_shop_text.xml | 11 + .../buy_with_googlepay_button_content.xml | 60 +++ .../buy_with_googlepay_button_content.xml | 54 +++ .../buy_with_googlepay_button_content.xml | 54 +++ app/src/main/res/drawable-ldpi/card_new.png | Bin 0 -> 226541 bytes .../buy_with_googlepay_button_content.xml | 54 +++ .../googlepay_button_background_image.9.png | Bin 0 -> 963 bytes ...ay_button_no_shadow_background_image.9.png | Bin 0 -> 263 bytes .../googlepay_button_background_image.9.png | Bin 0 -> 3186 bytes ...ay_button_no_shadow_background_image.9.png | Bin 0 -> 679 bytes .../googlepay_button_background_image.9.png | Bin 0 -> 4280 bytes ...ay_button_no_shadow_background_image.9.png | Bin 0 -> 819 bytes .../buy_with_googlepay_button_content.xml | 54 +++ .../drawable/googlepay_button_background.xml | 6 + .../res/drawable/googlepay_button_content.xml | 48 +++ .../googlepay_button_no_shadow_background.xml | 6 + .../res/drawable/googlepay_button_overlay.xml | 12 + app/src/main/res/drawable/ic_clear_24.xml | 5 + app/src/main/res/drawable/ic_promo_code.xml | 11 + app/src/main/res/drawable/ic_shipping.xml | 11 + app/src/main/res/drawable/shape_line.xml | 8 + .../drawable/shape_rectangle_rounded_4.xml | 8 + .../res/layout/buy_with_googlepay_button.xml | 31 ++ app/src/main/res/layout/fragment_shop.xml | 375 ++++++++++++++++++ .../main/res/layout/test_shopify_fragment.xml | 87 ++++ app/src/main/res/values/colors.xml | 5 + app/src/main/res/values/googlepay_strings.xml | 12 + .../main/res/values/strings_untranslated.xml | 12 + app/src/main/res/values/styles.xml | 9 + 45 files changed, 1599 insertions(+), 10 deletions(-) create mode 100644 app/src/main/java/com/tangem/tap/common/shop/TangemShopService.kt rename app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/{BackupCardsWidget.kt => WalletCardsWidget.kt} (99%) create mode 100644 app/src/main/java/com/tangem/tap/features/shop/redux/ShopAction.kt create mode 100644 app/src/main/java/com/tangem/tap/features/shop/redux/ShopMiddleware.kt create mode 100644 app/src/main/java/com/tangem/tap/features/shop/redux/ShopReducer.kt create mode 100644 app/src/main/java/com/tangem/tap/features/shop/redux/ShopState.kt create mode 100644 app/src/main/java/com/tangem/tap/features/shop/ui/ShopFragment.kt create mode 100644 app/src/main/res/color/selector_chip_shop.xml create mode 100644 app/src/main/res/color/selector_chip_shop_text.xml create mode 100755 app/src/main/res/drawable-de/buy_with_googlepay_button_content.xml create mode 100755 app/src/main/res/drawable-fr/buy_with_googlepay_button_content.xml create mode 100755 app/src/main/res/drawable-it/buy_with_googlepay_button_content.xml create mode 100644 app/src/main/res/drawable-ldpi/card_new.png create mode 100755 app/src/main/res/drawable-ru/buy_with_googlepay_button_content.xml create mode 100755 app/src/main/res/drawable-xhdpi/googlepay_button_background_image.9.png create mode 100755 app/src/main/res/drawable-xhdpi/googlepay_button_no_shadow_background_image.9.png create mode 100755 app/src/main/res/drawable-xxhdpi/googlepay_button_background_image.9.png create mode 100755 app/src/main/res/drawable-xxhdpi/googlepay_button_no_shadow_background_image.9.png create mode 100755 app/src/main/res/drawable-xxxhdpi/googlepay_button_background_image.9.png create mode 100755 app/src/main/res/drawable-xxxhdpi/googlepay_button_no_shadow_background_image.9.png create mode 100755 app/src/main/res/drawable/buy_with_googlepay_button_content.xml create mode 100755 app/src/main/res/drawable/googlepay_button_background.xml create mode 100755 app/src/main/res/drawable/googlepay_button_content.xml create mode 100755 app/src/main/res/drawable/googlepay_button_no_shadow_background.xml create mode 100755 app/src/main/res/drawable/googlepay_button_overlay.xml create mode 100644 app/src/main/res/drawable/ic_clear_24.xml create mode 100644 app/src/main/res/drawable/ic_promo_code.xml create mode 100644 app/src/main/res/drawable/ic_shipping.xml create mode 100644 app/src/main/res/drawable/shape_line.xml create mode 100644 app/src/main/res/drawable/shape_rectangle_rounded_4.xml create mode 100755 app/src/main/res/layout/buy_with_googlepay_button.xml create mode 100644 app/src/main/res/layout/fragment_shop.xml create mode 100644 app/src/main/res/layout/test_shopify_fragment.xml create mode 100755 app/src/main/res/values/googlepay_strings.xml diff --git a/app/src/main/java/com/tangem/tap/common/extensions/Navigation.kt b/app/src/main/java/com/tangem/tap/common/extensions/Navigation.kt index 30d8e1b18a..5fdd3a9279 100644 --- a/app/src/main/java/com/tangem/tap/common/extensions/Navigation.kt +++ b/app/src/main/java/com/tangem/tap/common/extensions/Navigation.kt @@ -19,6 +19,7 @@ import com.tangem.tap.features.onboarding.products.otherCards.OnboardingOtherCar import com.tangem.tap.features.onboarding.products.twins.ui.TwinsCardsFragment import com.tangem.tap.features.onboarding.products.wallet.ui.OnboardingWalletFragment import com.tangem.tap.features.send.ui.SendFragment +import com.tangem.tap.features.shop.ui.ShopFragment import com.tangem.tap.features.tokens.ui.AddTokensFragment import com.tangem.tap.features.wallet.ui.WalletDetailsFragment import com.tangem.tap.features.wallet.ui.WalletFragment @@ -69,6 +70,7 @@ fun FragmentActivity.addOnBackPressedDispatcher( private fun fragmentFactory(screen: AppScreen): Fragment { return when (screen) { AppScreen.Home -> HomeFragment() + AppScreen.Shop -> ShopFragment() AppScreen.OnboardingNote -> OnboardingNoteFragment() AppScreen.OnboardingWallet -> OnboardingWalletFragment() AppScreen.OnboardingTwins -> TwinsCardsFragment() diff --git a/app/src/main/java/com/tangem/tap/common/redux/AppReducer.kt b/app/src/main/java/com/tangem/tap/common/redux/AppReducer.kt index d797ff9010..cbfa2565fb 100644 --- a/app/src/main/java/com/tangem/tap/common/redux/AppReducer.kt +++ b/app/src/main/java/com/tangem/tap/common/redux/AppReducer.kt @@ -11,6 +11,7 @@ import com.tangem.tap.features.onboarding.products.otherCards.redux.OnboardingOt import com.tangem.tap.features.onboarding.products.twins.redux.TwinCardsReducer import com.tangem.tap.features.onboarding.products.wallet.redux.OnboardingWalletReducer import com.tangem.tap.features.send.redux.reducers.SendScreenReducer +import com.tangem.tap.features.shop.redux.ShopReducer import com.tangem.tap.features.tokens.redux.TokensReducer import com.tangem.tap.features.wallet.redux.reducers.WalletReducer import org.rekotlin.Action @@ -32,7 +33,8 @@ fun appReducer(action: Action, state: AppState?): AppState { detailsState = DetailsReducer.reduce(action, state), disclaimerState = DisclaimerReducer.reduce(action, state), tokensState = TokensReducer.reduce(action, state), - walletConnectState = WalletConnectReducer.reduce(action, state.walletConnectState) + walletConnectState = WalletConnectReducer.reduce(action, state.walletConnectState), + shopState = ShopReducer.reduce(action, state.shopState), ) } diff --git a/app/src/main/java/com/tangem/tap/common/redux/AppState.kt b/app/src/main/java/com/tangem/tap/common/redux/AppState.kt index d3c6f3656b..719386cad9 100644 --- a/app/src/main/java/com/tangem/tap/common/redux/AppState.kt +++ b/app/src/main/java/com/tangem/tap/common/redux/AppState.kt @@ -23,6 +23,8 @@ import com.tangem.tap.features.onboarding.products.wallet.redux.OnboardingWallet import com.tangem.tap.features.onboarding.products.wallet.redux.OnboardingWalletState import com.tangem.tap.features.send.redux.middlewares.SendMiddleware import com.tangem.tap.features.send.redux.states.SendState +import com.tangem.tap.features.shop.redux.ShopMiddleware +import com.tangem.tap.features.shop.redux.ShopState import com.tangem.tap.features.tokens.redux.TokensMiddleware import com.tangem.tap.features.tokens.redux.TokensState import com.tangem.tap.features.wallet.redux.WalletState @@ -44,6 +46,7 @@ data class AppState( val disclaimerState: DisclaimerState = DisclaimerState(), val tokensState: TokensState = TokensState(), val walletConnectState: WalletConnectState = WalletConnectState(), + val shopState: ShopState = ShopState(), ) : StateType { companion object { @@ -62,7 +65,8 @@ data class AppState( DisclaimerMiddleware().disclaimerMiddleware, TokensMiddleware().tokensMiddleware, WalletConnectMiddleware().walletConnectMiddleware, - BackupMiddleware().backupMiddleware + BackupMiddleware().backupMiddleware, + ShopMiddleware().shopMiddleware, ) } } diff --git a/app/src/main/java/com/tangem/tap/common/redux/navigation/NavigationState.kt b/app/src/main/java/com/tangem/tap/common/redux/navigation/NavigationState.kt index 61e3d263da..6f68439f61 100644 --- a/app/src/main/java/com/tangem/tap/common/redux/navigation/NavigationState.kt +++ b/app/src/main/java/com/tangem/tap/common/redux/navigation/NavigationState.kt @@ -11,6 +11,7 @@ data class NavigationState( enum class AppScreen { Home, + Shop, Disclaimer, OnboardingNote, OnboardingWallet, OnboardingTwins, OnboardingOther, Wallet, WalletDetails, diff --git a/app/src/main/java/com/tangem/tap/common/shop/TangemShopService.kt b/app/src/main/java/com/tangem/tap/common/shop/TangemShopService.kt new file mode 100644 index 0000000000..d428a9d197 --- /dev/null +++ b/app/src/main/java/com/tangem/tap/common/shop/TangemShopService.kt @@ -0,0 +1,216 @@ +package com.tangem.tap.common.shop + +import android.app.Application +import android.content.Intent +import com.google.android.gms.wallet.PaymentData +import com.shopify.buy3.Storefront +import com.tangem.tap.common.shop.data.ProductType +import com.tangem.tap.common.shop.data.TangemProduct +import com.tangem.tap.common.shop.data.TotalSum +import com.tangem.tap.common.shop.shopify.ShopifyShop +import com.tangem.tap.common.shop.shopify.data.CheckoutItem +import kotlinx.coroutines.async +import kotlinx.coroutines.awaitAll +import kotlinx.coroutines.coroutineScope +import java.math.BigDecimal +import java.util.* + +class TangemShopService(application: Application, shopifyShop: ShopifyShop) { + + private val shopifyService = ShopifyService(application, shopifyShop) + + private lateinit var product: Storefront.Product + + private val checkouts = mutableMapOf() + private val variants = mutableMapOf() + + private lateinit var googlePayService: GooglePayService + + suspend fun getProducts(): Result> { + val result = shopifyService.getProducts() + + result.onSuccess { + product = it.first { + val variantsSku = it.variants.edges.map { it.node.sku } + variantsSku.contains(ProductType.WALLET_2_CARDS.sku) && variantsSku.contains( + ProductType.WALLET_3_CARDS.sku + ) + } + product.variants.edges.map { it.node } + .forEach { variant -> + if (variant.sku == ProductType.WALLET_2_CARDS.sku) { + variants[ProductType.WALLET_2_CARDS] = variant + } else if (variant.sku == ProductType.WALLET_3_CARDS.sku) { + variants[ProductType.WALLET_3_CARDS] = variant + } + } + + + val twoCardsProduct = TangemProduct( + type = ProductType.WALLET_2_CARDS, + totalSum = TotalSum( + finalValue = variants[ProductType.WALLET_2_CARDS]?.priceV2?.format(), + beforeDiscount = variants[ProductType.WALLET_2_CARDS]?.compareAtPriceV2?.format() + ) + ) + val threeCardsProduct = TangemProduct( + type = ProductType.WALLET_3_CARDS, + totalSum = TotalSum( + finalValue = variants[ProductType.WALLET_3_CARDS]?.priceV2?.format(), + beforeDiscount = variants[ProductType.WALLET_3_CARDS]?.compareAtPriceV2?.format() + ) + ) + createCheckouts() + return Result.success(listOf(twoCardsProduct, threeCardsProduct)) + } + return Result.failure(result.exceptionOrNull()!!) + } + + private suspend fun createCheckouts() { + variants.keys.map { coroutineScope { async { createCheckout(it) } } }.awaitAll() + } + + private suspend fun createCheckout(productType: ProductType) { + val checkoutItem = CheckoutItem(variants[productType]!!.id, 1) + val result = shopifyService.createCheckout(listOf(checkoutItem)) + result.onSuccess { checkout -> + checkouts[productType] = checkout + } + } + + suspend fun checkIfGooglePayAvailable(googlePayService: GooglePayService): Result { + this.googlePayService = googlePayService + return googlePayService.checkIfGooglePayAvailable() + } + + fun buyWithGooglePay(productType: ProductType) { + val totalPrice = checkouts[productType]!!.totalPriceV2.amount + googlePayService.payWithGooglePay( + totalPriceCents = totalPrice, currencyCode = checkouts[productType]!!.currencyCode.name, + merchantID = shopifyService.shop.merchantID + ) + } + +// fun subscribeToGooglePayResult( +// productType: ProductType, +// resultCallback: (Result) -> Unit +// ) { +// googlePayService.responseCallback = { result -> +// result.onFailure { } +// result.onSuccess { +// completeTokenizedPayment(it, productType) +// } +// } +// } + + suspend fun handleGooglePayResult( + resultCode: Int, + data: Intent?, + productType: ProductType + ): Result { + val result = googlePayService.handleResponseFromGooglePay(resultCode, data) + result.onSuccess { + val finalizePaymentResult = completeTokenizedPayment(it, productType) + finalizePaymentResult.onSuccess { + return Result.success(Unit) + } + return Result.failure(finalizePaymentResult.exceptionOrNull()!!) + } + return Result.failure(result.exceptionOrNull()!!) + } + + private suspend fun completeTokenizedPayment( + paymentData: PaymentData, + productType: ProductType + ): Result { + val checkout = checkouts[productType]!! + val googlePayResponse = + googlePayService.parsePaymentData(paymentData) + ?: return Result.failure(Exception("cannot parse GPay result")) + + val amount = + Storefront.MoneyInput(checkout.totalPriceV2.amount, checkout.totalPriceV2.currencyCode) + val idempotencyKey = UUID.randomUUID().toString() + val addressGPay = googlePayResponse.billingAddress + + val address = Storefront.MailingAddressInput().apply { + lastName = addressGPay.name + address1 = addressGPay.address1 + address2 = addressGPay.address2 + addressGPay.address3 + province = addressGPay.administrativeArea + zip = addressGPay.postalCode + phone = addressGPay.phoneNumber + } + + + val payment = Storefront.TokenizedPaymentInputV3( + amount, + idempotencyKey, + address, + paymentData.toJson(), + Storefront.PaymentTokenType.GOOGLE_PAY + ) + .setTest(true) + + return shopifyService.completeWithTokenizedPayment( + payment = payment, + checkoutID = checkout.id + ) + } + + suspend fun applyPromoCode(promoCode: String): Result> { + val products = variants.keys + .map { coroutineScope { async { applyPromoCode(promoCode, it) } } } + .awaitAll() + .map { result -> result.getOrElse { return Result.failure(it) } } + + return Result.success(products) + } + + suspend fun applyPromoCode(promoCode: String, productType: ProductType): Result { + val checkout = checkouts[productType] ?: return Result.failure(Exception("No checkout")) + + val result = if (promoCode.isBlank()) { + shopifyService.removeDiscount(checkout.id) + } else { + shopifyService.applyDiscount(promoCode, checkout.id) + } + + result.onSuccess { + checkouts[productType] = it + return Result.success( + TangemProduct( + productType, + TotalSum( + finalValue = it.totalPriceV2.format(), + beforeDiscount = variants[productType]!!.compareAtPriceV2.format() + ), + appliedDiscount = it.getAppliedDiscount() + ) + + ) + } + return Result.failure(result.exceptionOrNull()!!) + } + + fun getCheckoutUrl(productType: ProductType): String { + return checkouts[productType]!!.webUrl + } + + companion object { + const val TANGEM_WALLET_2_CARDS_SKU = "TG115x2" + const val TANGEM_WALLET_3_CARDS_SKU = "TG115x3" + } +} + +private fun Storefront.MoneyV2.format(): String { + val currencySymbol = Currency.getInstance(currencyCode.name).symbol + val amountFormatted = BigDecimal(amount).setScale(2) + return currencySymbol + amountFormatted +} + +private fun Storefront.Checkout.getAppliedDiscount(): String? { + val discountApplication = + discountApplications.edges.firstOrNull()?.node as? Storefront.DiscountCodeApplication + return discountApplication?.code +} \ No newline at end of file diff --git a/app/src/main/java/com/tangem/tap/domain/configurable/config/ConfigManager.kt b/app/src/main/java/com/tangem/tap/domain/configurable/config/ConfigManager.kt index 412537befb..365cdcff90 100644 --- a/app/src/main/java/com/tangem/tap/domain/configurable/config/ConfigManager.kt +++ b/app/src/main/java/com/tangem/tap/domain/configurable/config/ConfigManager.kt @@ -2,6 +2,7 @@ package com.tangem.tap.domain.configurable.config import com.tangem.blockchain.common.BlockchainSdkConfig import com.tangem.common.extensions.VoidCallback +import com.tangem.tap.common.shop.shopify.ShopifyShop import com.tangem.tap.domain.configurable.Loader /** @@ -16,7 +17,8 @@ data class Config( val isSendingToPayIdEnabled: Boolean = true, val isTopUpEnabled: Boolean = false, @Deprecated("Not relevant since version 3.23") - val isCreatingTwinCardsAllowed: Boolean = false + val isCreatingTwinCardsAllowed: Boolean = false, + val shopify: ShopifyShop? = null ) class ConfigManager( @@ -52,10 +54,10 @@ class ConfigManager( fun resetToDefault(name: String) { when (name) { isSendingToPayIdEnabled -> config = - config.copy(isSendingToPayIdEnabled = defaultConfig.isSendingToPayIdEnabled) + config.copy(isSendingToPayIdEnabled = defaultConfig.isSendingToPayIdEnabled) isTopUpEnabled -> config = config.copy(isTopUpEnabled = defaultConfig.isTopUpEnabled) isCreatingTwinCardsAllowed -> config = - config.copy(isCreatingTwinCardsAllowed = defaultConfig.isCreatingTwinCardsAllowed) + config.copy(isCreatingTwinCardsAllowed = defaultConfig.isCreatingTwinCardsAllowed) } } @@ -87,6 +89,7 @@ class ConfigManager( infuraProjectId = values.infuraProjectId ), appsFlyerDevKey = values.appsFlyerDevKey, + shopify = values.shopify, ) defaultConfig = defaultConfig.copy( coinMarketCapKey = values.coinMarketCapKey, @@ -99,6 +102,7 @@ class ConfigManager( infuraProjectId = values.infuraProjectId ), appsFlyerDevKey = values.appsFlyerDevKey, + shopify = values.shopify, ) } diff --git a/app/src/main/java/com/tangem/tap/domain/configurable/config/JsonModels.kt b/app/src/main/java/com/tangem/tap/domain/configurable/config/JsonModels.kt index edbbf6345c..3ed4044447 100644 --- a/app/src/main/java/com/tangem/tap/domain/configurable/config/JsonModels.kt +++ b/app/src/main/java/com/tangem/tap/domain/configurable/config/JsonModels.kt @@ -1,5 +1,7 @@ package com.tangem.tap.domain.configurable.config +import com.tangem.tap.common.shop.shopify.ShopifyShop + /** [REDACTED_AUTHOR] */ @@ -20,6 +22,7 @@ class ConfigValueModel( val blockcypherTokens: Set?, val infuraProjectId: String?, val appsFlyerDevKey: String, + val shopify: ShopifyShop? ) class ConfigModel(val features: FeatureModel?, val configValues: ConfigValueModel?) { diff --git 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 index fb59fee5b6..95eada77e7 100644 --- 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 @@ -4,7 +4,6 @@ import com.tangem.tap.common.analytics.AnalyticsEvent import com.tangem.tap.common.analytics.AnalyticsParam import com.tangem.tap.common.analytics.GetCardSourceParams import com.tangem.tap.common.entities.IndeterminateProgressButton -import com.tangem.tap.common.extensions.dispatchOpenUrl import com.tangem.tap.common.extensions.onCardScanned import com.tangem.tap.common.extensions.withMainContext import com.tangem.tap.common.post @@ -50,7 +49,7 @@ private val homeMiddleware: Middleware = { dispatch, state -> } is HomeAction.ReadCard -> handleReadCard() is HomeAction.GoToShop -> { - store.dispatchOpenUrl(HomeMiddleware.CARD_SHOP_URI) + store.dispatch(NavigationAction.NavigateTo(AppScreen.Shop)) store.state.globalState.analyticsHandlers?.triggerEvent( event = AnalyticsEvent.GET_CARD, params = mapOf(AnalyticsParam.SOURCE.param to GetCardSourceParams.WELCOME.param) diff --git 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 index 398ee44b55..d63d66047c 100644 --- 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 @@ -32,7 +32,7 @@ class OnboardingWalletFragment : Fragment(R.layout.fragment_onboarding_wallet), StoreSubscriber, FragmentOnBackPressedHandler { private var accessCodeDialog: AccessCodeDialog? = null - private lateinit var cardsWidget: BackupCardsWidget + private lateinit var cardsWidget: WalletCardsWidget override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) @@ -48,7 +48,7 @@ class OnboardingWalletFragment : Fragment(R.layout.fragment_onboarding_wallet), super.onViewCreated(view, savedInstanceState) val leapfrog = LeapfrogWidget(fl_cards_container) - cardsWidget = BackupCardsWidget(leapfrog) { 200f } + cardsWidget = WalletCardsWidget(leapfrog) { 200f } startPostponedEnterTransition() view_pager_backup_info.adapter = BackupInfoAdapter() diff --git a/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/BackupCardsWidget.kt b/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/WalletCardsWidget.kt similarity index 99% rename from app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/BackupCardsWidget.kt rename to app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/WalletCardsWidget.kt index 1b4ecba2a7..0efdbf3d0b 100644 --- a/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/BackupCardsWidget.kt +++ b/app/src/main/java/com/tangem/tap/features/onboarding/products/wallet/ui/WalletCardsWidget.kt @@ -10,7 +10,7 @@ import com.tangem.tangem_sdk_new.ui.widget.leapfrogWidget.LeapView import com.tangem.tangem_sdk_new.ui.widget.leapfrogWidget.LeapViewState import com.tangem.tangem_sdk_new.ui.widget.leapfrogWidget.LeapfrogWidget -class BackupCardsWidget( +class WalletCardsWidget( val leapfrogWidget: LeapfrogWidget, val getTopOfAnchorViewForActivateState: () -> Float, ) { diff --git a/app/src/main/java/com/tangem/tap/features/shop/redux/ShopAction.kt b/app/src/main/java/com/tangem/tap/features/shop/redux/ShopAction.kt new file mode 100644 index 0000000000..9f7e7937b4 --- /dev/null +++ b/app/src/main/java/com/tangem/tap/features/shop/redux/ShopAction.kt @@ -0,0 +1,38 @@ +package com.tangem.tap.features.shop.redux + +import android.content.Intent +import com.tangem.tap.common.shop.GooglePayService +import com.tangem.tap.common.shop.data.ProductType +import com.tangem.tap.common.shop.data.TangemProduct +import org.rekotlin.Action + +sealed class ShopAction : Action { + + object LoadProducts : ShopAction() { + data class Success(val products: List) : ShopAction() + } + + data class ApplyPromoCode(val promoCode: String) : ShopAction() { + data class Success(val promoCode: String?, val products: List) : ShopAction() + object InvalidPromoCode : ShopAction() + } + + object BuyWithGooglePay : ShopAction() { + object UserCancelled : ShopAction() + data class HandleGooglePayResponse(val resultCode: Int, val data: Intent?) : ShopAction() + + data class Failure(val exception: Throwable) : ShopAction() + object Success : ShopAction() + } + + object StartWebCheckout : ShopAction() + + data class CheckIfGooglePayAvailable(val googlePayService: GooglePayService) : ShopAction() { + object Success : ShopAction() + object Failure : ShopAction() + } + + data class SelectProduct(val productType: ProductType) : ShopAction() + + object ResetState : ShopAction() +} \ No newline at end of file diff --git a/app/src/main/java/com/tangem/tap/features/shop/redux/ShopMiddleware.kt b/app/src/main/java/com/tangem/tap/features/shop/redux/ShopMiddleware.kt new file mode 100644 index 0000000000..605d5fe9d2 --- /dev/null +++ b/app/src/main/java/com/tangem/tap/features/shop/redux/ShopMiddleware.kt @@ -0,0 +1,116 @@ +package com.tangem.tap.features.shop.redux + +import com.tangem.tap.common.extensions.dispatchOnMain +import com.tangem.tap.common.extensions.dispatchOpenUrl +import com.tangem.tap.common.redux.AppState +import com.tangem.tap.common.redux.navigation.AppScreen +import com.tangem.tap.common.redux.navigation.NavigationAction +import com.tangem.tap.scope +import com.tangem.tap.shopService +import com.tangem.tap.store +import kotlinx.coroutines.launch +import org.rekotlin.Action +import org.rekotlin.Middleware + +class ShopMiddleware { + + val shopMiddleware: Middleware = { dispatch, state -> + { next -> + { action -> + handle(action) + next(action) + } + } + } +} + +private fun handle(action: Action) { + + val shopState = store.state.shopState + + if (action is NavigationAction.NavigateTo && action.screen == AppScreen.Shop) { + store.dispatch(ShopAction.LoadProducts) + } + + if (action !is ShopAction) return + + when (action) { + is ShopAction.ApplyPromoCode -> { + scope.launch { + if (action.promoCode.isBlank() && shopState.promoCode == null) { + store.dispatchOnMain(ShopAction.ApplyPromoCode.InvalidPromoCode) + return@launch + } + + val result = shopService.applyPromoCode(action.promoCode) + + result.onSuccess { products -> + store.dispatchOnMain( + ShopAction.ApplyPromoCode.Success( + promoCode = products.first { it.type == shopState.selectedProduct }.appliedDiscount, + products = products + ) + ) + } + result.onFailure { store.dispatchOnMain(ShopAction.ApplyPromoCode.InvalidPromoCode) } + } + } + ShopAction.BuyWithGooglePay -> { + shopService.buyWithGooglePay(shopState.selectedProduct) +// shopService.subscribeToGooglePayResult(productType = shopState.selectedProduct) { result -> +// result.onSuccess { +// store.dispatch(ShopAction.BuyWithGooglePay.Success) +// } +// result.onFailure { error -> +// if (error is TangemSdkError.UserCancelled) { +// store.dispatch(ShopAction.BuyWithGooglePay.UserCancelled) +// } else { +// store.dispatch(ShopAction.BuyWithGooglePay.Failure(error)) +// } +// } +// } + } + is ShopAction.BuyWithGooglePay.HandleGooglePayResponse -> { + scope.launch { + val result = shopService.handleGooglePayResult( + action.resultCode, + action.data, + shopState.selectedProduct + ) + result.onSuccess { + store.dispatchOnMain(ShopAction.BuyWithGooglePay.Success) + } + result.onFailure { + store.dispatchOnMain(ShopAction.BuyWithGooglePay.Failure(it)) + } + } + + } + ShopAction.LoadProducts -> { + scope.launch { + val result = shopService.getProducts() + result.onSuccess { + store.dispatchOnMain(ShopAction.LoadProducts.Success(it)) + } + } + } + is ShopAction.CheckIfGooglePayAvailable -> { + scope.launch { + val isAvailable = + shopService.checkIfGooglePayAvailable(action.googlePayService).getOrNull() + ?: false + val newAction = if (isAvailable) { + ShopAction.CheckIfGooglePayAvailable.Success + } else { + ShopAction.CheckIfGooglePayAvailable.Failure + } + store.dispatchOnMain(newAction) + + } + } + ShopAction.StartWebCheckout -> { + store.dispatchOpenUrl(shopService.getCheckoutUrl(shopState.selectedProduct)) + } + } + +} \ No newline at end of file diff --git a/app/src/main/java/com/tangem/tap/features/shop/redux/ShopReducer.kt b/app/src/main/java/com/tangem/tap/features/shop/redux/ShopReducer.kt new file mode 100644 index 0000000000..8d4b4ff2a7 --- /dev/null +++ b/app/src/main/java/com/tangem/tap/features/shop/redux/ShopReducer.kt @@ -0,0 +1,68 @@ +package com.tangem.tap.features.shop.redux + +import org.rekotlin.Action + +class ShopReducer { + companion object { + fun reduce(action: Action, state: ShopState): ShopState = internalReduce(action, state) + } +} + +private fun internalReduce(action: Action, state: ShopState): ShopState { + + if (action !is ShopAction) return state + + return when (action) { + is ShopAction.ApplyPromoCode -> state.copy( + promoCode = action.promoCode, + promoCodeLoading = true + ) + ShopAction.BuyWithGooglePay -> state + ShopAction.LoadProducts -> state + is ShopAction.LoadProducts.Success -> { + state.copy( + availableProducts = action.products, + ) + } + ShopAction.StartWebCheckout -> state + ShopAction.ApplyPromoCode.InvalidPromoCode -> state.copy( + promoCode = null, promoCodeLoading = false + ) + is ShopAction.ApplyPromoCode.Success -> { + state.copy( + promoCode = action.promoCode, + availableProducts = action.products, + promoCodeLoading = false + + ) + } + is ShopAction.SelectProduct -> { + state.copy( + selectedProduct = action.productType, + ) + } + is ShopAction.CheckIfGooglePayAvailable -> { + state + } + ShopAction.CheckIfGooglePayAvailable.Failure -> { + state.copy(isGooglePayAvailable = false) + } + ShopAction.CheckIfGooglePayAvailable.Success -> { + state.copy(isGooglePayAvailable = false) // TODO: change when we add support for GPay + + } + is ShopAction.BuyWithGooglePay.Failure -> { + state + } + is ShopAction.BuyWithGooglePay.HandleGooglePayResponse -> { + state + } + ShopAction.BuyWithGooglePay.Success -> { + state + } + ShopAction.BuyWithGooglePay.UserCancelled -> { + state + } + ShopAction.ResetState -> ShopState() + } +} \ No newline at end of file diff --git a/app/src/main/java/com/tangem/tap/features/shop/redux/ShopState.kt b/app/src/main/java/com/tangem/tap/features/shop/redux/ShopState.kt new file mode 100644 index 0000000000..a4ead917a3 --- /dev/null +++ b/app/src/main/java/com/tangem/tap/features/shop/redux/ShopState.kt @@ -0,0 +1,25 @@ +package com.tangem.tap.features.shop.redux + +import com.tangem.tap.common.shop.data.ProductType +import com.tangem.tap.common.shop.data.TangemProduct +import org.rekotlin.StateType + +data class ShopState( + val availableProducts: List = emptyList(), + val selectedProduct: ProductType = ProductType.WALLET_3_CARDS, + val promoCode: String? = null, + val promoCodeLoading: Boolean = false, + val isGooglePayAvailable: Boolean = false, // TODO: change when we add support for GPay +) : StateType { + val total: String? + get() = availableProducts.firstOrNull { it.type == selectedProduct }?.totalSum?.finalValue + + val priceBeforeDiscount: String? + get() { + val totalSum = availableProducts.firstOrNull { it.type == selectedProduct }?.totalSum + if (totalSum?.finalValue != totalSum?.beforeDiscount) { + return totalSum?.beforeDiscount + } + return null + } +} diff --git a/app/src/main/java/com/tangem/tap/features/shop/ui/ShopFragment.kt b/app/src/main/java/com/tangem/tap/features/shop/ui/ShopFragment.kt new file mode 100644 index 0000000000..27a20c0842 --- /dev/null +++ b/app/src/main/java/com/tangem/tap/features/shop/ui/ShopFragment.kt @@ -0,0 +1,167 @@ +package com.tangem.tap.features.shop.ui + +import android.animation.Animator +import android.animation.AnimatorListenerAdapter +import android.content.Context +import android.os.Bundle +import android.view.View +import android.view.View.OnFocusChangeListener +import android.view.inputmethod.EditorInfo +import android.view.inputmethod.InputMethodManager +import androidx.activity.OnBackPressedCallback +import com.tangem.tap.common.KeyboardObserver +import com.tangem.tap.common.extensions.show +import com.tangem.tap.common.redux.navigation.NavigationAction +import com.tangem.tap.common.shop.data.ProductType +import com.tangem.tap.features.BaseStoreFragment +import com.tangem.tap.features.shop.redux.ShopAction +import com.tangem.tap.features.shop.redux.ShopState +import com.tangem.tap.store +import com.tangem.wallet.R +import kotlinx.android.synthetic.main.fragment_shop.* +import org.rekotlin.StoreSubscriber + + +class ShopFragment : BaseStoreFragment(R.layout.fragment_shop), StoreSubscriber { + + + override fun subscribeToStore() { + store.subscribe(this) { state -> + state.skipRepeats { oldState, newState -> + oldState.shopState == newState.shopState + }.select { it.shopState } + } + storeSubscribersList.add(this) + } + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + activity?.onBackPressedDispatcher?.addCallback(this, object : OnBackPressedCallback(true) { + override fun handleOnBackPressed() { + store.dispatch(NavigationAction.PopBackTo()) + store.dispatch(ShopAction.ResetState) + } + }) + } + + override fun onViewCreated(view: View, savedInstanceState: Bundle?) { + super.onViewCreated(view, savedInstanceState) + + setupCardsImages() + setupProductSelection() + setupPromoCodeEditText() + + toolbar.setNavigationOnClickListener { + requireActivity().onBackPressed() + } + + + val keyboardObserver = KeyboardObserver(requireActivity()) + keyboardObserver.registerListener { isVisible -> + fl_cards.show(!isVisible) + } + } + + private fun setupCardsImages() { + imv_second.animate() + .translationY(70f) + .scaleX(0.9f) + .scaleY(0.9f) + .start() + imv_third.animate() + .translationY(140f) + .scaleX(0.8f) + .scaleY(0.8f) + .start() + } + + private fun setupProductSelection() { + chip_product_1.setOnCheckedChangeListener { _, isChecked -> + if (isChecked) store.dispatch(ShopAction.SelectProduct(ProductType.WALLET_3_CARDS)) + } + chip_product_2.setOnCheckedChangeListener { _, isChecked -> + if (isChecked) store.dispatch(ShopAction.SelectProduct(ProductType.WALLET_2_CARDS)) + } + } + + private fun setupPromoCodeEditText() { + et_promo_code.setOnEditorActionListener { view, actionId, event -> + if (actionId == EditorInfo.IME_ACTION_DONE) { + val imm: InputMethodManager = + requireContext().getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager + imm.hideSoftInputFromWindow(view.windowToken, 0) + view.clearFocus() + return@setOnEditorActionListener true + } + return@setOnEditorActionListener false + } + + et_promo_code.onFocusChangeListener = OnFocusChangeListener { _, hasFocus -> + if (!hasFocus) { + store.dispatch(ShopAction.ApplyPromoCode(et_promo_code.text.toString())) + } + } + } + + override fun newState(state: ShopState) { + if (activity == null) return + + animateProductSelection(state.selectedProduct) + handlePriceState(state) + handlePromoCodeState(state) + handleButtonsState(state) + } + + private fun animateProductSelection(selectedProduct: ProductType) { + val show = when (selectedProduct) { + ProductType.WALLET_2_CARDS -> false + ProductType.WALLET_3_CARDS -> true + } + showOrHideThirdCardWithAnimation(show) + } + + private fun showOrHideThirdCardWithAnimation(show: Boolean) { + val translationY = if (show) 140f else 0f + if (show) imv_third.show() + imv_third.animate() + .translationY(translationY) + .setListener(object : AnimatorListenerAdapter() { + override fun onAnimationEnd(animation: Animator) { + super.onAnimationEnd(animation) + imv_third?.show(show) + } + }) + } + + private fun handlePriceState(state: ShopState) { + tv_total.text = state.total + tv_total_before_discount.text = state.priceBeforeDiscount + + pb_price.show(state.total == null) + + } + + private fun handlePromoCodeState(state: ShopState) { + if (state.promoCode == null && !et_promo_code.hasFocus()) { + et_promo_code.setText("") + } + pb_promo_code.show(state.promoCodeLoading) + } + + private fun handleButtonsState(state: ShopState) { + btn_pay_google_pay.show(state.isGooglePayAvailable) + btn_alternative_payment.show(state.isGooglePayAvailable) + btn_main_action.show(!state.isGooglePayAvailable) + + if (state.total != null) { + btn_alternative_payment.setOnClickListener { store.dispatch(ShopAction.StartWebCheckout) } + btn_main_action.setOnClickListener { store.dispatch(ShopAction.StartWebCheckout) } + btn_pay_google_pay.setOnClickListener { store.dispatch(ShopAction.BuyWithGooglePay) } + } + } + + override fun handleOnBackPressed() { + store.dispatch(ShopAction.ResetState) + super.handleOnBackPressed() + } +} \ No newline at end of file diff --git a/app/src/main/res/color/selector_chip_shop.xml b/app/src/main/res/color/selector_chip_shop.xml new file mode 100644 index 0000000000..052f962892 --- /dev/null +++ b/app/src/main/res/color/selector_chip_shop.xml @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/color/selector_chip_shop_text.xml b/app/src/main/res/color/selector_chip_shop_text.xml new file mode 100644 index 0000000000..5d5afc33ff --- /dev/null +++ b/app/src/main/res/color/selector_chip_shop_text.xml @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable-de/buy_with_googlepay_button_content.xml b/app/src/main/res/drawable-de/buy_with_googlepay_button_content.xml new file mode 100755 index 0000000000..e1e2577110 --- /dev/null +++ b/app/src/main/res/drawable-de/buy_with_googlepay_button_content.xml @@ -0,0 +1,60 @@ + + + + + + + + + + + diff --git a/app/src/main/res/drawable-fr/buy_with_googlepay_button_content.xml b/app/src/main/res/drawable-fr/buy_with_googlepay_button_content.xml new file mode 100755 index 0000000000..4be47da569 --- /dev/null +++ b/app/src/main/res/drawable-fr/buy_with_googlepay_button_content.xml @@ -0,0 +1,54 @@ + + + + + + + + + + diff --git a/app/src/main/res/drawable-it/buy_with_googlepay_button_content.xml b/app/src/main/res/drawable-it/buy_with_googlepay_button_content.xml new file mode 100755 index 0000000000..477793d6e5 --- /dev/null +++ b/app/src/main/res/drawable-it/buy_with_googlepay_button_content.xml @@ -0,0 +1,54 @@ + + + + + + + + + + diff --git a/app/src/main/res/drawable-ldpi/card_new.png b/app/src/main/res/drawable-ldpi/card_new.png new file mode 100644 index 0000000000000000000000000000000000000000..465b2c23f76970f8631a9c828c3674f2ab683bc4 GIT binary patch literal 226541 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%0Ay$6zIE1l{wc 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

G*O*MSZ~r0s^rt_` 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 + + + + + + + + + diff --git a/app/src/main/res/drawable-xhdpi/googlepay_button_background_image.9.png b/app/src/main/res/drawable-xhdpi/googlepay_button_background_image.9.png new file mode 100755 index 0000000000000000000000000000000000000000..40f767d533619695ffc8e9a1befd128066d07453 GIT binary patch literal 963 zcmeAS@N?(olHy`uVBq!ia0vp^Q6S903?%u>HW~n_KLI`=u0R?H{{R2q(9jSX8tMQ9 z4GqR=AOPfgdU^r{fDB(>UpF^5kZfqEWoW3MpP!413y2#KVB_u0D!`K5fLjZD^@l(Q#Ut8CMKX(CnqPMdUI!ITW4oe2QNDp7h`vK zXJ=0egGeiTCm_S#-pR_z)ymPu-pR?%(b3k$Jy%si z3}{VANswPK!+%C5piWj+Hg*n9E}(6ky!-+Jf|k>7eBl$F`&az1&;m!X`LcIKl)s8= zN$5)IN$G!kxIWcxhjHLlHQR_i(mGBdmAjsP_YIGYPfSd7^Y-=gPg~_)&cMK=?NRiABe;OLCKAP;fMP2LjUZ``lE-?-r1$nLba=E%C-qLI@Ly zzT9%Hp+Zydp2@E>crGOUwchrX^Xey+bCM5i{5E+q2z#tNBjDU(tlhhQecxrDwi7nJ zKb4i1oY~Iv(Ja{M0E>d=5rxFF`Mn7_vwmiI_V_4sa@-I&d}gCWJlolqAE$kp^pAVt z|4*+}_b!?KWm4QF?|9ZZOQHas;j%{B>RQ%23 zH;X-2zh66xS7`#@yI&7xuG^DlzP{$^*`;+cw|;2J2FuCI+2noS+PFjWac}sR7DuxUf(FlARyop$oBK43#ZqGdecd#YtL|; z$@|0gFVdQ&MBb@0RIG63jhEB literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-xxhdpi/googlepay_button_background_image.9.png b/app/src/main/res/drawable-xxhdpi/googlepay_button_background_image.9.png new file mode 100755 index 0000000000000000000000000000000000000000..91035e2a412021ff692b27dca058e6428d2d6a25 GIT binary patch literal 3186 zcmZWsc{CJi8&@>M*u{`6L$bzLsH=9KQ>I-?=0hH<(;Z2A>B zdbj@@bt6ZZhAYj{t|;kJ#es>Hir|)r$%xkd(Q9URnHOpK%&!N@A|{I_5bSRRc#C`w zmFyFkgA=FnCT_jN%g2Rj8fx7t_^`f9YYxC z;P;PPltB!61^j6wx(wiXk)IR+=`Z!Y;D`@#E(0VVn$jGJ22klfD)*@NR zn~`{soUz-LKBEZp*V9^}P?4)29dnNqcK1q(Y~^=uH!KLWP5ZKK@wSUrd}q_X`gpTD zbdixMC5S0mSVr=7&Ab$D z&lwa1mc2c+^+{Ckrp^&MXPFP(JRj>rUyI1C+dl7^ME5UD#(@^?iUP_xGlJ~d6+GcP zzn_1x&6&`-CT~6Fu99}Qjp;nw*Wvg!mYF?~7j2F$c)U69CNY#E)wjC3%28t^mkxgg z64Ytr>y$cSg(R~YJlJozYJi+txjBst(}l*H|pu!n^@sv5;oA*anHT_t*IDDkM{7x?I zKsLWDD)yMuY5sXy4M{ITLku z;%-~3)YWnqQ}O{0oZK1)0Ork?#S5p)3p(MM$mub$RldzA0N za!`&W^l2$(D-e$R-!h@#Zi~sGK@@(?s~oH=k@|@Vy*}QleV=!q6LrLSiVV{TDJbWv z@v;o*sgo4J<|^cix4Odcs6q}2T!MGs<_;44vg9`cQ9wpG8I?UVZIClsSsZt2zJrVX z%DBHTs_K$0!Cj~%uM#QnhR+$z!f*m^iivkxG=VNkD5Ax6!&lk5m-Qi-oyYACc;z(% zRzoD8=(%y0MiGe1(M$FVN)V>)LzxCKa8F&tVu*Z?DuO_ls0U%^?=bk|&U~*#eCr9NkiXB@Xw{d`X_it8~ z@3PLbDzm{CJ60B>pKBGE%YNlam>&zJ&D>$;EEPT~iwX=4T@O7AsQH)+8t@)FZ>)Vf z1=oZkATJT9RB8o{5&gn?Ec*Ix+-&69xu;{hc&uKuMYWy9&(U?RUl1^?3G`Y;Eba-G zIEh;=(c1$WB(6HSDDFkJidc^C2=mTN`G)VMwHVAO34Z^s+k{>Q<1l!uCIOk;zB{CT z@lyb)9#axDdl0iRV!M18l(uvL3etYylBxcB!JP`59<%=)KHyN;F?LQ zRfY=GbRt54RUV@D_`TQ6De`e@K)7~Y%bBc9jW(iEARulwpt=L7?cF^@EQg~GwSW5$&IPI##3fOqTs&dvt!|q^j%_?Z5Xbq z%yCF`U~vREWl;iAj3K_szJ7`R-r<<7BE@b{X$hyiqs{3Rw`vcWDyNoB4D6*S_?e3Pg&rgBs+wv zWFc&P`1_Y1k)bOT=x4nTjLqni+4CVk_c^%R5EZoTNV03j1WDgYpa%$vHH?N+oT>(& zxOfN+)229TG%5U7Ak{YlTN*c39a5}F&>HvZwBU!=xxfiTC5OxX=d$Wj5NI22Ho!EP zb;t)Jc9>D-7h~kyNvmVcjUS(tRjjohV-n|jgX*@q4vjuDip>{9)z!mpf07T-Dve*@ zbk(&`29hR*@quj4l;q;lWhVmL#Dw=)zVO&^;d@uxs_Nal`mbKzYPOxKU@Ro%4|Km@ zN1|FGJ*O(2Z>jW5Dv$nexwe&EF2bZ=HD)=ed&32w+{B{p6ZV9awI_cb*EK;5*NkMW%jj(g82HyBgh3`)V%P@(GUwL$uB z?li2XZretN`Y_NgECxSCmc?NW99R|MY6F7j4wRVbjy( zd|=c36pc2jH>vP(o>39~DEphU+DCr)SIfvcrBd34-@mquV7Fxf3QgOB+;>c(zc>xh!hod#N_y49TTjw%xpKax zQ1aX!owi5KC>J!@H-2*{jSD!;Sh*Sp<1b&BBYWfc_@S-8G! z9@RDE0jkU^L~~NPud=E%Koa-}Gn#OJwIkmgM1ZMuAK}n}@v#pB<8PTKX_x}wSX!`~L literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-xxhdpi/googlepay_button_no_shadow_background_image.9.png b/app/src/main/res/drawable-xxhdpi/googlepay_button_no_shadow_background_image.9.png new file mode 100755 index 0000000000000000000000000000000000000000..dda66dfd0dca9e7cdb6241e55cb59f80d0500f67 GIT binary patch literal 679 zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H0wgodS2{2-Fy(o=IEGX(zP-!LBO551%~Sx3}fGZOu(yw(;_w|EDYe-;uS}zGnMpq4$4>`UfTU z$)XJmED8*a91aX}sw+K8Yn&GKh&&2z_L_3+@J~|){`uE>QWbAooRU13y1-Z_S>1bv zL%37dGyVrb?Q%Yes>^qr*0%dR*MwQM<{|HQ%fnS^7uwZ!{A8#IS!}+#(#>hsMWMLO z6CYk#kg<+I@9K;La`Qf`US_yoanNv?(Bo%p0kailo=C1_-TO#HIb#-ggS&Ou=Q&p< z-P<&=vBDyaLC$V*y zIGZsfUD13kbH#zESF;&^ym_#+lp){JP1v|$!s423d=I$8GxFF33ftaaV^oP*zEtyo zWf1pnO|Z9_1mGb6V=6Fs=(1u81H%ZW0uPgcl^+tG*wjAY;ar(IbN>~UCo`t{hpxYL zhr=PiGXB>&@D`jC$`K5n(b1a$CduVvo0Gcn=aSn sFVdQ&MBb@0B8jHtpET3 literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-xxxhdpi/googlepay_button_background_image.9.png b/app/src/main/res/drawable-xxxhdpi/googlepay_button_background_image.9.png new file mode 100755 index 0000000000000000000000000000000000000000..ab905289bc28dc6df2c5e8c1da2b9dda79676c3a GIT binary patch literal 4280 zcmb7I2UJs8w?>+UqJknQO;nH`K)@J^G!YOO2@WN+5PAqz0vI|I5D)|fO{6&^q9`Cm z0-^T=2tfvg&>|pBl7MtWePNuL_rHJEdhdUCt$WVB_w4iSZ|{B1K6~AypDc{|j-5Tm z#>U2Ha?{X?)mI$cN4Qz-Y;u+t8{3I!6GJ`gutW6U51(vi<83c{Pi))a`4wdr>M^l} z-H{7BZ8gV!AwEMzRT$VMsrWjro2a_-EU*r>7m66cqUdi_Y zdkeN+fWd|)FjspM8J-0z={>rFpqj=o#?aY%ce+Fzz3)o6ne^jcLbP18pI;s`c*B4p z_l4vTPK4)1j%QrEc5UGUm8*CcFXZ3v^?qIH<-mgQtmfk#JoAv}EQt!Vr71+VpMQrQ zI<7)1yh#-qYN^s4h}anRto~_aFP1(ux{{rni)b>N%XyIojZ$0A7E=pZbsu!1kU2B} zQ;FeGPNKSZP@ zd_GxE2`Mr;*dWU`+ArKAhOMtzUS3{oX=w?tu^F=V^z8X^;%+RI`@_r; z2+#tJ_U_%=w2{6SVO5w%FA1y7T^5rRL86YQ zu>)*`Dh%jsb?)uM;?3C_h=nh&ec^C3^(*R*-pY$D8&b~X6kOtd={ky*Kd1zkaJIVR zPVzfb=~hU3BBBQOAk$T1xNcqjVB2y_$IDkNkjT7`ms*$dK(vn%*VgWqDGF;1r**^W z9a_Cklx@cOCih*^7HrXI|MLipQOSSA@KYxpGb!%T?Tb~Z^q3`ybJ#X>Y5?L+D|;x+ zz?2RJO~PS^hf&hVGl3hlTmu7xHpSdr2qVea-FSwFj*g&;Z}bgD#cEH+EdA}J;+how zB`iL@Qgy~aDcoc-krJi-vA_Rh^@VRy#ZQAgC!1{R!k}>xt$Kxye>%4KJJbo5bX(4C zpGT`2H0fwT=>ruO7IMe6xV&#H`ua?CD&Ky8@VW`~kRYY`$j^Xyu_e_uhR1iu?^&F~ zDHMN`Nh9CS?`Sj{2wzn6b!+7Mgptgrj}f5F_D!Fdg0h&SzAl{dn3l9Nm7z(K4~Hd! zT4=7J1Tvz08QJV80ZP^vwJXWZmEXWE^Ma-ty^b?&_{hp=z6UN`YLu1}PXIHx*)g$Z z{lOk1J!B|-Oeat-8}X$yt;Bna0clSwqtTB>eJDv%2Q+0u)L?(j*}#sAH7Dzlovps1 z$A&T0=zyzQuEsytmi{`K!P1ngkCe$os+Glw&|Qw0Ef$Ne+PP+O4d#MGVB2~MSAQmo66`ti+j-Q}(@~>{ zdOlKbFPCL@{?gHnHPYyKw#-LP_WX*(t;gJVTox=bE&K^(zsUMB5d{uQZ8KX=hx580C(L3FrX>yF+H3-IvvZr8~R&CHIR_qOQEXJsQ0moPNgy`Xf?+SxMOO_|s^TM@UeJ`YH2QC`6NgQXVrae$eese4tK(veYM%cE4RX z%2L(J^LRMV9{q;b)!OZ`_+M+|7w&&BR4&=VDbO8I4%>34-KW@`Z(uoQQkylZy&!Xu;hvFcfRONy;lkKU=)N_4s+I(14q(Pevy=&LpK<*;??=%ERs7lr+ zPb+;FoyOzw6W*)XJVUuZwvCFaO5lyxb=xP+6&06CN=kOcY+e*VWt(!27rSu(*hgrU z!y+hQ1)d5qzIFbf5skv7U$p$w!EH(CTo~lHe&!_KIX~YedIS_9`R%bjZZZ=${wG;h zPKtj3JS>vpu1B6#`cBr_rVHT==meT;k#+TM*oRV8V~bS67r~5q;CRFC@#^a2zEMc0 zF8%zbmrJ+uk3-={Mr3U~Oq)2jSsWcOXE1Bs)aq1G0;Lmn2Ro-*TkmRN$4*jfn1eW6 znkGeXCr`US+UK7D%yhA-3dzw;1!a52mA)0Jt7>WkaELT?P@}Ra7b1f*R9^T>L;1o{ z+jSi4>$;$#!rA?e58GF?to}T7|4QnB1a;CK&Y(qW>V%`rsvduJ{Y@oBzDwYuetgF# zutkc@Q^G5Y#y9>h6U(@lE3y!dU7bYc^Z$Vo)N|}X_z*$3-PJA~C~(8rc&Vn1P^6QM z2+qgfABD6aQD$XzDv(F3W}~>imp|W-mhpEwbF85Tk7o`b*LGW}rh6T=H|s=X9Q>## z0ISAu;kaPi!ixm_a_JV72WHzQx&g4g=(azD9<@Yzx@){`s5{g3apAJ@;La3z7+ft) z&c$GAOQHk5$uby>rD~9-u8U*A_yfV<(70h38xN+L`^G^K!$RfDX2_j>`xJk>+b5>0 zHXe^JqU+|r+?)~*SIx@Hf!rd@o;eeGan8!qNNPZH6ha)hc5SfXMR_^%?K;wsn>|){ zWN%WJ-m$B>dHzMir{g)CPySiB9W1rLKBK(R5?lCwjTdox+!EQ7vQxD}C+Efo%gbjY z`o*!%_9Gf~u<+$IMAzzt{`u5wV}it0z^SNvmp|^-;&8Z!>KYnRpr33uY0pMRnr5yq z6)jly7VWYsyMGjl2l|+BSatEYMG08>T_UxzLb1jeC_kE20FjrmbFmQ4>$dStM-QR`R<_c;lk^O$hT?VkyG-JRc9o>6BvjqslzL~C-jJX0 zg$G}`l02u@y?pnYuP*oMTH4Ia_g1TWEmTwT{XVi&K=)w#9dQ4E-?{v;prwrRq{E}P zx9;;@fIXxFR97hL*_yi4d#yL}H6#wp?hlLl%;{LqB*X%a%^`kAjZ-xnHdg@QtA-Mq z9Qu^Y6A+|ctZtSxStPtTBVGh4?3yHt6NaS%H$*4cWolYZmbPb^^LO}>N_KFg(J2ml z^8$ELyEzU4&nR)8?6po2)wdcC`6JT{b=LK0CU1yc5$n=3ZFkG}wCwyE(}ZYCFPIAi zx5gcylTvh-uWWX_MbA0UiffzI|jAD`SZ(;Cd-r^$<@qZpY8IQfcV?r zTK^q+>ms=?RbF7os1zqGMhL`{#7}RDo7Zbv5#-6o6gy9O)>9t*F6C)y)l^__{B~Sg zF|3Z_i(Fm57yW2F3OAyI0M@$*<^bCM9rx-Zv$4Rj!C@=j6L@Ejtbt3FQO2u_<{!(G zkKLVMWVoIR|2?SK@0HV6zpeE~E@h$YM5^0rK{RSCC`=XzO+5bux}h=KJTQVNJW zC;Igf1{{(Em$La~aU=^i^|V^#8Pfl`9C`S8yk80+?uun7u-#l{Xk$-tqg%D(l@j5p z5FOAi0QObsJR3|0Hgj17#9s&pofNDu9j|eoI3yL?Rh%4zy@P>eUhM~zsNAzoRYKQH zPS@tig=CD_9MTCq`7r;<7n6Xt6K1!{JA~n+^116dw^$(fcF~1L-$_PfcO^73Lcl-} zeD<_gROwm8o9_0{<<`|>EFlrEE;+H=r^&SN{c9NSLk}C9#s(+#U7xNcF}ZfEW`h#b z#IF_bm#goGTL<<`7EYg@N~rJWcnS)T4UB>|I!_&v8Va3_`W415%t&bGSG;%O(^v45 z`^l-VC!Vxfk`+9Y6gykaZGVdq9IJ6UX}iFF{1nhl39Td(Bd3I%PaiSz&XPSJl9yip zpu4g8{awIU*E67ZE@CUD-+!{8o5q?Y9ZqpLQ%m)mkDj`Fp@7^Wl#iNQcD|Tp5=k*C zd>L=jrT94{IQ+{MeIJCO(M07bJY?2te*V|hOb}8wtOxpPT1d-`OnJ&abV*!kWg-_p zXfT&#nl)bnNt40M@CM_m#KW2`A_}EKdmN7Bra0dC{4prvtE=70>~+T}4uSA=Qd6{< q;MPrnda@zQ)O~Mn;FQA_Ph+*e$xh~@3DzG8HWMQY!%}^hxc>rq$y|N_ literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-xxxhdpi/googlepay_button_no_shadow_background_image.9.png b/app/src/main/res/drawable-xxxhdpi/googlepay_button_no_shadow_background_image.9.png new file mode 100755 index 0000000000000000000000000000000000000000..e67fdaf516d74fb33d13a18a39ac4b6c121a14d3 GIT binary patch literal 819 zcmeAS@N?(olHy`uVBq!ia0vp^t3a588Ax)iP}u;aRtNZmxB}^+0!&P|xB%U1Q4-`A z%)rRR%)!McC?O*&udZQWY;I+19}pB0kyBLBI$_d`B}+GK+Oc>4q4Sq+-g)}`<*N^$ zzJ34k>(AeR2A`y_FfcIw_jGX#skrs_?)APV2Z^@Cz&EVb?^oQ|*l^}={7t!JCaKK_ zf0o~W&oys?!NZ0<`vAT3o^v&*{DK|EAJ*y5;j^1*sdF5W)9p&+=R{!70ZTnVoVOv+^W7DfA zrtDt4bhG`g@bmnWma^?DFYT{Rw|q6t_?Y&piK|PF&AzOhn8NYLBKO!_uX7#CrDl57 zKbw<((0t{=w{On;n!5b?FQ2p1tT*3vt*xDYcTMoQV?o__Hx_@~=l@mj+>Yp;h0A=i zw^(ZHmfh=FbK&QzdFL*F`&4qdxyoAi_QKDmK4+tupU-|@_d}+DEzE9G)GOcbje1uS z?B7mRT6uM0ZOE-R8T_j!Ub&U>`jvC(_Q_EyTkY&)zAlX8|6HZAbz^~T?TUH3GhBjZ zmtDFa^znXVnen7sQ9m2)t{jNpx@cwg(yP~iq14JH3JESKqrQLD0t`V+WnhskovHh; zW2*kI9O|dy6;S0JaKR@)%`c$FKj2b8fJRV2U2wpakN~Z)fQImpYY_oDQ2|ZSK{sN8 s^x}eA;;&t0yOYZZaZH_8sMEAxjOWasx9nbR8V*YOp00i_>zopr0K0)M!~g&Q literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable/buy_with_googlepay_button_content.xml b/app/src/main/res/drawable/buy_with_googlepay_button_content.xml new file mode 100755 index 0000000000..a893cd0cac --- /dev/null +++ b/app/src/main/res/drawable/buy_with_googlepay_button_content.xml @@ -0,0 +1,54 @@ + + + + + + + + + + diff --git a/app/src/main/res/drawable/googlepay_button_background.xml b/app/src/main/res/drawable/googlepay_button_background.xml new file mode 100755 index 0000000000..b81005b06f --- /dev/null +++ b/app/src/main/res/drawable/googlepay_button_background.xml @@ -0,0 +1,6 @@ + + + + + diff --git a/app/src/main/res/drawable/googlepay_button_content.xml b/app/src/main/res/drawable/googlepay_button_content.xml new file mode 100755 index 0000000000..b2cdb1d52b --- /dev/null +++ b/app/src/main/res/drawable/googlepay_button_content.xml @@ -0,0 +1,48 @@ + + + + + + + + + diff --git a/app/src/main/res/drawable/googlepay_button_no_shadow_background.xml b/app/src/main/res/drawable/googlepay_button_no_shadow_background.xml new file mode 100755 index 0000000000..9543c4bcb6 --- /dev/null +++ b/app/src/main/res/drawable/googlepay_button_no_shadow_background.xml @@ -0,0 +1,6 @@ + + + + + diff --git a/app/src/main/res/drawable/googlepay_button_overlay.xml b/app/src/main/res/drawable/googlepay_button_overlay.xml new file mode 100755 index 0000000000..70c7a92271 --- /dev/null +++ b/app/src/main/res/drawable/googlepay_button_overlay.xml @@ -0,0 +1,12 @@ + + + + + + + + + + + diff --git a/app/src/main/res/drawable/ic_clear_24.xml b/app/src/main/res/drawable/ic_clear_24.xml new file mode 100644 index 0000000000..cd2a842a1f --- /dev/null +++ b/app/src/main/res/drawable/ic_clear_24.xml @@ -0,0 +1,5 @@ + + + diff --git a/app/src/main/res/drawable/ic_promo_code.xml b/app/src/main/res/drawable/ic_promo_code.xml new file mode 100644 index 0000000000..149d59df21 --- /dev/null +++ b/app/src/main/res/drawable/ic_promo_code.xml @@ -0,0 +1,11 @@ + + + + + + diff --git a/app/src/main/res/drawable/ic_shipping.xml b/app/src/main/res/drawable/ic_shipping.xml new file mode 100644 index 0000000000..b36ffe1bed --- /dev/null +++ b/app/src/main/res/drawable/ic_shipping.xml @@ -0,0 +1,11 @@ + + + + diff --git a/app/src/main/res/drawable/shape_line.xml b/app/src/main/res/drawable/shape_line.xml new file mode 100644 index 0000000000..cf7b6cfb0f --- /dev/null +++ b/app/src/main/res/drawable/shape_line.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/shape_rectangle_rounded_4.xml b/app/src/main/res/drawable/shape_rectangle_rounded_4.xml new file mode 100644 index 0000000000..b7d03c2907 --- /dev/null +++ b/app/src/main/res/drawable/shape_rectangle_rounded_4.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/buy_with_googlepay_button.xml b/app/src/main/res/layout/buy_with_googlepay_button.xml new file mode 100755 index 0000000000..2553181fd8 --- /dev/null +++ b/app/src/main/res/layout/buy_with_googlepay_button.xml @@ -0,0 +1,31 @@ + + + + + + + diff --git a/app/src/main/res/layout/fragment_shop.xml b/app/src/main/res/layout/fragment_shop.xml new file mode 100644 index 0000000000..839265fadc --- /dev/null +++ b/app/src/main/res/layout/fragment_shop.xml @@ -0,0 +1,375 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/test_shopify_fragment.xml b/app/src/main/res/layout/test_shopify_fragment.xml new file mode 100644 index 0000000000..eff6a14884 --- /dev/null +++ b/app/src/main/res/layout/test_shopify_fragment.xml @@ -0,0 +1,87 @@ + + + + +