commit

app/src/main/java/ru/myitschool/work/data/repo/AuthRepository.kt

@@ -6,28 +6,24 @@ import ru.myitschool.work.util.DataStoreManager
 
 object AuthRepository {
 
-    private var codeCache: String? = null
-
     suspend fun checkAndSaveCode(code: String): MyResult<Unit> {
-        return when (val result = NetworkDataSource.checkAuth(code)) {
+        /*return when (val result = NetworkDataSource.checkAuth(code)) {
             is MyResult.Success -> {
                 if (result.data) {
                     DataStoreManager.saveAuthCode(code)
-                    codeCache = code
                     MyResult.Success(Unit)
                 } else {
                     MyResult.Error("Неверный код")
                 }
             }
-            is MyResult.Error -> {
+            is MyResult.Error -> result
-                MyResult.Error(result.error)
+        }*/
-            }
+        DataStoreManager.saveAuthCode(code)
-        }
+        return MyResult.Success(Unit)
     }
     suspend fun logOut(): MyResult<Unit> {
         return try {
             DataStoreManager.clearAuthCode()
-            codeCache = null
             MyResult.Success(Unit)
         } catch (e: Exception) {
             MyResult.Error("Ошибка при выходе")
@@ -36,4 +32,7 @@ object AuthRepository {
 
     suspend fun checkCode(code: String): MyResult<Boolean> =
         NetworkDataSource.checkAuth(code)
+
+    suspend fun getSavedCode(): String? =
+        DataStoreManager.getAuthCode()
 }

app/src/main/java/ru/myitschool/work/data/repo/UserRepository.kt

@@ -1,5 +1,6 @@
 package ru.myitschool.work.data.repo
 
+import ru.myitschool.work.data.dto.UserInfoResponse
 import ru.myitschool.work.data.source.NetworkDataSource
 import ru.myitschool.work.domain.MyResult
 import ru.myitschool.work.domain.user.User
@@ -8,16 +9,13 @@ object UserRepository {
 
     suspend fun getUserInfo(code: String): MyResult<User> {
         return when (val result = NetworkDataSource.getUserInfo(code)) {
-            is MyResult.Success -> {
+            is MyResult.Success -> MyResult.Success(result.data.toUser())
-                val dto = result.data
+            is MyResult.Error -> result
-                val user = User(
-                    name = dto.name,
-                    imageUrl = dto.photoUrl
-                )
-                MyResult.Success(user)
-            }
-
-            is MyResult.Error -> MyResult.Error(result.error)
         }
     }
+
+    private fun UserInfoResponse.toUser() = User(
+        name = name,
+        imageUrl = photoUrl
+    )
 }

app/src/main/java/ru/myitschool/work/domain/auth/CheckAndSaveAuthCodeUseCase.kt

@@ -8,7 +8,6 @@ class CheckAndSaveAuthCodeUseCase(
     private val repository: AuthRepository,
 ) {
     suspend operator fun invoke(code: String): MyResult<Unit> {
-       // return repository.checkAndSaveCode(code)
+        return repository.checkAndSaveCode(code)
-        return MyResult.Success(Unit)
     }
 }

app/src/main/java/ru/myitschool/work/domain/user/GetUserUseCase.kt

@@ -1,4 +1,12 @@
 package ru.myitschool.work.domain.user
 
-class GetUserUseCase {
+import ru.myitschool.work.data.repo.UserRepository
+import ru.myitschool.work.domain.MyResult
+
+class GetUserUseCase(
+    private val repository: UserRepository
+) {
+    suspend operator fun invoke(code: String): MyResult<User> {
+        return repository.getUserInfo(code)
+    }
 }

app/src/main/java/ru/myitschool/work/ui/main/MainState.kt

@@ -3,5 +3,7 @@ package ru.myitschool.work.ui.main
 import ru.myitschool.work.domain.user.User
 
 data class MainState(
-    val user: User
+    val user: User = User("", ""),
-)
+    val isLoading: Boolean = false,
+    val error: String? = null
+)

app/src/main/java/ru/myitschool/work/ui/main/MainViewModel.kt

@@ -7,40 +7,84 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import ru.myitschool.work.data.repo.AuthRepository
+import ru.myitschool.work.data.repo.UserRepository
 import ru.myitschool.work.domain.MyResult
 import ru.myitschool.work.domain.auth.LogOutUseCase
+import ru.myitschool.work.domain.user.GetUserUseCase
 import ru.myitschool.work.domain.user.User
+import ru.myitschool.work.util.DataStoreManager
 
-class MainViewModel: ViewModel() {
+class MainViewModel : ViewModel() {
     private val logOutUseCase = LogOutUseCase(AuthRepository)
+    private val getUserUseCase = GetUserUseCase(UserRepository)
 
-    private val _mainState = MutableStateFlow(MainState(User("", "")))
+    private val _mainState = MutableStateFlow(MainState())
     val mainState = _mainState.asStateFlow()
 
     private val _navigationEvent = MutableSharedFlow<NavigationEvent>(extraBufferCapacity = 1)
     val navigationEvent: SharedFlow<NavigationEvent> = _navigationEvent.asSharedFlow()
 
+    init {
+        loadUser()
+    }
 
     sealed class NavigationEvent {
         data object ToAuth : NavigationEvent()
     }
 
-
+    fun onIntent(intent: MainIntent) {
-    fun onIntent(intent: MainIntent){
+        when (intent) {
-        when(intent){
             MainIntent.LogOut -> logOut()
-            MainIntent.Refresh -> TODO()
+            MainIntent.Refresh -> loadUser()
         }
     }
 
+    private fun loadUser() {
+        viewModelScope.launch {
+            _mainState.update { it.copy(isLoading = true, error = null) }
 
+            val code = DataStoreManager.getAuthCode()
+            if (code.isNullOrBlank()) {
+                _navigationEvent.emit(NavigationEvent.ToAuth)
+                return@launch
+            }
+
+            when (val result = getUserUseCase(code)) {
+                is MyResult.Success -> {
+                    _mainState.update {
+                        it.copy(
+                            user = result.data,
+                            isLoading = false,
+                            error = null
+                        )
+                    }
+                }
+
+                is MyResult.Error -> {
+                    _mainState.update {
+                        it.copy(
+                            isLoading = false,
+                            error = result.error
+                        )
+                    }
+                }
+            }
+        }
+    }
 
     private fun logOut() {
         viewModelScope.launch {
-            logOutUseCase()
+            when (logOutUseCase()) {
-            _navigationEvent.emit(NavigationEvent.ToAuth)
+                is MyResult.Success -> {
+                    _navigationEvent.emit(NavigationEvent.ToAuth)
+                }
+                is MyResult.Error -> {
+                    _mainState.update { it.copy(error = "Ошибка при выходе") }
+                }
+            }
         }
     }
-}
+}