GithubTrending

Data/.gitignore

@@ -0,0 +1 @@
+/build

Data/build.gradle

@@ -0,0 +1,21 @@
+apply plugin: 'kotlin'
+
+dependencies {
+    def dataDependencies = rootProject.ext.dataDependencies
+    def dataTestDependencies = rootProject.ext.dataTestDependencies
+
+    compile project(':Domain')
+
+    implementation dataDependencies.javaxAnnotation
+    implementation dataDependencies.kotlin
+    implementation dataDependencies.javaxInject
+    implementation dataDependencies.rxKotlin
+
+    testImplementation dataTestDependencies.junit
+    testImplementation dataTestDependencies.kotlinJUnit
+    testImplementation dataTestDependencies.mockito
+    testImplementation dataTestDependencies.assertj
+}
+
+sourceCompatibility = "1.6"
+targetCompatibility = "1.6"

Data/src/main/java/co/joebirch/data/ProjectsDataRepository.kt

@@ -0,0 +1,54 @@
+package co.joebirch.data
+
+import co.joebirch.data.mapper.ProjectMapper
+import co.joebirch.data.repository.ProjectsCache
+import co.joebirch.data.store.ProjectsDataStoreFactory
+import co.joebirch.domain.model.Project
+import co.joebirch.domain.repository.ProjectsRepository
+import io.reactivex.Completable
+import io.reactivex.Observable
+import io.reactivex.functions.BiFunction
+import javax.inject.Inject
+
+class ProjectsDataRepository @Inject constructor(
+        private val mapper: ProjectMapper,
+        private val cache: ProjectsCache,
+        private val factory: ProjectsDataStoreFactory)
+    : ProjectsRepository {
+
+    override fun getProjects(): Observable<List<Project>> {
+        return Observable.zip(cache.areProjectsCached().toObservable(),
+                cache.isProjectsCacheExpired().toObservable(),
+                BiFunction<Boolean, Boolean, Pair<Boolean, Boolean>> { areCached, isExpired ->
+                    Pair(areCached, isExpired)
+                })
+                .flatMap {
+                    factory.getDataStore(it.first, it.second).getProjects().toObservable()
+                            .distinctUntilChanged()
+                }
+                .flatMap { projects ->
+                    factory.getCacheDataStore()
+                            .saveProjects(projects)
+                            .andThen(Observable.just(projects))
+                }
+                .map {
+                    it.map {
+                        mapper.mapFromEntity(it)
+                    }
+                }
+    }
+
+    override fun bookmarkProject(projectId: String): Completable {
+        return factory.getCacheDataStore().setProjectAsBookmarked(projectId)
+    }
+
+    override fun unbookmarkProject(projectId: String): Completable {
+        return factory.getCacheDataStore().setProjectAsNotBookmarked(projectId)
+    }
+
+    override fun getBookmarkedProjects(): Observable<List<Project>> {
+        return factory.getCacheDataStore().getBookmarkedProjects().toObservable()
+                .map { it.map { mapper.mapFromEntity(it) } }
+    }
+
+}

Data/src/main/java/co/joebirch/data/mapper/EntityMapper.kt

@@ -0,0 +1,9 @@
+package co.joebirch.data.mapper
+
+interface EntityMapper<E, D> {
+
+    fun mapFromEntity(entity: E): D
+
+    fun mapToEntity(domain: D): E
+
+}

Data/src/main/java/co/joebirch/data/mapper/ProjectMapper.kt

@@ -0,0 +1,20 @@
+package co.joebirch.data.mapper
+
+import co.joebirch.data.model.ProjectEntity
+import co.joebirch.domain.model.Project
+import javax.inject.Inject
+
+open class ProjectMapper @Inject constructor() : EntityMapper<ProjectEntity, Project> {
+
+    override fun mapFromEntity(entity: ProjectEntity): Project {
+        return Project(entity.id, entity.name, entity.fullName, entity.starCount,
+                entity.dateCreated, entity.ownerName, entity.ownerAvatar, entity.isBookmarked)
+    }
+
+    override fun mapToEntity(domain: Project): ProjectEntity {
+        return ProjectEntity(domain.id, domain.name, domain.fullName,
+                domain.starCount, domain.dateCreated, domain.ownerName,
+                domain.ownerAvatar, domain.isBookmarked)
+    }
+
+}

Data/src/main/java/co/joebirch/data/model/ProjectEntity.kt

@@ -0,0 +1,6 @@
+package co.joebirch.data.model
+
+data class ProjectEntity(val id: String, val name: String, val fullName: String,
+                         val starCount: String, val dateCreated: String,
+                         val ownerName: String, val ownerAvatar: String,
+                         val isBookmarked: Boolean)

Data/src/main/java/co/joebirch/data/repository/ProjectsCache.kt

@@ -0,0 +1,28 @@
+package co.joebirch.data.repository
+
+import co.joebirch.data.model.ProjectEntity
+import io.reactivex.Completable
+import io.reactivex.Flowable
+import io.reactivex.Single
+
+interface ProjectsCache  {
+
+    fun clearProjects(): Completable
+
+    fun saveProjects(projects: List<ProjectEntity>): Completable
+
+    fun getProjects(): Flowable<List<ProjectEntity>>
+
+    fun getBookmarkedProjects(): Flowable<List<ProjectEntity>>
+
+    fun setProjectAsBookmarked(projectId: String): Completable
+
+    fun setProjectAsNotBookmarked(projectId: String): Completable
+
+    fun areProjectsCached(): Single<Boolean>
+
+    fun setLastCacheTime(lastCache: Long): Completable
+
+    fun isProjectsCacheExpired(): Flowable<Boolean>
+
+}

