Merge pull request #744 from CesiumGS/extract-uri-value

Extract Value From URI

Author: kring

CesiumIonClient/include/CesiumIonClient/Connection.h

@@ -105,6 +105,11 @@ class CESIUMASYNC_API Connection {
       const std::string& ionApiUrl = "https://api.cesium.com/",
       const std::string& ionAuthorizeUrl = "https://ion.cesium.com/oauth");
 
+  static CesiumAsync::Future<std::optional<std::string>> getApiUrl(
+      const CesiumAsync::AsyncSystem& asyncSystem,
+      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
+      const std::string& ionUrl);
+
   /**
    * @brief Creates a connection to Cesium ion using the provided access token.
    *

CesiumIonClient/src/Connection.cpp

@@ -15,6 +15,7 @@
 #include <rapidjson/error/en.h>
 #include <rapidjson/stringbuffer.h>
 #include <rapidjson/writer.h>
+#include <uriparser/Uri.h>
 
 #include <thread>
 
@@ -134,7 +135,7 @@ std::string createAuthorizationErrorHtml(
   authorizeUrl =
       Uri::addQuery(authorizeUrl, "client_id", std::to_string(clientID));
   authorizeUrl =
-      Uri::addQuery(authorizeUrl, "scope", joinToString(scopes, " "));
+      Uri::addQuery(authorizeUrl, "scope", joinToString(scopes, "%20"));
   authorizeUrl = Uri::addQuery(authorizeUrl, "redirect_uri", redirectUrl);
   authorizeUrl = Uri::addQuery(authorizeUrl, "state", state);
   authorizeUrl = Uri::addQuery(authorizeUrl, "code_challenge_method", "S256");
@@ -373,6 +374,51 @@ Asset jsonToAsset(const rapidjson::Value& item) {
 
 } // namespace
 
+CesiumAsync::Future<std::optional<std::string>>
+CesiumIonClient::Connection::getApiUrl(
+    const CesiumAsync::AsyncSystem& asyncSystem,
+    const std::shared_ptr<IAssetAccessor>& pAssetAccessor,
+    const std::string& ionUrl) {
+  std::string configUrl = Uri::resolve(ionUrl, "config.json");
+  if (configUrl == "config.json") {
+    return asyncSystem.createResolvedFuture<std::optional<std::string>>(
+        std::nullopt);
+  }
+  return pAssetAccessor->get(asyncSystem, configUrl)
+      .thenImmediately([ionUrl](std::shared_ptr<IAssetRequest>&& pRequest) {
+        const IAssetResponse* pResponse = pRequest->response();
+        if (pResponse && pResponse->statusCode() >= 200 &&
+            pResponse->statusCode() < 300) {
+          rapidjson::Document d;
+          if (parseJsonObject(pResponse, d) && d.IsObject()) {
+            const auto itr = d.FindMember("apiHostname");
+            if (itr != d.MemberEnd() && itr->value.IsString()) {
+              return std::make_optional<std::string>(itr->value.GetString());
+            }
+          }
+        }
+
+        UriUriA newUri;
+        if (uriParseSingleUriA(&newUri, ionUrl.c_str(), nullptr) !=
+            URI_SUCCESS) {
+          return std::optional<std::string>();
+        }
+
+        std::string hostName =
+            std::string(newUri.hostText.first, newUri.hostText.afterLast);
+        std::string scheme =
+            std::string(newUri.scheme.first, newUri.scheme.afterLast);
+
+        uriFreeUriMembersA(&newUri);
+
+        return std::make_optional<std::string>(
+            scheme + "://api." + hostName + '/');
+      })
+      .catchImmediately([](std::exception&&) {
+        return std::optional<std::string>(std::nullopt);
+      });
+}
+
 CesiumAsync::Future<Response<Assets>> Connection::assets() const {
   return this->_pAssetAccessor
       ->get(

CesiumUtility/include/CesiumUtility/Uri.h

@@ -14,6 +14,8 @@ class Uri final {
       const std::string& uri,
       const std::string& key,
       const std::string& value);
+  static std::string
+  getQueryValue(const std::string& uri, const std::string& key);
 
   typedef std::string
   SubstitutionCallbackSignature(const std::string& placeholder);

CesiumUtility/src/Uri.cpp

@@ -2,6 +2,7 @@
 
 #include <uriparser/Uri.h>
 
+#include <cstring>
 #include <stdexcept>
 
 namespace CesiumUtility {
@@ -100,6 +101,37 @@ std::string Uri::addQuery(
   // uriFreeUriMembersA(&baseUri);
 }
 
+std::string Uri::getQueryValue(const std::string& url, const std::string& key) {
+  UriUriA uri;
+  if (uriParseSingleUriA(&uri, url.c_str(), nullptr) != URI_SUCCESS) {
+    return "";
+  }
+  UriQueryListA* queryList;
+  int itemCount;
+  if (uriDissectQueryMallocA(
+          &queryList,
+          &itemCount,
+          uri.query.first,
+          uri.query.afterLast) != URI_SUCCESS) {
+    uriFreeUriMembersA(&uri);
+    return "";
+  }
+  UriQueryListA* p = queryList;
+  while (p) {
+    if (p->key && std::strcmp(p->key, key.c_str()) == 0) {
+      std::string value = p->value ? p->value : "";
+      uriUnescapeInPlaceA(value.data());
+      uriFreeQueryListA(queryList);
+      uriFreeUriMembersA(&uri);
+      return value;
+    }
+    p = p->next;
+  }
+  uriFreeQueryListA(queryList);
+  uriFreeUriMembersA(&uri);
+  return "";
+}
+
 std::string Uri::substituteTemplateParameters(
     const std::string& templateUri,
     const std::function<SubstitutionCallbackSignature>& substitutionCallback) {

CesiumUtility/test/TestGetQueryValue.cpp

@@ -0,0 +1,22 @@
+#include "CesiumUtility/Uri.h"
+
+#include <catch2/catch.hpp>
+
+using namespace CesiumUtility;
+
+TEST_CASE("Uri::getQueryValue") {
+  std::string url = "https://example.com/?name=John&age=25";
+  CHECK(Uri::getQueryValue(url, "name") == "John");
+  CHECK(Uri::getQueryValue(url, "age") == std::to_string(25));
+  CHECK(Uri::getQueryValue(url, "gender") == "");
+  CHECK(Uri::getQueryValue(url, "") == "");
+  CHECK(Uri::getQueryValue("", "name") == "");
+  CHECK(
+      Uri::getQueryValue(
+          "https://example.com/?name=John&name=Jane&age=25",
+          "name") == "John");
+  CHECK(
+      Uri::getQueryValue(
+          "https://example.com/?name=John%20Doe&age=25",
+          "name") == "John Doe");
+}