Refactoring of book, user and note repositories

app/src/main/java/com/sirekanyan/knigopis/repository/BookRepository.kt

@@ -1,18 +1,25 @@
 package com.sirekanyan.knigopis.repository
 
 import com.sirekanyan.knigopis.common.NetworkChecker
-import com.sirekanyan.knigopis.common.logError
-import com.sirekanyan.knigopis.common.logWarn
+import com.sirekanyan.knigopis.model.BookModel
 import com.sirekanyan.knigopis.repository.api.Endpoint
-import com.sirekanyan.knigopis.repository.cache.BookCache
-import com.sirekanyan.knigopis.repository.model.*
+import com.sirekanyan.knigopis.repository.cache.common.CacheKey
+import com.sirekanyan.knigopis.repository.cache.common.CommonCache
+import com.sirekanyan.knigopis.repository.cache.common.genericType
+import com.sirekanyan.knigopis.repository.common.CommonRepository
+import com.sirekanyan.knigopis.repository.model.FinishedBook
+import com.sirekanyan.knigopis.repository.model.FinishedBookToSend
+import com.sirekanyan.knigopis.repository.model.PlannedBook
+import com.sirekanyan.knigopis.repository.model.PlannedBookToSend
 import io.reactivex.Completable
+import io.reactivex.Flowable
+import io.reactivex.Maybe
 import io.reactivex.Single
 import io.reactivex.rxkotlin.Singles
 
 interface BookRepository {
 
-    fun loadBooks(): Single<List<Pair<Book, BookHeader>>>
+    fun loadBooks(): Flowable<List<BookModel>>
 
     fun saveBook(bookId: String?, book: FinishedBookToSend, done: Boolean?): Completable
 
@@ -22,30 +29,15 @@ interface BookRepository {
 
 class BookRepositoryImpl(
     private val api: Endpoint,
-    private val cache: BookCache,
+    private val cache: CommonCache,
     private val auth: KAuth,
     private val plannedBookOrganizer: BookOrganizer<PlannedBook>,
     private val finishedBookPrepare: BookOrganizer<FinishedBook>,
-    private val networkChecker: NetworkChecker
-) : BookRepository {
+    networkChecker: NetworkChecker
+) : CommonRepository<List<BookModel>>(networkChecker),
+    BookRepository {
 
-    override fun loadBooks(): Single<List<Pair<Book, BookHeader>>> =
-        if (networkChecker.isNetworkAvailable()) {
-            getFromNetwork()
-                .doOnSuccess { saveToCache(it).blockingAwait() }
-                .doOnError {
-                    logError("Cannot load books from network", it)
-                    logWarn("Getting cached books")
-                }
-                .onErrorResumeNext(findInCache())
-        } else {
-            findInCache()
-        }.map { (planned, finished) ->
-            mutableListOf<Pair<Book, BookHeader>>().apply {
-                addAll(plannedBookOrganizer.organize(planned))
-                addAll(finishedBookPrepare.organize(finished))
-            }
-        }
+    override fun loadBooks() = observe()
 
     override fun saveBook(bookId: String?, book: FinishedBookToSend, done: Boolean?): Completable =
         when {
@@ -69,24 +61,22 @@ class BookRepositoryImpl(
             }
         }
 
-    private fun getFromNetwork(): Single<Pair<List<PlannedBook>, List<FinishedBook>>> =
+    override fun loadFromNetwork(): Single<List<BookModel>> =
         Singles.zip(
             api.getPlannedBooks(auth.getAccessToken()),
             api.getFinishedBooks(auth.getAccessToken())
         )
+            .map { (planned, finished) ->
+                mutableListOf<BookModel>().apply {
+                    addAll(plannedBookOrganizer.organize(planned))
+                    addAll(finishedBookPrepare.organize(finished))
+                }
+            }
 
-    private fun findInCache(): Single<Pair<List<PlannedBook>, List<FinishedBook>>> =
-        Singles.zip(
-            cache.getPlannedBooks().toSingle(),
-            cache.getFinishedBooks().toSingle()
-        )
+    override fun findCached(): Maybe<List<BookModel>> =
+        cache.getFromJson(CacheKey.BOOKS, genericType<List<BookModel>>())
 
-    private fun saveToCache(books: Pair<List<PlannedBook>, List<FinishedBook>>): Completable =
-        books.let { (planned, finished) ->
-            Completable.concatArray(
-                cache.savePlannedBooks(planned),
-                cache.saveFinishedBooks(finished)
-            )
-        }
+    override fun saveToCache(data: List<BookModel>): Completable =
+        cache.saveToJson(CacheKey.BOOKS, data)
 
 }

app/src/main/java/com/sirekanyan/knigopis/repository/NoteRepository.kt

@@ -1,46 +1,40 @@
 package com.sirekanyan.knigopis.repository
 
 import com.sirekanyan.knigopis.common.NetworkChecker
-import com.sirekanyan.knigopis.common.logError
-import com.sirekanyan.knigopis.common.logWarn
+import com.sirekanyan.knigopis.model.NoteModel
+import com.sirekanyan.knigopis.model.toNoteModel
 import com.sirekanyan.knigopis.repository.api.Endpoint
-import com.sirekanyan.knigopis.repository.cache.NoteCache
-import com.sirekanyan.knigopis.repository.model.note.Note
+import com.sirekanyan.knigopis.repository.cache.common.CacheKey
+import com.sirekanyan.knigopis.repository.cache.common.CommonCache
+import com.sirekanyan.knigopis.repository.cache.common.genericType
+import com.sirekanyan.knigopis.repository.common.CommonRepository
 import io.reactivex.Completable
+import io.reactivex.Flowable
+import io.reactivex.Maybe
 import io.reactivex.Single
 
 interface NoteRepository {
 
-    fun getNotes(): Single<List<Note>>
+    fun getNotes(): Flowable<List<NoteModel>>
 
 }
 
 class NoteRepositoryImpl(
     private val api: Endpoint,
-    private val cache: NoteCache,
-    private val networkChecker: NetworkChecker
-) : NoteRepository {
-
-    override fun getNotes(): Single<List<Note>> =
-        if (networkChecker.isNetworkAvailable()) {
-            getFromNetwork()
-                .doOnSuccess { saveToCache(it).blockingAwait() }
-                .doOnError {
-                    logError("Cannot load notes from network", it)
-                    logWarn("Getting cached notes")
-                }
-                .onErrorResumeNext(findInCache())
-        } else {
-            findInCache()
-        }
-
-    private fun getFromNetwork(): Single<List<Note>> =
-        api.getLatestBooksWithNotes().map { it.values.toList() }
-
-    private fun findInCache(): Single<List<Note>> =
-        cache.getNotes().toSingle()
-
-    private fun saveToCache(notes: List<Note>): Completable =
-        cache.saveNotes(notes)
+    private val cache: CommonCache,
+    networkChecker: NetworkChecker
+) : CommonRepository<List<NoteModel>>(networkChecker),
+    NoteRepository {
+
+    override fun getNotes() = observe()
+
+    override fun loadFromNetwork(): Single<List<NoteModel>> =
+        api.getLatestBooksWithNotes().map { it.values.map { it.toNoteModel() } }
+
+    override fun findCached(): Maybe<List<NoteModel>> =
+        cache.getFromJson(CacheKey.NOTES, genericType<List<NoteModel>>())
+
+    override fun saveToCache(data: List<NoteModel>): Completable =
+        cache.saveToJson(CacheKey.NOTES, data)
 
 }

app/src/main/java/com/sirekanyan/knigopis/repository/SubscriptionRepository.kt

@@ -1,47 +1,41 @@
 package com.sirekanyan.knigopis.repository
 
 import com.sirekanyan.knigopis.common.NetworkChecker
-import com.sirekanyan.knigopis.common.logError
-import com.sirekanyan.knigopis.common.logWarn
+import com.sirekanyan.knigopis.model.UserModel
+import com.sirekanyan.knigopis.model.toUserModel
 import com.sirekanyan.knigopis.repository.api.Endpoint
-import com.sirekanyan.knigopis.repository.cache.SubscriptionCache
-import com.sirekanyan.knigopis.repository.model.subscription.Subscription
+import com.sirekanyan.knigopis.repository.cache.common.CacheKey
+import com.sirekanyan.knigopis.repository.cache.common.CommonCache
+import com.sirekanyan.knigopis.repository.cache.common.genericType
+import com.sirekanyan.knigopis.repository.common.CommonRepository
 import io.reactivex.Completable
+import io.reactivex.Flowable
+import io.reactivex.Maybe
 import io.reactivex.Single
 
 interface SubscriptionRepository {
 
-    fun getSubscriptions(): Single<List<Subscription>>
+    fun getSubscriptions(): Flowable<List<UserModel>>
 
 }
 
 class SubscriptionRepositoryImpl(
     private val api: Endpoint,
-    private val cache: SubscriptionCache,
+    private val cache: CommonCache,
     private val auth: KAuth,
-    private val networkChecker: NetworkChecker
-) : SubscriptionRepository {
-
-    override fun getSubscriptions(): Single<List<Subscription>> =
-        if (networkChecker.isNetworkAvailable()) {
-            getFromNetwork()
-                .doOnSuccess { saveToCache(it).blockingAwait() }
-                .doOnError {
-                    logError("Cannot load subscriptions from network", it)
-                    logWarn("Getting cached subscriptions")
-                }
-                .onErrorResumeNext(findInCache())
-        } else {
-            findInCache()
-        }
-
-    private fun getFromNetwork(): Single<List<Subscription>> =
-        api.getSubscriptions(auth.getAccessToken())
-
-    private fun findInCache(): Single<List<Subscription>> =
-        cache.getSubscriptions().toSingle()
-
-    private fun saveToCache(subscriptions: List<Subscription>): Completable =
-        cache.saveSubscriptions(subscriptions)
+    networkChecker: NetworkChecker
+) : CommonRepository<List<UserModel>>(networkChecker),
+    SubscriptionRepository {
+
+    override fun getSubscriptions() = observe()
+
+    override fun loadFromNetwork(): Single<List<UserModel>> =
+        api.getSubscriptions(auth.getAccessToken()).map { it.map { it.toUserModel() } }
+
+    override fun findCached(): Maybe<List<UserModel>> =
+        cache.getFromJson(CacheKey.USERS, genericType<List<UserModel>>())
+
+    override fun saveToCache(data: List<UserModel>): Completable =
+        cache.saveToJson(CacheKey.USERS, data)
 
 }