[HTTP] Call controller actions using URL from _publicApi instead of _query endpoint

src/main/kotlin/io/kuzzle/sdk/Kuzzle.kt

@@ -90,6 +90,7 @@ open class Kuzzle {
         }
 
         queries[requestId]?.completeExceptionally(ApiErrorException(response))
+        queries.remove(requestId)
         protocol.trigger(TokenExpiredEvent())
     }
 

src/main/kotlin/io/kuzzle/sdk/controllers/AuthController.kt

@@ -6,6 +6,7 @@ import io.kuzzle.sdk.coreClasses.lang.Lang
 import io.kuzzle.sdk.coreClasses.maps.KuzzleMap
 import io.kuzzle.sdk.coreClasses.responses.Response
 import io.kuzzle.sdk.events.LoginAttemptEvent
+import io.kuzzle.sdk.events.LogoutAttemptEvent
 import java.util.concurrent.CompletableFuture
 
 class AuthController(kuzzle: Kuzzle) : BaseController(kuzzle) {
@@ -164,7 +165,10 @@ class AuthController(kuzzle: Kuzzle) : BaseController(kuzzle) {
             put("controller", "auth")
             put("action", "logout")
         }
-        return kuzzle.query(query)
+        return kuzzle.query(query).thenApplyAsync { response ->
+            kuzzle.protocol.trigger(LogoutAttemptEvent())
+            response
+        }
     }
 
     @JvmOverloads

src/main/kotlin/io/kuzzle/sdk/coreClasses/exceptions/ApiErrorException.kt

@@ -30,8 +30,8 @@ class ApiErrorException : KuzzleException {
     constructor(response: Response) :
         super(response.error?.message, response.status) {
             if (response.error != null) {
-                this.stack = response.error?.stack
-                this.id = response.error?.id
+                this.stack = response.error!!.stack
+                this.id = response.error!!.id
             }
         }
 }

src/main/kotlin/io/kuzzle/sdk/coreClasses/exceptions/KuzzleExceptionCode.kt