Data/src/main/java/co/joebirch/data/repository/ProjectsDataStore.kt

@@ -0,0 +1,21 @@
+package co.joebirch.data.repository
+
+import co.joebirch.data.model.ProjectEntity
+import io.reactivex.Completable
+import io.reactivex.Flowable
+
+interface ProjectsDataStore {
+
+    fun getProjects(): Flowable<List<ProjectEntity>>
+
+    fun saveProjects(projects: List<ProjectEntity>): Completable
+
+    fun clearProjects(): Completable
+
+    fun getBookmarkedProjects(): Flowable<List<ProjectEntity>>
+
+    fun setProjectAsBookmarked(projectId: String): Completable
+
+    fun setProjectAsNotBookmarked(projectId: String): Completable
+
+}

Data/src/main/java/co/joebirch/data/repository/ProjectsRemote.kt

@@ -0,0 +1,10 @@
+package co.joebirch.data.repository
+
+import co.joebirch.data.model.ProjectEntity
+import io.reactivex.Flowable
+
+interface ProjectsRemote {
+
+    fun getProjects(): Flowable<List<ProjectEntity>>
+
+}

Data/src/main/java/co/joebirch/data/store/ProjectsCacheDataStore.kt

@@ -0,0 +1,40 @@
+package co.joebirch.data.store
+
+import co.joebirch.data.model.ProjectEntity
+import co.joebirch.data.repository.ProjectsCache
+import co.joebirch.data.repository.ProjectsDataStore
+import io.reactivex.Completable
+import io.reactivex.Flowable
+import io.reactivex.Observable
+import javax.inject.Inject
+
+open class ProjectsCacheDataStore @Inject constructor(
+        private val projectsCache: ProjectsCache)
+    : ProjectsDataStore {
+
+    override fun getProjects(): Flowable<List<ProjectEntity>> {
+        return projectsCache.getProjects()
+    }
+
+    override fun saveProjects(projects: List<ProjectEntity>): Completable {
+        return projectsCache.saveProjects(projects)
+                .andThen(projectsCache.setLastCacheTime(System.currentTimeMillis()))
+    }
+
+    override fun clearProjects(): Completable {
+        return projectsCache.clearProjects()
+    }
+
+    override fun getBookmarkedProjects(): Flowable<List<ProjectEntity>> {
+        return projectsCache.getBookmarkedProjects()
+    }
+
+    override fun setProjectAsBookmarked(projectId: String): Completable {
+        return projectsCache.setProjectAsBookmarked(projectId)
+    }
+
+    override fun setProjectAsNotBookmarked(projectId: String): Completable {
+        return projectsCache.setProjectAsNotBookmarked(projectId)
+    }
+
+}

Data/src/main/java/co/joebirch/data/store/ProjectsDataStoreFactory.kt

@@ -0,0 +1,27 @@
+package co.joebirch.data.store
+
+import co.joebirch.data.repository.ProjectsDataStore
+import javax.inject.Inject
+
+open class ProjectsDataStoreFactory @Inject constructor(
+        private val projectsCacheDataStore: ProjectsCacheDataStore,
+        private val projectsRemoteDataStore: ProjectsRemoteDataStore) {
+
+    open fun getDataStore(projectsCached: Boolean,
+                          cacheExpired: Boolean): ProjectsDataStore {
+        return if (projectsCached && !cacheExpired) {
+            projectsCacheDataStore
+        } else {
+            projectsRemoteDataStore
+        }
+    }
+
+    open fun getCacheDataStore(): ProjectsDataStore {
+        return projectsCacheDataStore
+    }
+
+    fun getRemoteDataStore(): ProjectsDataStore {
+        return projectsRemoteDataStore
+    }
+
+}

Data/src/main/java/co/joebirch/data/store/ProjectsRemoteDataStore.kt

@@ -0,0 +1,38 @@
+package co.joebirch.data.store
+
+import co.joebirch.data.model.ProjectEntity
+import co.joebirch.data.repository.ProjectsDataStore
+import co.joebirch.data.repository.ProjectsRemote
+import io.reactivex.Completable
+import io.reactivex.Flowable
+import javax.inject.Inject
+
+open class ProjectsRemoteDataStore @Inject constructor(
+        private val projectsRemote: ProjectsRemote)
+    : ProjectsDataStore {
+
+    override fun getProjects(): Flowable<List<ProjectEntity>> {
+        return projectsRemote.getProjects()
+    }
+
+    override fun saveProjects(projects: List<ProjectEntity>): Completable {
+        throw UnsupportedOperationException("Saving projects isn't supported here...")
+    }
+
+    override fun clearProjects(): Completable {
+        throw UnsupportedOperationException("Clearing projects isn't supported here...")
+    }
+
+    override fun getBookmarkedProjects(): Flowable<List<ProjectEntity>> {
+        throw UnsupportedOperationException("Getting bookmarked projects isn't supported here...")
+    }
+
+    override fun setProjectAsBookmarked(projectId: String): Completable {
+        throw UnsupportedOperationException("Setting bookmarks isn't supported here...")
+    }
+
+    override fun setProjectAsNotBookmarked(projectId: String): Completable {
+        throw UnsupportedOperationException("Setting bookmarks isn't supported here...")
+    }
+
+}