Merge branch 'feature/hse-auth-engine' into 'develop'

Feature/hse auth engine

See merge request 19111/androidodoo!27

Author: Ворожцов Михаил Александрович

common/network/authorization/api/src/main/kotlin/odoo/miem/android/common/network/authorization/api/IAuthorizationInteractor.kt

@@ -19,5 +19,5 @@ interface IAuthorizationInteractor {
      *
      * @return Observable<Result> which we can observer and get Success or Error result
      */
-    fun generalAuthorization(baseUrl: String, login: String, password: String): ResultSingle<Int>
+    fun generalAuthorization(baseUrl: String, login: String, password: String): ResultSingle<Unit>
 }

common/network/authorization/impl/src/main/kotlin/odoo/miem/android/common/network/authorization/impl/AuthorizationInteractor.kt

@@ -4,6 +4,8 @@ import odoo.miem.android.common.network.authorization.api.IAuthorizationInteract
 import odoo.miem.android.common.network.authorization.api.di.IAuthorizationRepositoryApi
 import odoo.miem.android.core.dataStore.api.di.IDataStoreApi
 import odoo.miem.android.core.di.impl.api
+import odoo.miem.android.core.utils.builder.urlProcessing
+import odoo.miem.android.core.utils.regex.getSessionIdFromCookie
 import odoo.miem.android.core.utils.state.ErrorResult
 import odoo.miem.android.core.utils.state.Result
 import odoo.miem.android.core.utils.state.ResultSingle
