Add like button to book suggestions

README.md

@@ -56,13 +56,18 @@ the user during the login process.
 
 ### Version 4.1 - HIGH MAINTENANCE
 - [ ] Like book suggestions
+    - [ ] Bugfixes
+    - [ ] Split wishlist and suggestions
 - [x] Upgrade to Kotlin > 1.4.20
     - [x] ViewBinding
     - [x] Remove Kotterknife usage
 - [ ] Backup file improvements
+    - [ ] Check Backup pages & labels restore
     - [ ] Show path to local backup files
     - [ ] Open file with FileProvider
-- [x] Improve main screen
+- [ ] Improve main screen
+    - [ ] Bigger book covers
+    - [ ] Show stars for read books
     - [x] Replace buggy SharedElementTransition for DetailPageNavigation
     - [x] Use lighter UI for labels (outline instead of filled)
     - [x] New labels screen

app/build.gradle

@@ -6,7 +6,7 @@ apply plugin: 'com.google.firebase.crashlytics'
 
 android {
     compileSdkVersion 30
-    buildToolsVersion '30.0.0'
+    buildToolsVersion '30.0.2'
 
     defaultConfig {
         applicationId "at.shockbytes.dante"
@@ -120,7 +120,6 @@ dependencies {
 
     // debugImplementation "com.squareup.leakcanary:leakcanary-android:$leakCanaryVersion"
 
-    implementation 'com.tbuonomo:creative-viewpager:1.0.1'
     implementation 'pub.devrel:easypermissions:3.0.0'
     implementation 'ru.bullyboo.view:circleseekbar:1.0.3'
     implementation 'com.f2prateek.rx.preferences2:rx-preferences:2.0.0'

app/src/main/java/at/shockbytes/dante/suggestions/Suggestion.kt

@@ -4,5 +4,8 @@ data class Suggestion(
     val suggestionId: String,
     val suggestion: BookSuggestionEntity,
     val suggester: Suggester,
-    val recommendation: String
+    val recommendation: String,
+    val likes: Int,
+    val isLikedByMe: Boolean,
+    val isReportedByMe: Boolean
 )

app/src/main/java/at/shockbytes/dante/suggestions/SuggestionLikeRequest.kt

@@ -0,0 +1,5 @@
+package at.shockbytes.dante.suggestions
+
+data class SuggestionLikeRequest(
+    val isLikedByMe: Boolean
+)

app/src/main/java/at/shockbytes/dante/suggestions/SuggestionsRepository.kt

@@ -2,6 +2,7 @@ package at.shockbytes.dante.suggestions
 
 import at.shockbytes.dante.core.book.BookEntity
 import io.reactivex.Completable
+import io.reactivex.Observable
 import io.reactivex.Single
 import kotlinx.coroutines.CoroutineScope
 
@@ -14,6 +15,8 @@ interface SuggestionsRepository {
 
     fun reportSuggestion(suggestionId: String, scope: CoroutineScope): Completable
 
+    fun likeSuggestion(suggestionId: String, isLikedByMe: Boolean, scope: CoroutineScope): Completable
+
     fun getUserReportedSuggestions(): Single<List<String>>
 
     fun suggestBook(bookEntity: BookEntity, recommendation: String): Completable

app/src/main/java/at/shockbytes/dante/suggestions/cache/DataStoreSuggestionsCache.kt

@@ -27,6 +27,7 @@ class DataStoreSuggestionsCache(
     private val suggestionsKey = preferencesKey<String>(KEY_SUGGESTION_CACHE)
     private val cacheKey = preferencesKey<Long>(KEY_CACHE)
     private val reportedSuggestionsKey = preferencesSetKey<String>(KEY_REPORTED_SUGGESTION_CACHE)
+    private val likesSuggestionsKey = preferencesSetKey<String>(KEY_LIKED_SUGGESTION_CACHE)
 
     override fun lastCacheTimestamp(): Single<Long> {
         return singleOf {
@@ -44,13 +45,37 @@ class DataStoreSuggestionsCache(
     }
 
     override fun loadSuggestions(): Single<Suggestions> {
-        return singleOf {
-            runBlocking {
-                dataStore.data.first()[suggestionsKey]
-            }?.let { data ->
-                gson.fromJson<Suggestions>(data)
-            } ?: Suggestions(listOf())
-        }
+        return Single
+            .zip(
+                loadReportedSuggestions(),
+                loadLikedSuggestions(),
+                { reportedSuggestionIds, likedSuggestionIds ->
+
+                    loadSuggestionsFromCache().suggestions
+                        .map { suggestion ->
+
+                            val isLikedByMe =
+                                likedSuggestionIds.contains(suggestion.suggestionId)
+                            val isReportedByMe =
+                                reportedSuggestionIds.contains(suggestion.suggestionId)
+
+                            suggestion.copy(
+                                isLikedByMe = isLikedByMe,
+                                isReportedByMe = isReportedByMe,
+                                likes = suggestion.likes.inc()
+                            )
+                        }
+                        .let(::Suggestions)
+                }
+            )
+    }
+
+    private fun loadSuggestionsFromCache(): Suggestions {
+        return runBlocking {
+            dataStore.data.first()[suggestionsKey]
+        }?.let { data ->
+            gson.fromJson<Suggestions>(data)
+        } ?: Suggestions(listOf())
     }
 
     override suspend fun cacheSuggestionReport(suggestionId: String) {
@@ -69,9 +94,35 @@ class DataStoreSuggestionsCache(
         }
     }
 
+    override suspend fun cacheSuggestionLike(suggestionId: String) {
+        dataStore.edit { preferences ->
+            val likes = preferences[likesSuggestionsKey].orEmpty().toMutableSet()
+            likes.add(suggestionId)
+            preferences[likesSuggestionsKey] = likes
+        }
+    }
+
+    override suspend fun removeSuggestionLike(suggestionId: String) {
+        dataStore.edit { preferences ->
+            val likes = preferences[likesSuggestionsKey].orEmpty().toMutableSet()
+            if (likes.remove(suggestionId)) {
+                preferences[likesSuggestionsKey] = likes
+            }
+        }
+    }
+
+    override fun loadLikedSuggestions(): Single<List<String>> {
+        return singleOf {
+            runBlocking {
+                dataStore.data.first()[likesSuggestionsKey].orEmpty().toList()
+            }
+        }
+    }
+
     companion object {
         private const val KEY_SUGGESTION_CACHE = "key_suggestion_cache"
         private const val KEY_CACHE = "key_cache"
         private const val KEY_REPORTED_SUGGESTION_CACHE = "key_reported_suggestion_cache"
+        private const val KEY_LIKED_SUGGESTION_CACHE = "key_liked_suggestion_cache"
     }
 }

app/src/main/java/at/shockbytes/dante/suggestions/cache/SuggestionsCache.kt

@@ -11,7 +11,17 @@ interface SuggestionsCache {
 
     fun loadSuggestions(): Single<Suggestions>
 
+    // ------------ Reports ------------
+
     suspend fun cacheSuggestionReport(suggestionId: String)
 
     fun loadReportedSuggestions(): Single<List<String>>
+
+    // ------------- Likes -------------
+
+    suspend fun cacheSuggestionLike(suggestionId: String)
+
+    suspend fun removeSuggestionLike(suggestionId: String)
+
+    fun loadLikedSuggestions(): Single<List<String>>
 }

app/src/main/java/at/shockbytes/dante/suggestions/firebase/FirebaseSuggestionsApi.kt

@@ -1,5 +1,6 @@
 package at.shockbytes.dante.suggestions.firebase
 
+import at.shockbytes.dante.suggestions.SuggestionLikeRequest
 import at.shockbytes.dante.suggestions.SuggestionRequest
 import at.shockbytes.dante.suggestions.Suggestions
 import io.reactivex.Completable
@@ -13,16 +14,23 @@ import retrofit2.http.Path
 interface FirebaseSuggestionsApi {
 
     @GET("suggestions")
-    fun getSuggestions(
+    fun getRawSuggestions(
         @Header("Authorization") bearerToken: String
-    ): Single<Suggestions>
+    ): Single<RawSuggestions>
 
     @POST("suggestions/{suggestionId}/report")
     fun reportSuggestion(
         @Header("Authorization") bearerToken: String,
         @Path("suggestionId") suggestionId: String
     ): Completable
 
+    @POST("suggestions/{suggestionId}/like")
+    fun likeSuggestion(
+        @Header("Authorization") bearerToken: String,
+        @Path("suggestionId") suggestionId: String,
+        @Body suggestionLikeRequest: SuggestionLikeRequest
+    ): Completable
+
     @POST("suggestions")
     fun suggestBook(
         @Header("Authorization") bearerToken: String,

app/src/main/java/at/shockbytes/dante/suggestions/firebase/FirebaseSuggestionsRepository.kt

@@ -3,6 +3,8 @@ package at.shockbytes.dante.suggestions.firebase
 import at.shockbytes.dante.core.book.BookEntity
 import at.shockbytes.dante.core.login.LoginRepository
 import at.shockbytes.dante.suggestions.BookSuggestionEntity
+import at.shockbytes.dante.suggestions.Suggestion
+import at.shockbytes.dante.suggestions.SuggestionLikeRequest
 import at.shockbytes.dante.suggestions.SuggestionRequest
 import at.shockbytes.dante.suggestions.Suggestions
 import at.shockbytes.dante.suggestions.SuggestionsRepository
@@ -26,7 +28,10 @@ class FirebaseSuggestionsRepository(
     private val tracker: Tracker
 ) : SuggestionsRepository {
 
-    override fun loadSuggestions(accessTimestamp: Long, scope: CoroutineScope): Single<Suggestions> {
+    override fun loadSuggestions(
+        accessTimestamp: Long,
+        scope: CoroutineScope
+    ): Single<Suggestions> {
         return shouldUseRemoteData(accessTimestamp)
             .flatMap { useRemoteSuggestions ->
                 if (useRemoteSuggestions) {
@@ -64,7 +69,8 @@ class FirebaseSuggestionsRepository(
 
     private fun loadRemoteSuggestions(scope: CoroutineScope): Single<Suggestions> {
         return loginRepository.getAuthorizationHeader()
-            .flatMap(firebaseSuggestionsApi::getSuggestions)
+            .flatMap(firebaseSuggestionsApi::getRawSuggestions)
+            .flatMap(::mapToSuggestions)
             .doOnSuccess { suggestions ->
                 if (suggestions.isNotEmpty()) {
                     cacheRemoteSuggestions(suggestions, scope)
@@ -73,6 +79,38 @@ class FirebaseSuggestionsRepository(
             .subscribeOn(schedulers.io)
     }
 
+    private fun mapToSuggestions(rawSuggestions: RawSuggestions): Single<Suggestions> {
+
+        return Single
+            .zip(
+                suggestionsCache.loadReportedSuggestions(),
+                suggestionsCache.loadLikedSuggestions(),
+                { reportedSuggestionIds, likedSuggestionIds ->
+
+                    val suggestions = rawSuggestions.suggestions
+                        .map { rawSuggestion ->
+
+                            val isLikedByMe =
+                                likedSuggestionIds.contains(rawSuggestion.suggestionId)
+                            val isReportedByMe =
+                                reportedSuggestionIds.contains(rawSuggestion.suggestionId)
+
+                            Suggestion(
+                                suggestionId = rawSuggestion.suggestionId,
+                                suggestion = rawSuggestion.suggestion,
+                                suggester = rawSuggestion.suggester,
+                                recommendation = rawSuggestion.recommendation,
+                                likes = rawSuggestion.likes,
+                                isLikedByMe = isLikedByMe,
+                                isReportedByMe = isReportedByMe
+                            )
+                        }
+
+                    Suggestions(suggestions)
+                }
+            )
+    }
+
     private fun cacheRemoteSuggestions(suggestions: Suggestions, scope: CoroutineScope) {
         scope.launch {
             suggestionsCache.cache(suggestions)
@@ -95,6 +133,25 @@ class FirebaseSuggestionsRepository(
             .subscribeOn(schedulers.io)
     }
 
+    override fun likeSuggestion(
+        suggestionId: String,
+        isLikedByMe: Boolean,
+        scope: CoroutineScope
+    ): Completable {
+        return loginRepository.getAuthorizationHeader()
+            .flatMapCompletable { bearerToken ->
+                firebaseSuggestionsApi.likeSuggestion(
+                    bearerToken,
+                    suggestionId,
+                    SuggestionLikeRequest(isLikedByMe)
+                )
+            }
+            .doOnComplete {
+                cacheLikedSuggestion(suggestionId, isLikedByMe, scope)
+            }
+            .subscribeOn(schedulers.io)
+    }
+
     override fun getUserReportedSuggestions(): Single<List<String>> {
         return suggestionsCache.loadReportedSuggestions()
     }
@@ -105,6 +162,20 @@ class FirebaseSuggestionsRepository(
         }
     }
 
+    private fun cacheLikedSuggestion(
+        suggestionId: String,
+        isLikedByMe: Boolean,
+        scope: CoroutineScope
+    ) {
+        scope.launch {
+            if (isLikedByMe) {
+                suggestionsCache.removeSuggestionLike(suggestionId)
+            } else {
+                suggestionsCache.cacheSuggestionLike(suggestionId)
+            }
+        }
+    }
+
     override fun suggestBook(bookEntity: BookEntity, recommendation: String): Completable {
         return loginRepository.getAuthorizationHeader()
             .flatMapCompletable { bearerToken ->

app/src/main/java/at/shockbytes/dante/suggestions/firebase/RawSuggestions.kt

@@ -0,0 +1,17 @@
+package at.shockbytes.dante.suggestions.firebase
+
+import at.shockbytes.dante.suggestions.BookSuggestionEntity
+import at.shockbytes.dante.suggestions.Suggester
+
+data class RawSuggestions(
+    val suggestions: List<RawSuggestion>
+) {
+
+    data class RawSuggestion(
+        val suggestionId: String,
+        val suggestion: BookSuggestionEntity,
+        val suggester: Suggester,
+        val recommendation: String,
+        val likes: Int
+    )
+}

app/src/main/java/at/shockbytes/dante/ui/adapter/suggestions/OnSuggestionActionClickedListener.kt

@@ -7,4 +7,6 @@ interface OnSuggestionActionClickedListener {
     fun onAddSuggestionToWishlist(suggestion: Suggestion)
 
     fun onReportBookSuggestion(suggestionId: String, suggestionTitle: String)
+
+    fun onLikeBookSuggestion(suggestionId: String, suggestionTitle: String, isLikedByMe: Boolean)
 }