add interface and implementation for both features

feature_auth/src/main/java/com/mrozon/feature_auth/data/UserAuthRepository.kt

@@ -1,49 +1,10 @@
 package com.mrozon.feature_auth.data
 
-import com.mrozon.core_api.db.HealthDiaryDao
 import com.mrozon.core_api.entity.User
-import com.mrozon.core_api.mapper.UserToUserDbMapper
-import com.mrozon.core_api.network.model.*
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flow
-import javax.inject.Inject
-import javax.inject.Singleton
 import com.mrozon.utils.network.Result
-import com.mrozon.utils.network.Result.Companion.error
-import com.mrozon.utils.network.Result.Companion.loading
-import com.mrozon.utils.network.Result.Companion.success
-
-@Singleton
-class UserAuthRepository @Inject constructor(private val userAuthRemoteDataSource: UserAuthRemoteDataSource,
-                                        private val dao: HealthDiaryDao
-
-) {
-
-    fun registerUser(user: User, password: String): Flow<Result<User>> {
-        return flow {
-            emit(loading())
-            val request = RegisterRequest(email = user.email,
-                first_name = user.firstname, last_name = user.lastname, password = password, username = user.email)
-            val response = userAuthRemoteDataSource.registerUser(request)
-            if (response.status == Result.Status.SUCCESS) {
-                emit(success(response.data!!.toUser()))
-            } else if (response.status == Result.Status.ERROR) {
-                emit(error(response.message!!))
-            }
-        }
-    }
+import kotlinx.coroutines.flow.Flow
 
-    fun loginUser(userName: String, password: String): Flow<Result<User>> {
-        return flow {
-            emit(loading())
-            val request = LoginRequest(username = userName, password = password)
-            val response = userAuthRemoteDataSource.loginUser(request)
-            if (response.status == Result.Status.SUCCESS) {
-                dao.insertUser(response.data!!.toUserDb())
-                emit(success(response.data!!.toUser()))
-            } else if (response.status == Result.Status.ERROR) {
-                emit(error(response.message!!))
-            }
-        }
-    }
+interface UserAuthRepository {
+    fun registerUser(user: User, password: String): Flow<Result<User>>
+    fun loginUser(userName: String, password: String): Flow<Result<User>>
 }

feature_auth/src/main/java/com/mrozon/feature_auth/data/UserAuthRepositoryImpl.kt

@@ -0,0 +1,49 @@
+package com.mrozon.feature_auth.data
+
+import com.mrozon.core_api.db.HealthDiaryDao
+import com.mrozon.core_api.entity.User
+import com.mrozon.core_api.mapper.UserToUserDbMapper
+import com.mrozon.core_api.network.model.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import javax.inject.Inject
+import javax.inject.Singleton
+import com.mrozon.utils.network.Result
+import com.mrozon.utils.network.Result.Companion.error
+import com.mrozon.utils.network.Result.Companion.loading
+import com.mrozon.utils.network.Result.Companion.success
+
+@Singleton
+class UserAuthRepositoryImpl @Inject constructor(private val userAuthRemoteDataSource: UserAuthRemoteDataSource,
+                                                 private val dao: HealthDiaryDao
+
+): UserAuthRepository {
+
+    override fun registerUser(user: User, password: String): Flow<Result<User>> {
+        return flow {
+            emit(loading())
+            val request = RegisterRequest(email = user.email,
+                first_name = user.firstname, last_name = user.lastname, password = password, username = user.email)
+            val response = userAuthRemoteDataSource.registerUser(request)
+            if (response.status == Result.Status.SUCCESS) {
+                emit(success(response.data!!.toUser()))
+            } else if (response.status == Result.Status.ERROR) {
+                emit(error(response.message!!))
+            }
+        }
+    }
+
+    override fun loginUser(userName: String, password: String): Flow<Result<User>> {
+        return flow {
+            emit(loading())
+            val request = LoginRequest(username = userName, password = password)
+            val response = userAuthRemoteDataSource.loginUser(request)
+            if (response.status == Result.Status.SUCCESS) {
+                dao.insertUser(response.data!!.toUserDb())
+                emit(success(response.data!!.toUser()))
+            } else if (response.status == Result.Status.ERROR) {
+                emit(error(response.message!!))
+            }
+        }
+    }
+}

feature_auth/src/main/java/com/mrozon/feature_auth/di/LoginFragmentModule.kt

@@ -2,11 +2,17 @@ package com.mrozon.feature_auth.di
 
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
+import com.mrozon.core_api.db.HealthDiaryDao
+import com.mrozon.core_api.mapper.UserToUserDbMapper
 import com.mrozon.core_api.viewmodel.ViewModelKey
+import com.mrozon.feature_auth.data.UserAuthRepository
+import com.mrozon.feature_auth.data.UserAuthRepositoryImpl
 import com.mrozon.feature_auth.presentation.LoginFragmentViewModel
 import dagger.Binds
 import dagger.Module
+import dagger.Provides
 import dagger.multibindings.IntoMap
+import javax.inject.Singleton
 
 @Module
 interface LoginFragmentModule {
@@ -19,4 +25,7 @@ interface LoginFragmentModule {
     @Binds
     fun viewModelFactory(factory: DaggerViewModelFactory): ViewModelProvider.Factory
 
+    @Binds
+    fun provideUserAuthRepository(repository: UserAuthRepositoryImpl): UserAuthRepository
+
 }

feature_auth/src/main/java/com/mrozon/feature_auth/di/RegistrationFragmentModule.kt

@@ -3,6 +3,8 @@ package com.mrozon.feature_auth.di
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import com.mrozon.core_api.viewmodel.ViewModelKey
+import com.mrozon.feature_auth.data.UserAuthRepository
+import com.mrozon.feature_auth.data.UserAuthRepositoryImpl
 import com.mrozon.feature_auth.presentation.LoginFragmentViewModel
 import com.mrozon.feature_auth.presentation.RegistrationFragmentViewModel
 import dagger.Binds
@@ -20,4 +22,7 @@ interface RegistrationFragmentModule {
     @Binds
     fun viewModelFactory(factory: DaggerViewModelFactory): ViewModelProvider.Factory
 
+    @Binds
+    fun provideUserAuthRepository(repository: UserAuthRepositoryImpl): UserAuthRepository
+
 }

feature_auth/src/main/java/com/mrozon/feature_auth/presentation/LoginFragmentViewModel.kt

@@ -4,13 +4,9 @@ import android.util.Patterns.EMAIL_ADDRESS
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.viewModelScope
-import com.mrozon.core_api.db.HealthDiaryDao
-import com.mrozon.core_api.db.model.UserDb
 import com.mrozon.core_api.entity.User
-import com.mrozon.core_api.mapper.UserToUserDbMapper
-import com.mrozon.core_api.network.model.toUserDb
-import com.mrozon.feature_auth.data.UserAuthRemoteDataSource
 import com.mrozon.feature_auth.data.UserAuthRepository
+import com.mrozon.feature_auth.data.UserAuthRepositoryImpl
 import com.mrozon.utils.base.BaseViewModel
 import com.mrozon.utils.network.Result
 //import com.mrozon.utils.extension.asFlow
@@ -19,8 +15,6 @@ import kotlinx.coroutines.channels.ConflatedBroadcastChannel
 import kotlinx.coroutines.flow.asFlow
 import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.combineLatest
-import timber.log.Timber
 import javax.inject.Inject
 
 class LoginFragmentViewModel @Inject constructor(

feature_auth/src/main/java/com/mrozon/feature_auth/presentation/RegistrationFragmentViewModel.kt

@@ -3,16 +3,10 @@ package com.mrozon.feature_auth.presentation
 import android.util.Patterns.EMAIL_ADDRESS
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
-import androidx.lifecycle.Transformations
 import androidx.lifecycle.viewModelScope
-import com.mrozon.core_api.db.HealthDiaryDao
-import com.mrozon.core_api.db.model.UserDb
-import com.mrozon.core_api.entity.Person
 import com.mrozon.core_api.entity.User
-import com.mrozon.core_api.mapper.UserToUserDbMapper
-import com.mrozon.core_api.network.model.toUserDb
-import com.mrozon.feature_auth.data.UserAuthRemoteDataSource
 import com.mrozon.feature_auth.data.UserAuthRepository
+import com.mrozon.feature_auth.data.UserAuthRepositoryImpl
 import com.mrozon.utils.base.BaseViewModel
 import com.mrozon.utils.network.Result
 //import com.mrozon.utils.extension.asFlow
@@ -21,8 +15,6 @@ import kotlinx.coroutines.channels.ConflatedBroadcastChannel
 import kotlinx.coroutines.flow.asFlow
 import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.combineLatest
-import timber.log.Timber
 import javax.inject.Inject
 
 class RegistrationFragmentViewModel @Inject constructor(

feature_person/src/main/java/com/mrozon/feature_person/data/PersonRepository.kt

@@ -1,119 +1,16 @@
 package com.mrozon.feature_person.data
 
-import androidx.lifecycle.Transformations
-import com.mrozon.core_api.db.HealthDiaryDao
+import androidx.lifecycle.LiveData
 import com.mrozon.core_api.db.model.PersonDb
-import com.mrozon.core_api.entity.Gender
 import com.mrozon.core_api.entity.Person
-import com.mrozon.core_api.mapper.PersonToPersonDbMapper
-import com.mrozon.core_api.network.model.PersonRequest
-import com.mrozon.core_api.network.model.SharePersonRequest
-import com.mrozon.core_api.network.model.toPerson
-import com.mrozon.core_api.resultLiveData
-import com.mrozon.utils.extension.toDateString
 import com.mrozon.utils.network.Result
-import com.mrozon.utils.network.Result.Companion.error
-import com.mrozon.utils.network.Result.Companion.loading
-import com.mrozon.utils.network.Result.Companion.success
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flow
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class PersonRepository @Inject constructor(private val dao: HealthDiaryDao,
-        private val personRemoteDataSource: PersonRemoteDataSource,
-        private val mapper: PersonToPersonDbMapper
-) {
-
-    fun getPersons() = resultLiveData(
-        databaseQuery = {
-            val personDb = dao.getPersons()
-            Transformations.map(personDb) {
-                mapper.reverseMap(it)
-            }
-        },
-        networkCall = { personRemoteDataSource.getPersons() },
-        saveCallResult = {
-            val persons = it.map { personResponse ->
-                personResponse.toPerson()
-            }
-            val personsDb = mapper.map(persons)
-            dao.deleteAllPerson()
-            dao.insertAllPerson(personsDb)
-        }
-    )
-
-    fun addPerson(person: Person): Flow<Result<Person>> {
-        return flow {
-            emit(loading())
-            var gender = true
-            if (person.gender==Gender.FEMALE) gender = false
-            val personRequest = PersonRequest(name=person.name, gender = gender, born = person.born.toDateString() )
-            val response = personRemoteDataSource.addPersons(personRequest)
-            if (response.status == Result.Status.SUCCESS) {
-                val personDb = mapper.map(response.data?.toPerson())
-                dao.insertPerson(personDb!!)
-                emit(success(response.data!!.toPerson()))
-            } else if (response.status == Result.Status.ERROR) {
-                emit(error(response.message!!))
-            }
-        }
-    }
-
-    fun getPerson(id: Long): Flow<Result<Person>> {
-        return flow {
-            try {
-                emit(loading())
-                val response = dao.getPerson(id)
-                emit(success(mapper.reverseMap(response)!!))
-            }
-            catch (e: Exception){
-                emit(error(e.message!!))
-            }
-        }
-    }
-
-    fun deletePerson(id: Long): Flow<Result<Unit>> {
-        return flow {
-            val response = personRemoteDataSource.deletePerson(id)
-            if (response.status == Result.Status.SUCCESS) {
-                dao.deletePerson(id)
-                emit(success())
-            } else if (response.status == Result.Status.ERROR) {
-                emit(error(response.message!!))
-            }
-        }
-    }
-
-    fun editPerson(person: Person): Flow<Result<Person>> {
-        return flow {
-            emit(loading())
-            var gender = true
-            if (person.gender==Gender.FEMALE) gender = false
-            val personRequest = PersonRequest(name=person.name, gender = gender, born = person.born.toDateString() )
-            val response = personRemoteDataSource.editPerson(person.id, personRequest)
-            if (response.status == Result.Status.SUCCESS) {
-                val personDb = mapper.map(response.data?.toPerson())
-                dao.insertPerson(personDb!!)
-                emit(success(response.data!!.toPerson()))
-            } else if (response.status == Result.Status.ERROR) {
-                emit(error(response.message!!))
-            }
-        }
-    }
-
-    fun sharePerson(id: Long, userName: String): Flow<Result<Unit>> {
-        return flow {
-            emit(loading())
-            val request = SharePersonRequest(patient_id = id.toInt(), username = userName)
-            val response = personRemoteDataSource.sharePerson(request)
-            if (response.status == Result.Status.SUCCESS) {
-                emit(success())
-            } else if (response.status == Result.Status.ERROR) {
-                emit(error(response.message!!))
-            }
-        }
-    }
 
+interface PersonRepository {
+    fun getPersons(): LiveData<Result<List<Person>>>
+    fun addPerson(person: Person): Flow<Result<Person>>
+    fun getPerson(id: Long): Flow<Result<Person>>
+    fun deletePerson(id: Long): Flow<Result<Unit>>
+    fun editPerson(person: Person): Flow<Result<Person>>
+    fun sharePerson(id: Long, userName: String): Flow<Result<Unit>>
 }

feature_person/src/main/java/com/mrozon/feature_person/data/PersonRepositoryImpl.kt

@@ -0,0 +1,121 @@
+package com.mrozon.feature_person.data
+
+import androidx.lifecycle.Transformations
+import com.mrozon.core_api.db.HealthDiaryDao
+import com.mrozon.core_api.db.model.PersonDb
+import com.mrozon.core_api.entity.Gender
+import com.mrozon.core_api.entity.Person
+import com.mrozon.core_api.mapper.PersonToPersonDbMapper
+import com.mrozon.core_api.network.model.PersonRequest
+import com.mrozon.core_api.network.model.PersonResponse
+import com.mrozon.core_api.network.model.SharePersonRequest
+import com.mrozon.core_api.network.model.toPerson
+import com.mrozon.core_api.resultLiveData
+import com.mrozon.utils.extension.toDateString
+import com.mrozon.utils.network.Result
+import com.mrozon.utils.network.Result.Companion.error
+import com.mrozon.utils.network.Result.Companion.loading
+import com.mrozon.utils.network.Result.Companion.success
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import retrofit2.Response
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class PersonRepositoryImpl @Inject constructor(private val dao: HealthDiaryDao,
+        private val personRemoteDataSource: PersonRemoteDataSource,
+        private val mapper: PersonToPersonDbMapper
+): PersonRepository {
+
+    override fun getPersons() = resultLiveData(
+        databaseQuery = {
+            val personDb = dao.getPersons()
+            Transformations.map(personDb) {
+                mapper.reverseMap(it)
+            }
+        },
+        networkCall = { personRemoteDataSource.getPersons() },
+        saveCallResult = {
+            val persons = it.map { personResponse ->
+                personResponse.toPerson()
+            }
+            val personsDb = mapper.map(persons)
+            dao.deleteAllPerson()
+            dao.insertAllPerson(personsDb)
+        }
+    )
+
+    override fun addPerson(person: Person): Flow<Result<Person>> {
+        return flow {
+            emit(loading())
+            var gender = true
+            if (person.gender==Gender.FEMALE) gender = false
+            val personRequest = PersonRequest(name=person.name, gender = gender, born = person.born.toDateString() )
+            val response = personRemoteDataSource.addPersons(personRequest)
+            if (response.status == Result.Status.SUCCESS) {
+                val personDb = mapper.map(response.data?.toPerson())
+                dao.insertPerson(personDb!!)
+                emit(success(response.data!!.toPerson()))
+            } else if (response.status == Result.Status.ERROR) {
+                emit(error(response.message!!))
+            }
+        }
+    }
+
+    override fun getPerson(id: Long): Flow<Result<Person>> {
+        return flow {
+            try {
+                emit(loading())
+                val response = dao.getPerson(id)
+                emit(success(mapper.reverseMap(response)!!))
+            }
+            catch (e: Exception){
+                emit(error(e.message!!))
+            }
+        }
+    }
+
+    override fun deletePerson(id: Long): Flow<Result<Unit>> {
+        return flow {
+            val response = personRemoteDataSource.deletePerson(id)
+            if (response.status == Result.Status.SUCCESS) {
+                dao.deletePerson(id)
+                emit(success())
+            } else if (response.status == Result.Status.ERROR) {
+                emit(error(response.message!!))
+            }
+        }
+    }
+
+    override fun editPerson(person: Person): Flow<Result<Person>> {
+        return flow {
+            emit(loading())
+            var gender = true
+            if (person.gender==Gender.FEMALE) gender = false
+            val personRequest = PersonRequest(name=person.name, gender = gender, born = person.born.toDateString() )
+            val response = personRemoteDataSource.editPerson(person.id, personRequest)
+            if (response.status == Result.Status.SUCCESS) {
+                val personDb = mapper.map(response.data?.toPerson())
+                dao.insertPerson(personDb!!)
+                emit(success(response.data!!.toPerson()))
+            } else if (response.status == Result.Status.ERROR) {
+                emit(error(response.message!!))
+            }
+        }
+    }
+
+    override fun sharePerson(id: Long, userName: String): Flow<Result<Unit>> {
+        return flow {
+            emit(loading())
+            val request = SharePersonRequest(patient_id = id.toInt(), username = userName)
+            val response = personRemoteDataSource.sharePerson(request)
+            if (response.status == Result.Status.SUCCESS) {
+                emit(success())
+            } else if (response.status == Result.Status.ERROR) {
+                emit(error(response.message!!))
+            }
+        }
+    }
+
+}

feature_person/src/main/java/com/mrozon/feature_person/di/EditPersonFragmentModule.kt

@@ -3,6 +3,8 @@ package com.mrozon.feature_person.di
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import com.mrozon.core_api.viewmodel.ViewModelKey
+import com.mrozon.feature_person.data.PersonRepository
+import com.mrozon.feature_person.data.PersonRepositoryImpl
 import com.mrozon.feature_person.presentation.EditPersonFragmentViewModel
 import com.mrozon.feature_person.presentation.ListPersonFragmentViewModel
 import dagger.Binds
@@ -18,4 +20,7 @@ interface EditPersonFragmentModule {
 
     @Binds
     fun viewModelFactory(factory: DaggerViewModelFactory): ViewModelProvider.Factory
+
+    @Binds
+    fun providePersonRepository(repository: PersonRepositoryImpl): PersonRepository
 }

feature_person/src/main/java/com/mrozon/feature_person/di/ListPersonFragmentModule.kt

@@ -3,6 +3,8 @@ package com.mrozon.feature_person.di
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import com.mrozon.core_api.viewmodel.ViewModelKey
+import com.mrozon.feature_person.data.PersonRepository
+import com.mrozon.feature_person.data.PersonRepositoryImpl
 import com.mrozon.feature_person.presentation.ListPersonFragmentViewModel
 import dagger.Binds
 import dagger.Module
@@ -17,4 +19,7 @@ interface ListPersonFragmentModule {
 
     @Binds
     fun viewModelFactory(factory: DaggerViewModelFactory): ViewModelProvider.Factory
+
+    @Binds
+    fun providePersonRepository(repository: PersonRepositoryImpl): PersonRepository
 }