Fix emitting xrates when there are 2+ coinTypes for the same provider id

horizontalsystems · Apr 6, 2021 · 337b3ac · 337b3ac
1 parent ad10926
commit 337b3ac
Show file tree

Hide file tree

Showing 5 changed files with 44 additions and 12 deletions.
diff --git a/xrateskit/src/main/java/io/horizontalsystems/xrateskit/coins/ProviderCoinsManager.kt b/xrateskit/src/main/java/io/horizontalsystems/xrateskit/coins/ProviderCoinsManager.kt
@@ -100,6 +100,15 @@ class ProviderCoinsManager(
         }
     }
 
+    fun getProviderId(coinType: CoinType, provider: InfoProvider) : String? {
+        return storage.getProviderCoin(coinType)?.let {
+            if(provider is InfoProvider.CoinGecko)
+                it.coingeckoId
+            else
+                it.cryptocompareId
+        }
+    }
+
     fun getCoinTypes(providerCoinId: String, provider: InfoProvider): List<CoinType> {
         return storage.getCoinTypesByProviderCoinId(providerCoinId, provider)
     }

diff --git a/xrateskit/src/main/java/io/horizontalsystems/xrateskit/core/Interfaces.kt b/xrateskit/src/main/java/io/horizontalsystems/xrateskit/core/Interfaces.kt
@@ -38,6 +38,7 @@ interface IStorage {
         //Provider Coins
     fun saveProviderCoins(providerCoins: List<ProviderCoinEntity>)
     fun getProviderCoins(coinTypes: List<CoinType>): List<ProviderCoinEntity>
+    fun getProviderCoin(coinType: CoinType): ProviderCoinEntity?
     fun getCoinTypesByProviderCoinId(providerCoinId: String, provider: InfoProvider): List<CoinType>
     fun searchCoins(searchText: String): List<ProviderCoinEntity>
     fun clearPriorities()

diff --git a/xrateskit/src/main/java/io/horizontalsystems/xrateskit/providers/CoinGeckoProvider.kt b/xrateskit/src/main/java/io/horizontalsystems/xrateskit/providers/CoinGeckoProvider.kt
@@ -304,19 +304,31 @@ class CoinGeckoProvider(
 
         return Single.create { emitter ->
             try {
-                val providerCoinIds = providerCoinsManager.getProviderIds(coinTypes, this.provider).mapNotNull { it }
-                if(providerCoinIds.isEmpty())
+                val coinTypesByCoinGeckoId = mutableMapOf<String, MutableList<CoinType>>()
+
+                coinTypes.forEach { coinType ->
+                    providerCoinsManager.getProviderId(coinType, provider)?.let { providerCoinId ->
+                        if (coinTypesByCoinGeckoId[providerCoinId] == null) {
+                            coinTypesByCoinGeckoId[providerCoinId] = mutableListOf()
+                        }
+
+                        coinTypesByCoinGeckoId[providerCoinId]?.add(coinType)
+                    }
+                }
+
+                if (coinTypesByCoinGeckoId.isEmpty())
                     emitter.onSuccess(Collections.emptyList())
                 else
-                    emitter.onSuccess(getLatestRates(providerCoinIds, currencyCode))
+                    emitter.onSuccess(getLatestRates(coinTypesByCoinGeckoId, currencyCode))
 
             } catch (ex: Exception) {
                 emitter.onError(ex)
             }
         }
     }
 
-    private fun getLatestRates(coinIds: List<String>, currencyCode: String): List<LatestRateEntity>{
+    private fun getLatestRates(coinTypesByCoinGeckoId: Map<String, List<CoinType>>, currencyCode: String): List<LatestRateEntity>{
+        val coinIds = coinTypesByCoinGeckoId.keys.toList()
         val latestRates = mutableListOf<LatestRateEntity>()
         val coinIdsParams = "&ids=${coinIds.joinToString(separator = ",")}"
 
@@ -328,15 +340,18 @@ class CoinGeckoProvider(
         val responses = CoinGeckoCoinPriceResponse.parseData(json, currencyCode, coinIds)
         val timestamp = System.currentTimeMillis() / 1000
         responses.forEach {
-            latestRates.add(
-                LatestRateEntity(
-                    coinType = getCoinType(it.coinId),
-                    currencyCode = currencyCode,
-                    rateDiff24h = it.rateDiff24h,
-                    rate = it.rate,
-                    timestamp = timestamp
+            val providerCoinId = it.coinId
+            coinTypesByCoinGeckoId[providerCoinId]?.forEach { coinType ->
+                latestRates.add(
+                    LatestRateEntity(
+                        coinType = coinType,
+                        currencyCode = currencyCode,
+                        rateDiff24h = it.rateDiff24h,
+                        rate = it.rate,
+                        timestamp = timestamp
+                    )
                 )
-            )
+            }
         }
 
         return latestRates

diff --git a/xrateskit/src/main/java/io/horizontalsystems/xrateskit/storage/ProviderCoinsDao.kt b/xrateskit/src/main/java/io/horizontalsystems/xrateskit/storage/ProviderCoinsDao.kt
@@ -15,6 +15,9 @@ interface ProviderCoinsDao {
     @Query("SELECT * FROM ProviderCoinEntity WHERE coinType  IN (:coinTypes)")
     fun getProviderCoins(coinTypes: List<CoinType>): List<ProviderCoinEntity>
 
+    @Query("SELECT * FROM ProviderCoinEntity WHERE coinType = :coinType")
+    fun getProviderCoin(coinType: CoinType): ProviderCoinEntity?
+
     @Query("SELECT coinType FROM ProviderCoinEntity WHERE cryptocompareId =:providerCoinId")
     fun getCoinTypesForCryptoCompare(providerCoinId: String): List<CoinType>
 

diff --git a/xrateskit/src/main/java/io/horizontalsystems/xrateskit/storage/Storage.kt b/xrateskit/src/main/java/io/horizontalsystems/xrateskit/storage/Storage.kt
@@ -127,6 +127,10 @@ class Storage(private val database: Database) : IStorage {
         return providerCoinDao.getProviderCoins(coinTypes)
     }
 
+    override fun getProviderCoin(coinType: CoinType): ProviderCoinEntity? {
+        return providerCoinDao.getProviderCoin(coinType)
+    }
+
     override  fun getCoinTypesByProviderCoinId(providerCoinId: String, provider: InfoProvider): List<CoinType> {
         if(provider is InfoProvider.CoinGecko)
             return providerCoinDao.getCoinTypesForCoinGecko(providerCoinId)