OGC3DTilesAssetsParser.cpp

#include "OGC3DTilesAssetsParser.h"
 
#include "Context.h"
#include "Engine.h"
 
#include <Foundation/Logging/Logger.h>
 
#include <Serialization/JsonParser.h>
 
#include <algorithm> // for copy() and assign()
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("OGC3DTilesAssetsParser");
}
 
using namespace Cogs::Core;
 
// FIXME: We should rather return a BOOL for status and provide the TilesAssets object as a pre-allocated parameter.
OGC3DTilesAssetsParser::TilesAsset*
parseJSON(std::string_view json) {
  Document doc = parseJson(json, JsonParseFlags::None);
  OGC3DTilesAssetsParser::TilesAsset* asset = new OGC3DTilesAssetsParser::TilesAsset;
 
  if (doc.HasMember("type")) {
    asset->type = std::string(doc["type"].GetString());
  }
  else {
    LOG_ERROR(logger, "No TYPE in asset structure");
    return asset;
  }
 
  if (doc.HasMember("url")) {
    asset->url = std::string(doc["url"].GetString());
  }
  else if (doc.HasMember("options")) {
    GenericObject options = doc["options"].GetObject();
    if (options.HasMember("url")) {
      asset->url = std::string(options["url"].GetString());
    }
    else {
      LOG_ERROR(logger, "No URL:OPTIONS in asset structure");
      return asset;
    }
  }
  else {
    LOG_ERROR(logger, "No URL in asset structure");
    return asset;
  }
 
  if (doc.HasMember("accessToken")) {
    // Using the name 'bearerToken' to avoid confusion with 'accessToken' in OGC3DTilesComponent
    asset->bearerToken = std::string(doc["accessToken"].GetString());
  }
  else {
    LOG_WARNING(logger, "Tiles assets file does not contain an 'accessToken' property.");
  }
 
  // Parse the "attribution" section later, if needed.
  return asset;
}
 
Cogs::Core::DataFetcherManager::FetchId
OGC3DTilesAssetsParser::fetch(Context* context, const std::string& baseURL, const std::string& accessToken, int assetId, OGC3DTilesAssetsParser::FetchCallback callback)
{
  if (assetId < 0) { // Is this a dataset which does not have an asset file?
    callback(nullptr);
    return Cogs::Core::DataFetcherManager::NoFetchId;
  }
 
  const std::string url = baseURL + "/v1/assets/" + std::to_string(assetId) + "/endpoint?access_token=" + accessToken;
 
  Cogs::Core::DataFetcherManager::FetchId fetchId = DataFetcherManager::fetchAsync(context, url,
    [context, url, callback](std::unique_ptr<Cogs::FileContents> data) {
      OGC3DTilesAssetsParser::TilesAsset* asset = nullptr;
      if (data) {
        // Data is available in worker thread. Create a data parsing task lambda
        Cogs::Memory::MemoryBuffer contentsBuff = data->take();
        std::string_view jsonStr = std::string_view(static_cast<const char*>(contentsBuff.data()), contentsBuff.size());
        asset = parseJSON(jsonStr);
      }
      else {
        LOG_ERROR(logger, "Could not fetch assets file '%s'", url.c_str());
      }
 
      auto finishTask = [callback, asset]() {
        callback(asset);
      };
 
#if defined(EMSCRIPTEN)
      // Cogs.js support - no threading
      (void)context;  // Silence unused capture warning.
      finishTask();
#else
      context->engine->runTaskInMainThread(std::move(finishTask));
#endif
    });
 
  return fetchId;
}
 
std::string
OGC3DTilesAssetsParser::getAssetHostname(const OGC3DTilesAssetsParser::TilesAsset* asset)
{
  const size_t start = asset->url.find_first_of("://");
  const size_t end = asset->url.find("/", start + 4);
  if (start == std::string::npos || end == std::string::npos) {
    return asset->url;
  }
  return asset->url.substr(0, end);
}