release/0.1.6 (#103)

* Bump com.google.guava:guava from 33.3.1-jre to 33.4.0-jre (#97)

* Bump coroutines from 1.9.0 to 1.10.1 (#100)

* some improvements + loading conversation on new message if it is not already in the list

* Bump koin from 4.0.0 to 4.0.1 (#101)

* minor update

---------

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

core/common/src/main/kotlin/dev/meloda/fast/common/extensions/Extensions.kt

@@ -1,7 +1,5 @@
 package dev.meloda.fast.common.extensions
 
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay

core/data/src/main/kotlin/dev/meloda/fast/data/State.kt

@@ -20,18 +20,20 @@ sealed class State<out T> {
 
         data object ConnectionError : Error()
 
-        data object Unknown : Error()
+        data object UnknownError : Error()
 
         data object InternalError : Error()
 
         data class OAuthError(val error: OAuthErrorDomain) : Error()
+
+        data class TestError(val message: String) : Error()
     }
 
     fun isLoading(): Boolean = this is Loading
 
     companion object {
 
-        val UNKNOWN_ERROR = Error.Unknown
+        val UNKNOWN_ERROR = Error.UnknownError
     }
 }
 
@@ -73,11 +75,12 @@ fun <T : Any> ApiResult<T, RestApiErrorDomain>.mapToState() = when (this) {
     is ApiResult.Failure.ApiFailure -> this.error.toStateApiError()
 }
 
-fun <T : Any, N> ApiResult<T, RestApiErrorDomain>.mapToState(successMapper: (T) -> N) = when (this) {
-    is ApiResult.Success -> State.Success(successMapper(this.value))
+fun <T : Any, N> ApiResult<T, RestApiErrorDomain>.mapToState(successMapper: (T) -> N) =
+    when (this) {
+        is ApiResult.Success -> State.Success(successMapper(this.value))
 
-    is ApiResult.Failure.NetworkFailure -> State.Error.ConnectionError
-    is ApiResult.Failure.UnknownFailure -> State.UNKNOWN_ERROR
-    is ApiResult.Failure.HttpFailure -> this.error.toStateApiError()
-    is ApiResult.Failure.ApiFailure -> this.error.toStateApiError()
-}
+        is ApiResult.Failure.NetworkFailure -> State.Error.ConnectionError
+        is ApiResult.Failure.UnknownFailure -> State.UNKNOWN_ERROR
+        is ApiResult.Failure.HttpFailure -> this.error.toStateApiError()
+        is ApiResult.Failure.ApiFailure -> this.error.toStateApiError()
+    }

core/domain/src/main/kotlin/dev/meloda/fast/domain/OAuthUseCaseImpl.kt

@@ -33,92 +33,100 @@ class OAuthUseCaseImpl(
             forceSms = forceSms
         )
 
-        val error = response.error?.let(VkOAuthError::parse)
-        val errorType = response.errorType?.let(VkOAuthErrorType::parse)
+        kotlin.runCatching {
+            val error = response.error?.let(VkOAuthError::parse)
+            val errorType = response.errorType?.let(VkOAuthErrorType::parse)
 
-        val newState = when (error) {
-            null -> {
-                State.Success(
-                    AuthInfo(
-                        userId = response.userId,
-                        accessToken = response.accessToken,
-                        validationHash = response.validationHash
-                    )
-                )
-            }
-
-            VkOAuthError.FLOOD_CONTROL -> {
-                State.Error.OAuthError(OAuthErrorDomain.TooManyTriesError)
-            }
-
-            VkOAuthError.NEED_VALIDATION -> {
-                if (response.banInfo != null) {
-                    val info = requireNotNull(response.banInfo)
-
-                    State.Error.OAuthError(
-                        OAuthErrorDomain.UserBannedError(
-                            memberName = info.memberName,
-                            message = info.message,
-                            accessToken = info.accessToken,
-                            restoreUrl = info.restoreUrl
-                        )
-                    )
-                } else {
-                    State.Error.OAuthError(
-                        OAuthErrorDomain.ValidationRequiredError(
-                            description = response.errorDescription.orEmpty(),
-                            validationType = response.validationType.orEmpty()
-                                .let(ValidationType::parse),
-                            validationSid = response.validationSid.orEmpty(),
-                            phoneMask = response.phoneMask.orEmpty(),
-                            redirectUri = response.redirectUri.orEmpty(),
-                            validationResend = response.validationResend,
-                            restoreIfCannotGetCode = response.restoreIfCannotGetCode
+            val newState = when (error) {
+                null -> {
+                    State.Success(
+                        AuthInfo(
+                            userId = response.userId,
+                            accessToken = response.accessToken,
+                            validationHash = response.validationHash
                         )
                     )
                 }
-            }
 
-            VkOAuthError.NEED_CAPTCHA -> {
-                State.Error.OAuthError(
-                    OAuthErrorDomain.CaptchaRequiredError(
-                        captchaSid = response.captchaSid.orEmpty(),
-                        captchaImageUrl = response.captchaImage.orEmpty()
+                VkOAuthError.FLOOD_CONTROL -> {
+                    State.Error.OAuthError(OAuthErrorDomain.TooManyTriesError)
+                }
+
+                VkOAuthError.NEED_VALIDATION -> {
+                    if (response.banInfo != null) {
+                        val info = requireNotNull(response.banInfo)
+
+                        State.Error.OAuthError(
+                            OAuthErrorDomain.UserBannedError(
+                                memberName = info.memberName,
+                                message = info.message,
+                                accessToken = info.accessToken,
+                                restoreUrl = info.restoreUrl
+                            )
+                        )
+                    } else {
+                        State.Error.OAuthError(
+                            OAuthErrorDomain.ValidationRequiredError(
+                                description = response.errorDescription.orEmpty(),
+                                validationType = response.validationType.orEmpty()
+                                    .let(ValidationType::parse),
+                                validationSid = response.validationSid.orEmpty(),
+                                phoneMask = response.phoneMask.orEmpty(),
+                                redirectUri = response.redirectUri.orEmpty(),
+                                validationResend = response.validationResend,
+                                restoreIfCannotGetCode = response.restoreIfCannotGetCode
+                            )
+                        )
+                    }
+                }
+
+                VkOAuthError.NEED_CAPTCHA -> {
+                    State.Error.OAuthError(
+                        OAuthErrorDomain.CaptchaRequiredError(
+                            captchaSid = response.captchaSid.orEmpty(),
+                            captchaImageUrl = response.captchaImage.orEmpty()
+                        )
                     )
-                )
-            }
+                }
 
-            VkOAuthError.INVALID_CLIENT -> {
-                State.Error.OAuthError(OAuthErrorDomain.InvalidCredentialsError)
-            }
+                VkOAuthError.INVALID_CLIENT -> {
+                    State.Error.OAuthError(OAuthErrorDomain.InvalidCredentialsError)
+                }
 
-            VkOAuthError.INVALID_REQUEST -> {
-                when (errorType) {
-                    null -> State.Error.OAuthError(OAuthErrorDomain.UnknownError)
+                VkOAuthError.INVALID_REQUEST -> {
+                    when (errorType) {
+                        null -> State.Error.OAuthError(OAuthErrorDomain.UnknownError)
 
-                    VkOAuthErrorType.WRONG_OTP -> {
-                        State.Error.OAuthError(OAuthErrorDomain.WrongValidationCode)
+                        VkOAuthErrorType.WRONG_OTP -> {
+                            State.Error.OAuthError(OAuthErrorDomain.WrongValidationCode)
+                        }
+
+                        VkOAuthErrorType.WRONG_OTP_FORMAT -> {
+                            State.Error.OAuthError(OAuthErrorDomain.WrongValidationCodeFormat)
+                        }
+
+                        VkOAuthErrorType.PASSWORD_BRUTEFORCE_ATTEMPT -> {
+                            State.Error.OAuthError(OAuthErrorDomain.TooManyTriesError)
+                        }
+
+                        VkOAuthErrorType.USERNAME_OR_PASSWORD_IS_INCORRECT -> {
+                            State.Error.OAuthError(OAuthErrorDomain.InvalidCredentialsError)
+                        }
                     }
+                }
 
-                    VkOAuthErrorType.WRONG_OTP_FORMAT -> {
-                        State.Error.OAuthError(OAuthErrorDomain.WrongValidationCodeFormat)
-                    }
-
-                    VkOAuthErrorType.PASSWORD_BRUTEFORCE_ATTEMPT -> {
-                        State.Error.OAuthError(OAuthErrorDomain.TooManyTriesError)
-                    }
-
-                    VkOAuthErrorType.USERNAME_OR_PASSWORD_IS_INCORRECT -> {
-                        State.Error.OAuthError(OAuthErrorDomain.InvalidCredentialsError)
-                    }
+                VkOAuthError.UNKNOWN -> {
+                    State.Error.OAuthError(OAuthErrorDomain.UnknownError)
                 }
             }
 
-            VkOAuthError.UNKNOWN -> {
-                State.Error.OAuthError(OAuthErrorDomain.UnknownError)
+            emit(newState)
+        }.fold(
+            onSuccess = {
+            },
+            onFailure = {
+                emit(State.Error.TestError(it.stackTraceToString()))
             }
-        }
-
-        emit(newState)
+        )
     }
 }

core/network/src/main/kotlin/dev/meloda/fast/network/ValidationType.kt

@@ -5,6 +5,8 @@ enum class ValidationType(val value: String) {
     SMS("2fa_sms");
 
     companion object {
-        fun parse(value: String): ValidationType = entries.first { it.value == value }
+        fun parse(value: String): ValidationType =
+            entries.firstOrNull { it.value == value }
+                ?: throw IllegalArgumentException("Unknown validation type $value")
     }
 }