@@ -25,45 +27,36 @@ class AuthorizationInteractor @Inject constructor() : IAuthorizationInteractor {
         baseUrl: String,
         login: String,
         password: String
-    ): ResultSingle<Int> {
+    ): ResultSingle<Unit> {
         Timber.d("generalAuthorization(): baseUrl = $baseUrl, login = $login, password = $password")
 
-        dataStore.setHseAuthorized(false)
         dataStore.setUrl(proceedUrl(baseUrl))
 
         return authorizationRepository.generalAuthorization(
             login = login,
             password = password
         )
-            .map<Result<Int>> {
-                Timber.d("generalAuthorization(): uid = $it")
-                dataStore.setUID(it)
-                SuccessResult(data = it)
+            .map<Result<Unit>> { cookie ->
+                Timber.d("generalAuthorization(): sessionId = $cookie")
+                dataStore.setAuthorized(true)
+                dataStore.setSessionId(
+                    cookie.split(COOKIE_SPLIT_SIGN)
+                        .find { it.contains(FIELD_SESSION_ID) }
+                        .orEmpty()
+                        .getSessionIdFromCookie()
+                )
+                SuccessResult()
             }
             .onErrorReturn {
                 Timber.e("generalAuthorization(): error message = ${it.message}")
                 ErrorResult(R.string.general_authorization_error)
             }
     }
 
-    private fun proceedUrl(inputUrl: String): String {
-        var proceededUrl = if (!inputUrl.run { startsWith("https://") || startsWith("http://") }) {
-            "https://"
-        } else {
-            ""
-        } + inputUrl.trim()
+    private fun proceedUrl(inputUrl: String): String = "${urlProcessing(inputUrl)}web/"
 
-        if (!inputUrl.endsWith("/")) {
-            proceededUrl += "/"
-        }
-
-        return proceededUrl + urlSuffix
+    private companion object {
+        const val COOKIE_SPLIT_SIGN = ";"
+        const val FIELD_SESSION_ID = "session_id"
     }
-
-    private val urlSuffix: String
-        get() = if (dataStore.isHseAuthorized) {
-            "web/datastore/"
-        } else {
-            "jsonrpc/"
-        }
 }

common/uiKitComponents/src/main/kotlin/odoo/miem/android/common/uiKitComponents/textfields/BaseTextField.kt

@@ -35,6 +35,7 @@ fun BaseTextField(
     keyboardType: KeyboardType = KeyboardType.Text,
     @StringRes labelResource: Int,
     leadingIcon: @Composable (() -> Unit)? = null,
+    placeholder: @Composable (() -> Unit)? = null,
     modifier: Modifier = Modifier,
     enabled: Boolean = true,
     onValueChange: (TextFieldValue) -> Unit = {},
@@ -52,6 +53,7 @@ fun BaseTextField(
         enabled = enabled,
         singleLine = true,
         label = { Text(text = stringResource(labelResource), style = MaterialTheme.typography.bodyMedium) },
+        placeholder = placeholder,
         visualTransformation = visualTransformation,
         keyboardOptions = KeyboardOptions(keyboardType = keyboardType, imeAction = imeAction),
         keyboardActions = KeyboardActions(onDone = { focusManager.clearFocus() }),

common/uiKitComponents/src/main/kotlin/odoo/miem/android/common/uiKitComponents/textfields/LoginTextField.kt

@@ -41,6 +41,7 @@ fun LoginTextField(
     visualTransformation: VisualTransformation = VisualTransformation.None,
     imeAction: ImeAction = ImeAction.Done,
     isError: Boolean = false,
+    placeholder: @Composable (() -> Unit)? = null,
     modifier: Modifier = Modifier
 ) {
     var isPasswordVisible by remember { mutableStateOf(false) }
@@ -84,6 +85,7 @@ fun LoginTextField(
         trailingIcon = trailingIcon,
         imeAction = imeAction,
         isError = isError,
+        placeholder = placeholder,
         modifier = modifier
     )
 }

core/dataStore/api/src/main/kotlin/odoo/miem/android/core/dataStore/api/IDataStore.kt

@@ -20,6 +20,9 @@ interface IDataStore {
     val currentUID: Int
     fun setUID(uid: Int)
 
-    val isHseAuthorized: Boolean
-    fun setHseAuthorized(authorized: Boolean)
+    val isAuthorized: Boolean
+    fun setAuthorized(authorized: Boolean)
+
+    val sessionId: String
+    fun setSessionId(newSessionId: String)
 }

core/dataStore/impl/src/main/kotlin/odoo/miem/android/core/dataStore/impl/DataStore.kt

@@ -45,16 +45,26 @@ class DataStore @Inject constructor() : IDataStore {
         }
     }
 
-    override val isHseAuthorized by sharedPreferences.delegates.boolean()
-    override fun setHseAuthorized(authorized: Boolean) {
-        if (authorized != isHseAuthorized) {
+    override val isAuthorized by sharedPreferences.delegates.boolean()
+    override fun setAuthorized(authorized: Boolean) {
+        if (authorized != isAuthorized) {
             sharedPreferences.edit {
-                putBoolean(::isHseAuthorized.name, authorized)
+                putBoolean(::isAuthorized.name, authorized)
             }
             Timber.d("setHseAuthorized(): authorized = $authorized")
         }
     }
 
+    override val sessionId by sharedPreferences.delegates.string()
+    override fun setSessionId(newSessionId: String) {
+        if (newSessionId != sessionId) {
+            sharedPreferences.edit {
+                putString(::sessionId.name, newSessionId)
+            }
+            Timber.d("setSessionId(): sessionId = $newSessionId")
+        }
+    }
+
     private companion object {
         const val PREFERENCES_NAME = "dataStore"
     }

core/jsonrpc/README.md

@@ -0,0 +1,106 @@
+# Json Rpc
+
+## Description
+This module is a Retrofit implementation of a similar add-on on Okhttp. It consists of 4 submodules:
+- [base](core/jsonrpc/base) - contains protocols, base interfaces for implementation and errors
+- [core](core/jsonrpc/core) - special module, for external consumers, so **if you want to use this library, just include it**
+- [engine](core/jsonrpc/engine) - main module of library, which contain all implementations of [base](core/jsonrpc/base)
+- [parser](core/jsonrpc/parser) - module, which contains parser for request and response result
+
+## Details about creating request
+So, in the basic scenario, you will need to create the following request body:
+```
+{
+  'jsonrpc': '2.0',
+  'id': 1,
+  'method': 'your_method',
+  'params': {
+    'model': 'your_model',
+    'method': 'your_model_method',
+    'args': [
+      [('filter', '=', 'your_filter')],
+      ['your_args']
+    ],
+    'kwargs': {
+      'your_kwargs_key' : 'your_kwargs_value'
+    }
+  }
+}
+```
+
+Let's go by step:
+- `jsonrpc` - will always (99%) `2.0`, that is why this value is default
+- `id` - this value will generate engine, therefore you do not need to set it
+- `method` - method of execution (default value is `call`)
+- `params` - parameters by which the request will be executed:
+  - `model` - the model you are referring to (for example, `res.partner`)
+  - `method` - method **IN MODEL** (for example, `search_read`)
+  - `args` - additional arguments for filtering out your request. For example, if you want to have a results only with filed `active=true` 
+  and view only `id`, your args should be:
+  ```
+  'args': [
+      [('active', '=', 'true')],
+      ['id']
+    ],
+  ```
+  - `kwargs` - addition keyword arguments. For example, if you want to see only first 5 records:
+  ```
+  'kwargs': {
+      'limit' : 5
+  }
+  ```
+  
+## Example
+Let's try to create such response body with a help of library:
+```
+{
+  'jsonrpc': '2.0',
+  'id': 1,
+  'method': 'call',
+  'params': {
+    'model': 'ir.ui.menu',
+    'method': 'search_read',
+    'args': [
+      [('active', '=', 'true')],
+      ['id'],
+    ],
+    'kwargs': {},
+  }
+}
+```
+
+Firstly, we need to create *IMenusRepository* by url `https://odoo.miem.tv/web/dataset/`:
+```kotlin
+interface IMenusRepository {
+    
+    @JsonRpc("call")
+    fun getMenus(
+      @JsonRpcPath path: String = "web/dataset",
+      @JsonRpcArgument("model") model: String = "ir.ui.menu",
+      @JsonRpcArgument("method") modelMethod: String = "search_read",
+      @JsonRpcArgument("args") args: List<Any> = listOf(
+        listOf<String>("active", "=", "true"),
+        listOf<String>("id")
+      ),
+      @JsonRpcArgument("kwargs") kwargs: Map<String, Any> = emptyMap()
+    )
+}
+```
+
+Secondly, just create instance of this interface, using [JsonRpcClient](core/jsonrpc/core/src/main/kotlin/odoo/miem/android/core/jsonrpc/core/JsonRpcClient.kt):
+```kotlin
+val jsonRpcClient = JsonRpcClient.Builder()
+            .baseUrl("https://odoo.miem.tv/")
+            .build()
+
+val menuRepository = jsonRpcClient.create(IMenusRepository::class.java)
+// or it is also possible like that: val menuInterface by jsonRpcClient.create<IMenusRepository::class.java>()
+```
+
+And finally, call method (it is network call, so you asynchronous tools, like coroutines or rxjava):
+```kotlin
+val menus = menuRepository.getMenus()
+```
+
+## Alertness
+Without any doubt this type of json body can change to suit your needs as you like

core/jsonrpc/base/src/main/kotlin/odoo/miem/android/core/jsonrpc/base/engine/JsonRpcCaller.kt

@@ -2,6 +2,7 @@ package odoo.miem.android.core.jsonrpc.base.engine
 
 import odoo.miem.android.core.jsonrpc.base.engine.protocol.JsonRpcRequest
 import odoo.miem.android.core.jsonrpc.base.engine.protocol.JsonRpcResponse
+import okhttp3.Response
 
 /**
  * [JsonRpcCaller] is a client, with a help of which
@@ -29,6 +30,7 @@ interface JsonRpcCaller {
     fun call(
         jsonRpcRequest: JsonRpcRequest,
         headers: Map<String, String> = emptyMap(),
-        paths: List<String> = emptyList()
+        paths: List<String> = emptyList(),
+        onResponseProceed: ((id: Long, Response) -> JsonRpcResponse)? = null
     ): JsonRpcResponse
 }

core/jsonrpc/base/src/main/kotlin/odoo/miem/android/core/jsonrpc/base/engine/annotation/JsonRpc.kt

@@ -17,16 +17,12 @@ package odoo.miem.android.core.jsonrpc.base.engine.annotation
  * { "id": 1, "method": "call", .... }
  * ```
  *
- * ATTENTION
- * Depending on the type of authorization (hse or general, for example),
- * this method will be in body of `params` map or like in example above
- *
  * @author Vorozhtsov Mikhail
  */
 annotation class JsonRpc(val value: String)
 
 /**
- * [JsonArgument] is annotation, which provide parameters
+ * [JsonRpcArgument] is annotation, which provide parameters
  * in `params` field of json body.
  *
  * @param value contains name of field
@@ -35,7 +31,7 @@ annotation class JsonRpc(val value: String)
  * ```
  * @JsonRpc("call")
  * fun getCoolUser(
- *      @JsonArgument("name") name: String = "Mike"
+ *      @JsonRpcArgument("name") name: String = "Mike"
  * ): User
  * ```
  *
@@ -46,4 +42,36 @@ annotation class JsonRpc(val value: String)
  *
  * @author Vorozhtsov Mikhail
  */
-annotation class JsonArgument(val value: String)
+annotation class JsonRpcArgument(val value: String)
+
+/**
+ * [JsonRpcPath] is annotation, which provide path in request url
+ *
+ *
+ * For example:
+ * ```
+ * val baseUrl = "https://odoo.com/"
+ *
+ * @JsonRpc("call")
+ * fun getCoolUser(
+ *      @JsonRpcPath path: String = "web"
+ *      @JsonRpcPath path: String = "dataset"
+ * ): User
+ * ```
+ *
+ * So, in example above final url will be:
+ * ```
+ * https://odoo.com/web/dataset/
+ * ```
+ *
+ * It is also possible make path, and we will have same result url:
+ * ```
+ * @JsonRpc("call")
+ * fun getCoolUser(
+ *      @JsonRpcPath path: String = "web/dataset"
+ * ): User
+ * ```
+ *
+ * @author Vorozhtsov Mikhail
+ */
+annotation class JsonRpcPath