GetSnapshotsPagedResponse ConfigurationClient::GetSnapshots()

in sdk/appconfiguration/azure-data-appconfiguration/src/configuration_client.cpp [912:1101]


GetSnapshotsPagedResponse ConfigurationClient::GetSnapshots(
    std::string const& accept,
    GetSnapshotsOptions const& options,
    Core::Context const& context) const
{
  auto url = m_url;
  url.AppendPath("snapshots");

  url.AppendQueryParameter("api-version", Core::Url::Encode(m_apiVersion));
  url.AppendQueryParameter("name", Core::Url::Encode(options.Name));
  url.AppendQueryParameter("After", Core::Url::Encode(options.After));
  {
    std::string valueStr;
    for (size_t i = 0; i < options.Select.size(); ++i)
    {
      if (i != 0)
      {
        valueStr += ',';
      }

      valueStr += Core::Url::Encode(options.Select[i].ToString());
    }

    url.AppendQueryParameter("$Select", valueStr);
  }

  {
    std::string valueStr;
    for (size_t i = 0; i < options.Status.size(); ++i)
    {
      if (i != 0)
      {
        valueStr += ',';
      }

      valueStr += Core::Url::Encode(options.Status[i].ToString());
    }

    url.AppendQueryParameter("status", valueStr);
  }

  if (options.NextPageToken.find("https://") == 0 || options.NextPageToken.find("http://") == 0)
  {
    url = Core::Url(options.NextPageToken);
    url.SetPort(m_url.GetPort());
  }
  else if (!options.NextPageToken.empty())
  {
    url.SetPath(
        options.NextPageToken[0] == '/' ? options.NextPageToken.substr(1) : options.NextPageToken);
  }

  Core::Http::Request request(Core::Http::HttpMethod::Get, url);

  request.SetHeader("Accept", accept);
  request.SetHeader("Sync-Token", options.SyncToken);
  auto rawResponse = m_pipeline->Send(request, context);
  auto const httpStatusCode = rawResponse->GetStatusCode();

  if (httpStatusCode != Core::Http::HttpStatusCode::Ok)
  {
    throw Core::RequestFailedException(rawResponse);
  }

  GetSnapshotsPagedResponse response{};
  response.m_client = std::make_shared<ConfigurationClient>(*this);
  response.m_accept = accept;
  response.m_options = options;
  {
    auto const& responseBody = rawResponse->GetBody();
    if (responseBody.size() > 0)
    {
      auto const jsonRoot
          = Core::Json::_internal::json::parse(responseBody.begin(), responseBody.end());
      if (jsonRoot.contains("@nextLink") && !jsonRoot["@nextLink"].is_null())
      {
        response.NextPageToken = jsonRoot["@nextLink"].get<std::string>();
      }

      if (jsonRoot.contains("items"))
      {
        response.Items = std::vector<Snapshot>{};

        for (auto const& jsonItem : jsonRoot["items"])
        {
          Snapshot vectorItem{};

          vectorItem.Name = jsonItem["name"].get<std::string>();

          if (jsonItem.contains("status") && !jsonItem["status"].is_null())
          {
            vectorItem.Status = SnapshotStatus(jsonItem["status"].get<std::string>());
          }

          for (auto const& jsonItemNested : jsonItem["filters"])
          {
            KeyValueFilter vecItem{};

            vecItem.Key = jsonItemNested["key"].get<std::string>();

            if (jsonItemNested.contains("label") && !jsonItemNested["label"].is_null())
            {
              vecItem.Label = jsonItemNested["label"].get<std::string>();
            }

            if (jsonItemNested.contains("tags"))
            {
              vecItem.Tags = std::vector<std::string>{};

              for (auto const& jsonItemNestedAgain : jsonItemNested["tags"])
              {
                std::string vi{};

                vi = jsonItemNestedAgain.get<std::string>();

                vecItem.Tags.Value().emplace_back(std::move(vi));
              }
            }

            vectorItem.Filters.emplace_back(std::move(vecItem));
          }

          if (jsonItem.contains("composition_type") && !jsonItem["composition_type"].is_null())
          {
            vectorItem.CompositionType
                = CompositionType(jsonItem["composition_type"].get<std::string>());
          }

          if (jsonItem.contains("created") && !jsonItem["created"].is_null())
          {
            vectorItem.Created = jsonItem["created"].get<std::string>();
          }

          if (jsonItem.contains("expires") && !jsonItem["expires"].is_null())
          {
            vectorItem.Expires = jsonItem["expires"].get<std::string>();
          }

          if (jsonItem.contains("retention_period") && !jsonItem["retention_period"].is_null())
          {
            vectorItem.RetentionPeriod = jsonItem["retention_period"].is_string()
                ? std::stoll(jsonItem["retention_period"].get<std::string>())
                : jsonItem["retention_period"].get<std::int64_t>();
          }

          if (jsonItem.contains("size") && !jsonItem["size"].is_null())
          {
            vectorItem.Size = jsonItem["size"].is_string()
                ? std::stoll(jsonItem["size"].get<std::string>())
                : jsonItem["size"].get<std::int64_t>();
          }

          if (jsonItem.contains("items_count") && !jsonItem["items_count"].is_null())
          {
            vectorItem.ItemsCount = jsonItem["items_count"].is_string()
                ? std::stoll(jsonItem["items_count"].get<std::string>())
                : jsonItem["items_count"].get<std::int64_t>();
          }

          if (jsonItem.contains("tags"))
          {
            vectorItem.Tags = std::map<std::string, std::string>{};

            for (auto const& kv : jsonItem["tags"].items())
            {
              std::string value{};
              value = kv.value().get<std::string>();
              vectorItem.Tags.Value().emplace(kv.key(), value);
            }
          }

          if (jsonItem.contains("etag") && !jsonItem["etag"].is_null())
          {
            vectorItem.Etag = jsonItem["etag"].get<std::string>();
          }

          response.Items.Value().emplace_back(std::move(vectorItem));
        }
      }
    }
  }

  response.SyncToken = rawResponse->GetHeaders().at("Sync-Token");
  response.ContentType
      = GetSnapshotsResponseContentType(rawResponse->GetHeaders().at("Content-Type"));

  response.RawResponse = std::move(rawResponse);

  return response;
}