Connection.h

#pragma once
 
#include <CesiumAsync/AsyncSystem.h>
#include <CesiumAsync/IAssetAccessor.h>
#include <CesiumAsync/Library.h>
#include <CesiumAsync/SharedFuture.h>
#include <CesiumClientCommon/OAuth2PKCE.h>
#include <CesiumIonClient/ApplicationData.h>
#include <CesiumIonClient/Assets.h>
#include <CesiumIonClient/Defaults.h>
#include <CesiumIonClient/Geocoder.h>
#include <CesiumIonClient/LoginToken.h>
#include <CesiumIonClient/Profile.h>
#include <CesiumIonClient/Response.h>
#include <CesiumIonClient/Token.h>
#include <CesiumIonClient/TokenList.h>
#include <CesiumUtility/Result.h>
 
#include <cstdint>
#include <mutex>
#include <optional>
#include <string>
 
namespace CesiumIonClient {

enum class SortOrder { Ascending, Descending };

struct ListTokensOptions {
  std::optional<int32_t> limit;

  std::optional<int32_t> page;

  std::optional<std::string> search;

  std::optional<std::string> sortBy;

  std::optional<SortOrder> sortOrder;
};

class CESIUMASYNC_API Connection {
public:
  static CesiumAsync::Future<CesiumUtility::Result<Connection>> authorize(
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      const std::string& friendlyApplicationName,
      int64_t clientID,
      const std::string& redirectPath,
      const std::vector<std::string>& scopes,
      std::function<void(const std::string&)>&& openUrlCallback,
      const CesiumIonClient::ApplicationData& appData,
      const std::string& ionApiUrl = "https://api.cesium.com/",
      const std::string& ionAuthorizeUrl = "https://ion.cesium.com/oauth");

  static CesiumAsync::Future<Response<ApplicationData>> appData(
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      const std::string& apiUrl = "https://api.cesium.com");

  static CesiumAsync::Future<std::optional<std::string>> getApiUrl(
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      const std::string& ionUrl);

  Connection(
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      const std::string& accessToken,
      const CesiumIonClient::ApplicationData& appData,
      const std::string& apiUrl = "https://api.cesium.com");

  Connection(
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      const CesiumIonClient::LoginToken& accessToken,
      const std::string& refreshToken,
      int64_t clientId,
      const std::string& redirectPath,
      const CesiumIonClient::ApplicationData& appData,
      const std::string& apiUrl = "https://api.cesium.com");

  Connection(
      const CesiumAsync::AsyncSystem& asyncSystem,
      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor,
      const CesiumIonClient::ApplicationData& appData,
      const std::string& apiUrl);

  const CesiumAsync::AsyncSystem& getAsyncSystem() const noexcept;

  const std::shared_ptr<CesiumAsync::IAssetAccessor>&
  getAssetAccessor() const noexcept;

  const std::string& getAccessToken() const noexcept;

  const std::string& getRefreshToken() const noexcept;

  const std::string& getApiUrl() const noexcept;

  CesiumAsync::Future<Response<Profile>> me() const;

  CesiumAsync::Future<Response<Defaults>> defaults() const;

  CesiumAsync::Future<Response<Assets>> assets() const;

  CesiumAsync::Future<Response<TokenList>>
  tokens(const ListTokensOptions& options = {}) const;

  CesiumAsync::Future<Response<Asset>> asset(int64_t assetID) const;

  CesiumAsync::Future<Response<Token>> token(const std::string& tokenID) const;

  CesiumAsync::Future<Response<TokenList>>
  nextPage(const Response<TokenList>& currentPage) const;

  CesiumAsync::Future<Response<TokenList>>
  previousPage(const Response<TokenList>& currentPage) const;

  CesiumAsync::Future<Response<Token>> createToken(
      const std::string& name,
      const std::vector<std::string>& scopes,
      const std::optional<std::vector<int64_t>>& assetIds = std::nullopt,
      const std::optional<std::vector<std::string>>& allowedUrls =
          std::nullopt) const;

  CesiumAsync::Future<Response<NoValue>> modifyToken(
      const std::string& tokenID,
      const std::string& newName,
      const std::optional<std::vector<int64_t>>& newAssetIDs,
      const std::vector<std::string>& newScopes,
      const std::optional<std::vector<std::string>>& newAllowedUrls) const;

  CesiumAsync::Future<Response<GeocoderResult>> geocode(
      GeocoderProviderType provider,
      GeocoderRequestType type,
      const std::string& query) const;

  static std::optional<std::string> getIdFromToken(const std::string& token);
 
private:
  // This is a separate structure so that it can outlive the Connection while an
  // async operation is in progress.
  struct TokenDetails {
    TokenDetails(
        const CesiumIonClient::LoginToken& accessToken,
        const std::string& refreshToken);
 
    CesiumIonClient::LoginToken accessToken;
    std::string refreshToken;
    std::optional<CesiumAsync::SharedFuture<CesiumUtility::Result<std::string>>>
        refreshInProgress;
    std::mutex mutex;
  };
 
  CesiumAsync::Future<Response<TokenList>> tokens(const std::string& url) const;
  CesiumAsync::Future<CesiumUtility::Result<std::string>>
  ensureValidToken() const;
 
  CesiumAsync::AsyncSystem _asyncSystem;
  std::shared_ptr<CesiumAsync::IAssetAccessor> _pAssetAccessor;
  std::string _apiUrl;
  CesiumIonClient::ApplicationData _appData;
  int64_t _clientId;
  std::string _redirectPath;
  std::shared_ptr<TokenDetails> _pTokenDetails;
};
} // namespace CesiumIonClient