auth interceptor added for intercepting all auth requests

danishjamal104 · danishjamal104 · commit 2df3a3dc192b · 2021-06-10T09:24:51.000+05:30
ktlint applied
diff --git a/app/src/main/java/com/github/code/gambit/data/remote/interceptor/ApiGatewayInterceptor.kt b/app/src/main/java/com/github/code/gambit/data/remote/interceptor/ApiGatewayInterceptor.kt
@@ -1,4 +1,4 @@
-package com.github.code.gambit.data.remote
+package com.github.code.gambit.data.remote.interceptor
 
 import com.github.code.gambit.BuildConfig
 import okhttp3.Interceptor
diff --git a/app/src/main/java/com/github/code/gambit/data/remote/interceptor/AuthInterceptor.kt b/app/src/main/java/com/github/code/gambit/data/remote/interceptor/AuthInterceptor.kt
@@ -0,0 +1,35 @@
+package com.github.code.gambit.data.remote.interceptor
+
+import android.content.Context
+import com.amazonaws.services.cognitoidentityprovider.model.NotAuthorizedException
+import com.github.code.gambit.R
+import com.github.code.gambit.helper.ServiceResult
+import com.github.code.gambit.utility.NoInternetException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.lang.Exception
+
+class AuthInterceptor
+constructor(val context: Context) : InternetCheck(context) {
+
+    private suspend fun <T> authRequest(call: suspend () -> T): T {
+        val a = withContext(Dispatchers.IO) { hasActiveInternetConnection() }
+        if (!a) {
+            throw NoInternetException("Not connected to internet")
+        }
+        return call.invoke()
+    }
+
+    suspend fun <T, B> authRequest(call: suspend () -> T, result: (res: T) -> ServiceResult<B>): ServiceResult<B> {
+        return try {
+            val response = authRequest { call.invoke() }
+            result(response)
+        } catch (exception: Exception) {
+            if (exception.cause is NotAuthorizedException) {
+                ServiceResult.Error(Exception(context.getString(R.string.incorrect_username_or_password)))
+            } else {
+                ServiceResult.Error(exception)
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/com/github/code/gambit/data/remote/interceptor/InternetCheck.kt b/app/src/main/java/com/github/code/gambit/data/remote/interceptor/InternetCheck.kt
@@ -1,34 +1,20 @@
-package com.github.code.gambit.data.remote.services
+package com.github.code.gambit.data.remote.interceptor
 
 import android.annotation.SuppressLint
 import android.content.Context
 import android.net.ConnectivityManager
-import com.github.code.gambit.utility.NoInternetException
 import dagger.hilt.android.qualifiers.ApplicationContext
-import okhttp3.Interceptor
-import okhttp3.Response
 import timber.log.Timber
 import java.io.IOException
 import java.net.HttpURLConnection
 import java.net.URL
 
-class NetworkInterceptor
-constructor(@ApplicationContext context: Context) : Interceptor {
-
-    private val applicationContext = context.applicationContext
-
-    override fun intercept(chain: Interceptor.Chain): Response {
-        if (!hasActiveInternetConnection()) {
-            throw NoInternetException("Not connected to internet")
-        }
-        return chain.proceed(chain.request())
-    }
-
+open class InternetCheck(@ApplicationContext val applicationContext: Context) {
     @SuppressLint("ServiceCast")
     private fun isConnected(): Boolean {
         val connectivityManager = applicationContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
-        val network_info = connectivityManager.activeNetwork
-        return network_info != null
+        val networkInfo = connectivityManager.activeNetwork
+        return networkInfo != null
     }
 
     fun hasActiveInternetConnection(): Boolean {
diff --git a/app/src/main/java/com/github/code/gambit/data/remote/interceptor/NetworkInterceptor.kt b/app/src/main/java/com/github/code/gambit/data/remote/interceptor/NetworkInterceptor.kt
@@ -0,0 +1,18 @@
+package com.github.code.gambit.data.remote.interceptor
+
+import android.content.Context
+import com.github.code.gambit.R
+import com.github.code.gambit.utility.NoInternetException
+import okhttp3.Interceptor
+import okhttp3.Response
+
+open class NetworkInterceptor
+constructor(val context: Context) : Interceptor, InternetCheck(context) {
+
+    override fun intercept(chain: Interceptor.Chain): Response {
+        if (!hasActiveInternetConnection()) {
+            throw NoInternetException(context.getString(R.string.no_internet_message))
+        }
+        return chain.proceed(chain.request())
+    }
+}
diff --git a/app/src/main/java/com/github/code/gambit/data/remote/services/auth/AuthServiceImpl.kt b/app/src/main/java/com/github/code/gambit/data/remote/services/auth/AuthServiceImpl.kt
@@ -4,148 +4,151 @@ import com.amplifyframework.auth.AuthException
 import com.amplifyframework.auth.AuthUserAttribute
 import com.amplifyframework.auth.AuthUserAttributeKey
 import com.amplifyframework.auth.cognito.AWSCognitoAuthSession
-import com.amplifyframework.auth.cognito.AWSCognitoUserPoolTokens
 import com.amplifyframework.auth.options.AuthSignUpOptions
 import com.amplifyframework.kotlin.core.Amplify
+import com.github.code.gambit.data.remote.interceptor.AuthInterceptor
 import com.github.code.gambit.helper.ServiceResult
 import com.github.code.gambit.helper.auth.AuthData
 import com.github.code.gambit.utility.extention.defaultBuilder
 
-class AuthServiceImpl : AuthService {
+class AuthServiceImpl(private val authInterceptor: AuthInterceptor) : AuthService {
 
     override suspend fun login(authData: AuthData): ServiceResult<Unit> {
-        return try {
-            val result = Amplify.Auth.signIn(authData.email, authData.password)
+        return authInterceptor.authRequest({
+            Amplify.Auth.signIn(
+                authData.email,
+                authData.password
+            )
+        }) { result ->
             if (result.isSignInComplete) {
                 ServiceResult.Success(Unit)
             } else {
                 ServiceResult.Error(Exception("Login incomplete + ${result.nextStep}"))
             }
-        } catch (e: AuthException) {
-            ServiceResult.Error(e)
         }
     }
 
     override suspend fun signUp(authData: AuthData): ServiceResult<Unit> {
-        val options = AuthSignUpOptions.builder().defaultBuilder(authData)
-        return try {
-            val result = Amplify.Auth.signUp(authData.email, authData.password, options)
+        return authInterceptor.authRequest({
+            val options = AuthSignUpOptions.builder().defaultBuilder(authData)
+            Amplify.Auth.signUp(authData.email, authData.password, options)
+        }) { result ->
             if (result.isSignUpComplete) {
                 ServiceResult.Success(Unit)
             } else {
                 ServiceResult.Error(Exception("SignUp incomplete + ${result.nextStep}"))
             }
-        } catch (e: AuthException) {
-            ServiceResult.Error(e)
         }
     }
 
     override suspend fun logOut(): ServiceResult<Unit> {
-        return try {
-            Amplify.Auth.signOut()
-            ServiceResult.Success(Unit)
-        } catch (e: AuthException) {
-            ServiceResult.Error(e)
-        }
+        return authInterceptor.authRequest({ Amplify.Auth.signOut() }) { ServiceResult.Success(Unit) }
     }
 
-    override suspend fun resetPassword(oldPassword: String, newPassword: String): ServiceResult<Unit> {
-        return try {
-            val result = Amplify.Auth.updatePassword(oldPassword, newPassword)
-            ServiceResult.Success(result)
-        } catch (e: java.lang.Exception) {
-            ServiceResult.Error(e)
+    override suspend fun resetPassword(
+        oldPassword: String,
+        newPassword: String
+    ): ServiceResult<Unit> {
+        return authInterceptor.authRequest({
+            Amplify.Auth.updatePassword(
+                oldPassword,
+                newPassword
+            )
+        }) {
+            ServiceResult.Success(it)
         }
     }
 
     override suspend fun forgotPassword(userEmail: String): ServiceResult<Unit> {
-        return try {
-            Amplify.Auth.resetPassword(userEmail)
+        return authInterceptor.authRequest({ Amplify.Auth.resetPassword(userEmail) }) {
             ServiceResult.Success(Unit)
-        } catch (e: java.lang.Exception) {
-            ServiceResult.Error(e)
         }
     }
 
     override suspend fun changePassword(
         newPassword: String,
         confirmationCode: String
     ): ServiceResult<Unit> {
-        return try {
-            Amplify.Auth.confirmResetPassword(newPassword, confirmationCode)
+        return authInterceptor.authRequest({
+            Amplify.Auth.confirmResetPassword(
+                newPassword,
+                confirmationCode
+            )
+        }) {
             ServiceResult.Success(Unit)
-        } catch (e: java.lang.Exception) {
-            ServiceResult.Error(e)
         }
     }
 
     override suspend fun updateUserName(fullName: String): ServiceResult<String> {
-        return try {
+        return authInterceptor.authRequest({
             val attribute = AuthUserAttribute(AuthUserAttributeKey.name(), fullName)
-            val result = Amplify.Auth.updateUserAttribute(attribute)
+            Amplify.Auth.updateUserAttribute(attribute)
+        }) { result ->
             if (result.isUpdated) {
                 ServiceResult.Success(fullName)
             } else {
-                ServiceResult.Error(AuthException("User name update failed", "Switch you internet connection"))
+                ServiceResult.Error(
+                    AuthException(
+                        "User name update failed",
+                        "Switch your internet connection"
+                    )
+                )
             }
-        } catch (e: java.lang.Exception) {
-            ServiceResult.Error(e)
         }
     }
 
     override suspend fun confirmSignUp(authData: AuthData): ServiceResult<Unit> {
-        return try {
-            val result = Amplify.Auth.confirmSignUp(authData.email, authData.confirmationCode!!)
+        return authInterceptor.authRequest({
+            Amplify.Auth.confirmSignUp(
+                authData.email,
+                authData.confirmationCode!!
+            )
+        }) { result ->
             if (result.isSignUpComplete) {
                 ServiceResult.Success(Unit)
             } else {
                 ServiceResult.Error(Exception("Confirmation incomplete + ${result.nextStep}"))
             }
-        } catch (e: AuthException) {
-            ServiceResult.Error(e)
         }
     }
 
     override suspend fun fetchSession(): ServiceResult<AWSCognitoAuthSession> {
-        return try {
-            val authSession = Amplify.Auth.fetchAuthSession() as AWSCognitoAuthSession
-            ServiceResult.Success(authSession)
-        } catch (e: AuthException) {
-            ServiceResult.Error(e)
+        return authInterceptor.authRequest({ Amplify.Auth.fetchAuthSession() as AWSCognitoAuthSession }) {
+            ServiceResult.Success(
+                it
+            )
         }
     }
 
     override suspend fun fetchIdToken(): ServiceResult<String> {
-        when (val session = fetchSession()) {
-            is ServiceResult.Error -> {
-                return ServiceResult.Error(session.exception)
-            }
-            is ServiceResult.Success<AWSCognitoAuthSession> -> {
-                val tokens: AWSCognitoUserPoolTokens = session.data.userPoolTokens.value
-                    ?: return ServiceResult.Error(Exception("token not generated, user might be not authentication"))
-                return ServiceResult.Success(tokens.idToken)
-            }
-            else -> {
-                return ServiceResult.Error(Exception("Illegal state!!"))
+        return authInterceptor.authRequest({ fetchSession() }) { session ->
+            when (session) {
+                is ServiceResult.Error -> {
+                    ServiceResult.Error(session.exception)
+                }
+                is ServiceResult.Success<AWSCognitoAuthSession> -> {
+                    session.data.userPoolTokens.value?.let {
+                        ServiceResult.Success(it.idToken)
+                    }
+                        ?: ServiceResult.Error(Exception("token not generated, user might be not authentication"))
+                }
             }
         }
     }
 
     override suspend fun fetchUserAttribute(): ServiceResult<List<AuthUserAttribute>> {
-        return try {
-            val attributes = Amplify.Auth.fetchUserAttributes()
-            ServiceResult.Success(attributes)
-        } catch (e: AuthException) {
-            ServiceResult.Error(e)
+        return authInterceptor.authRequest({ Amplify.Auth.fetchUserAttributes() }) {
+            ServiceResult.Success(
+                it
+            )
         }
     }
 
     override suspend fun resentConfirmationCode(email: String): ServiceResult<Unit> {
-        return try {
-            Amplify.Auth.resendSignUpCode(email)
-            ServiceResult.Success(Unit)
-        } catch (e: AuthException) {
-            ServiceResult.Error(e)
+        return authInterceptor.authRequest({ Amplify.Auth.resendSignUpCode(email) }) {
+            ServiceResult.Success(
+                Unit
+            )
         }
     }
 }
diff --git a/app/src/main/java/com/github/code/gambit/di/NetworkModule.kt b/app/src/main/java/com/github/code/gambit/di/NetworkModule.kt
@@ -5,11 +5,12 @@ import com.chuckerteam.chucker.api.ChuckerInterceptor
 import com.github.code.gambit.data.mapper.network.FileNetworkMapper
 import com.github.code.gambit.data.mapper.network.UrlNetworkMapper
 import com.github.code.gambit.data.mapper.network.UserNetworkMapper
-import com.github.code.gambit.data.remote.ApiGatewayInterceptor
 import com.github.code.gambit.data.remote.NetworkDataSource
 import com.github.code.gambit.data.remote.NetworkDataSourceImpl
+import com.github.code.gambit.data.remote.interceptor.ApiGatewayInterceptor
+import com.github.code.gambit.data.remote.interceptor.AuthInterceptor
+import com.github.code.gambit.data.remote.interceptor.NetworkInterceptor
 import com.github.code.gambit.data.remote.services.ApiService
-import com.github.code.gambit.data.remote.services.NetworkInterceptor
 import com.github.code.gambit.data.remote.services.auth.AuthService
 import com.github.code.gambit.data.remote.services.auth.AuthServiceImpl
 import com.github.code.gambit.data.remote.services.file.FileService
@@ -61,6 +62,14 @@ object NetworkModule {
         return ChuckerInterceptor(context)
     }
 
+    @Singleton
+    @Provides
+    fun provideAuthInterceptor(
+        @ApplicationContext context: Context
+    ): AuthInterceptor {
+        return AuthInterceptor(context)
+    }
+
     @Singleton
     @Provides
     fun provideOkHttpClient(
@@ -108,8 +117,8 @@ object NetworkModule {
 
     @Singleton
     @Provides
-    fun provideAuthService(): AuthService {
-        return AuthServiceImpl()
+    fun provideAuthService(authInterceptor: AuthInterceptor): AuthService {
+        return AuthServiceImpl(authInterceptor)
     }
 
     @Singleton
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
@@ -80,4 +80,6 @@
     <string name="between">between</string>
     <string name="space">&#160;</string>
     <string name="resend">Resend</string>
+    <string name="no_internet_message">Not connected to internet</string>
+    <string name="incorrect_username_or_password">Incorrect Username or Password</string>
 </resources>

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-package com.github.code.gambit.data.remote`
	`1`	`+package com.github.code.gambit.data.remote.interceptor`
`2`	`2`
`3`	`3`	`import com.github.code.gambit.BuildConfig`
`4`	`4`	`import okhttp3.Interceptor`