@@ -1,7 +1,13 @@
 package io.kuzzle.sdk.coreClasses.exceptions
 
 enum class KuzzleExceptionCode {
-    MISSING_REQUESTID(0, "Missing field requestId"), MISSING_QUERY(400, "You must provide a query"), NOT_CONNECTED(500, "Not connected."), CONNECTION_LOST(500, "Connection lost"), WRONG_VOLATILE_TYPE(
+    MISSING_REQUESTID(0, "Missing field requestId"),
+    MISSING_CONTROLLER(0, "Missing field controller"),
+    MISSING_ACTION(0, "Missing field action"),
+    MISSING_QUERY(400, "You must provide a query"),
+    NOT_CONNECTED(500, "Not connected."),
+    CONNECTION_LOST(500, "Connection lost"),
+    WRONG_VOLATILE_TYPE(
         400,
         "Volatile data must be a Map<String, Object>"
     );

src/main/kotlin/io/kuzzle/sdk/coreClasses/exceptions/MissingActionException.kt

@@ -0,0 +1,5 @@
+package io.kuzzle.sdk.coreClasses.exceptions
+
+open class MissingActionException : KuzzleException {
+    constructor() : super(KuzzleExceptionCode.MISSING_ACTION)
+}

src/main/kotlin/io/kuzzle/sdk/coreClasses/exceptions/MissingControllerException.kt

@@ -0,0 +1,5 @@
+package io.kuzzle.sdk.coreClasses.exceptions
+
+open class MissingControllerException : KuzzleException {
+    constructor() : super(KuzzleExceptionCode.MISSING_CONTROLLER)
+}

src/main/kotlin/io/kuzzle/sdk/coreClasses/exceptions/MissingURLParamException.kt

@@ -0,0 +1,8 @@
+package io.kuzzle.sdk.coreClasses.exceptions
+
+/**
+ * Thrown when attempting to interact with the network while not connected.
+ */
+class MissingURLParamException : KuzzleException {
+    constructor(templateParam: String, baseURL: String) : super("Missing URL Param $templateParam in $baseURL", 0)
+}

src/main/kotlin/io/kuzzle/sdk/coreClasses/exceptions/URLNotFoundException.kt

@@ -0,0 +1,5 @@
+package io.kuzzle.sdk.coreClasses.exceptions
+
+class URLNotFoundException : KuzzleException {
+    constructor(controller: String, action: String) : super("No URL found for \"$controller:$action\".", 400)
+}

src/main/kotlin/io/kuzzle/sdk/coreClasses/http/HttpRequest.kt

@@ -0,0 +1,10 @@
+package io.kuzzle.sdk.coreClasses.http
+
+import io.kuzzle.sdk.coreClasses.maps.KuzzleMap
+
+data class HttpRequest(
+    val verb: String,
+    val url: String,
+    val body: KuzzleMap,
+    val headers: KuzzleMap,
+)

src/main/kotlin/io/kuzzle/sdk/coreClasses/http/Route.kt

@@ -0,0 +1,178 @@
+package io.kuzzle.sdk.coreClasses.http
+
+import io.kuzzle.sdk.coreClasses.exceptions.MissingURLParamException
+import io.kuzzle.sdk.coreClasses.json.JsonSerializer
+import io.kuzzle.sdk.coreClasses.maps.KuzzleMap
+import java.net.URLEncoder
+
+enum class PartType {
+    STATIC,
+    TEMPLATE
+}
+
+private class RoutePart {
+    val type: PartType
+    val value: String
+
+    constructor(type: PartType, value: String) {
+        this.type = type
+        this.value = value
+    }
+}
+
+val PayloadProperties = setOf<String>(
+    "controller",
+    "action",
+    "meta",
+    "volatile",
+)
+
+class Route {
+    private val partType: PartType
+    private val routeParts: ArrayList<RoutePart>
+    private var staticURL: String = ""
+    private var baseURL: String
+    private var verb: String
+
+    private constructor(verb: String, baseUrl: String, routeParts: ArrayList<RoutePart>) {
+        this.verb = verb.uppercase()
+        this.baseURL = baseUrl
+        this.routeParts = routeParts
+        val hasOnePartTemplated = routeParts.indexOfFirst { it.type == PartType.TEMPLATE } > -1
+        this.partType = if (hasOnePartTemplated) PartType.TEMPLATE else PartType.STATIC
+        if (! hasOnePartTemplated) {
+            staticURL = routeParts.joinToString("") {
+                it.value
+            }
+        }
+    }
+
+    /**
+     * Given map containing the properties of the request, the buildRequest method
+     * will create an instance of HttpRequest which contains the information needed to make
+     * the request later on.
+     *
+     * The method has to:
+     * - Generate the URL using the properties of the request if there are part of the URL that are templated
+     * - Generate the query string
+     * - Generate the list of headers
+     */
+    fun buildRequest(request: KuzzleMap): HttpRequest {
+        val headers = request.optMap("headers", KuzzleMap())
+
+        val queryArgs = KuzzleMap()
+        for (key: String? in request.keys) {
+            // Skip if a key or value is null
+            if (key == null || request[key] == null) {
+                continue
+            }
+
+            when (key) {
+                "jwt" -> headers["authorization"] = "Bearer ${request["jwt"]}"
+                "volatile" -> {
+                    headers["x-kuzzle-volatile"] = request["volatile"]
+                }
+                "headers" -> headers.putAll(request.optMap("headers", KuzzleMap()))
+                "body" -> {
+                    if (verb == "GET") {
+                        queryArgs.putAll(request.optMap("body", KuzzleMap()))
+                    }
+                }
+                else -> {
+                    if (! PayloadProperties.contains(key)) {
+                        queryArgs[key] = request[key]
+                    }
+                }
+            }
+        }
+
+        /**
+         * Build the query string
+         */
+        val queryString: String = queryArgs.keys.filterNotNull().joinToString("&") {
+            val encodedKey = URLEncoder.encode(it, "utf-8")
+
+            if (queryArgs.isArrayList(it)) {
+                val value = queryArgs.getArrayList(it)!!.joinToString(",")
+                "$encodedKey=${URLEncoder.encode(value, "utf-8")}"
+            } else if (queryArgs.optBoolean(it, false) == true) {
+                encodedKey
+            } else {
+                val value = if (queryArgs.isMap(it)) JsonSerializer.serialize(queryArgs.getMap(it)!!) else queryArgs[it].toString()
+                "$encodedKey=${URLEncoder.encode(value, "utf-8")}"
+            }
+        }
+
+        /**
+         * If the partType is STATIC it means that there is no template in the url
+         * So we can use the staticURL instead of building the URL
+         */
+        if (partType == PartType.STATIC) {
+            return HttpRequest(
+                verb,
+                if (queryArgs.isEmpty()) staticURL else "$staticURL?$queryString",
+                request.optMap("body", KuzzleMap()),
+                headers
+            )
+        }
+
+        /**
+         * Each STATIC part will be appended to the string builder without further processing,
+         * TEMPLATE parts however will be used to find their corresponding value in the request map
+         * and the retrieve value will be put in the URL
+         */
+        val urlBuilder = StringBuilder()
+        for (routePart: RoutePart in routeParts) {
+            if (routePart.type == PartType.STATIC) {
+                urlBuilder.append(routePart.value)
+            } else {
+                if (! request.containsKey(routePart.value) || request[routePart.value] == null) {
+                    throw MissingURLParamException(routePart.value, baseURL)
+                }
+                val serializedValue = request[routePart.value]!!.toString()
+                urlBuilder.append(URLEncoder.encode(serializedValue, "utf-8"))
+            }
+        }
+        return HttpRequest(
+            verb,
+            if (queryArgs.isEmpty()) urlBuilder.toString() else "$urlBuilder?$queryString",
+            request.optMap("body", KuzzleMap()),
+            headers
+        )
+    }
+
+    companion object {
+        /**
+         * Parse Kuzzle url with the format /:index/:collection
+         * Split each section of the url and tag them either as STATIC or TEMPLATE
+         * Static parts are static as the name suggest, they can be combined without further processing
+         * Template parts however need to be replaced with the appropriate value
+         * Each sections starting with : is considered to be a template part
+         */
+        fun parse(verb: String, url: String): Route {
+            val routeParts = ArrayList<RoutePart>()
+
+            // Sanitize path in case of double /
+            val parts = url.split('/').filter { it.isNotEmpty() }
+
+            routeParts.add(RoutePart(PartType.STATIC, "/"))
+
+            for (part: String in parts) {
+                if (part.startsWith(":")) {
+                    routeParts.add(RoutePart(PartType.TEMPLATE, part.substring(1)))
+                } else {
+                    routeParts.add(RoutePart(PartType.STATIC, part))
+                }
+                // Add static / to separate each parts
+                routeParts.add(RoutePart(PartType.STATIC, "/"))
+            }
+
+            // Remove trailing / if there was none in the url
+            if (! url.endsWith("/")) {
+                routeParts.removeLast()
+            }
+
+            return Route(verb, url, routeParts)
+        }
+    }
+}

src/main/kotlin/io/kuzzle/sdk/coreClasses/serializer/StringSerializer.kt

@@ -0,0 +1,15 @@
+package io.kuzzle.sdk.coreClasses.serializer
+
+import io.kuzzle.sdk.coreClasses.json.JsonSerializer
+
+object StringSerializer {
+    fun serialize(obj: Any): String {
+        if (obj == null) {
+            return ""
+        }
+        if (obj is Map<*, *> || obj is List<*>) {
+            return JsonSerializer.serialize(obj)
+        }
+        return obj.toString()
+    }
+}

src/main/kotlin/io/kuzzle/sdk/events/LogoutAttemptEvent.kt

@@ -0,0 +1,3 @@
+package io.kuzzle.sdk.events
+
+class LogoutAttemptEvent