in sdk/appconfiguration/azure-data-appconfiguration/src/configuration_client.cpp [1379:1592]
Azure::Response<CreateSnapshotResult> ConfigurationClient::CreateSnapshot(
CreateSnapshotRequestContentType const& contentType,
std::string const& name,
std::string const& accept,
Snapshot const& entity,
CreateSnapshotOptions const& options,
Core::Context const& context) const
{
auto url = m_url;
url.AppendPath("snapshots/");
url.AppendPath(!name.empty() ? Core::Url::Encode(name) : "null");
url.AppendQueryParameter("api-version", Core::Url::Encode(m_apiVersion));
std::string jsonBody;
{
auto jsonRoot = Core::Json::_internal::json::object();
jsonRoot["name"] = entity.Name;
if (entity.Status.HasValue())
{
jsonRoot["status"] = entity.Status.Value().ToString();
}
for (size_t i = 0; i < entity.Filters.size(); ++i)
{
jsonRoot["filters"][i]["key"] = entity.Filters[i].Key;
if (entity.Filters[i].Label.HasValue())
{
jsonRoot["filters"][i]["label"] = entity.Filters[i].Label.Value();
}
if (entity.Filters[i].Tags.HasValue())
{
jsonRoot["filters"][i]["tags"] = Core::Json::_internal::json::array();
for (size_t j = 0; j < entity.Filters[i].Tags.Value().size(); ++j)
{
jsonRoot["filters"][i]["tags"][j] = entity.Filters[i].Tags.Value()[j];
}
}
}
if (entity.CompositionType.HasValue())
{
jsonRoot["composition_type"] = entity.CompositionType.Value().ToString();
}
if (entity.Created.HasValue())
{
jsonRoot["created"] = entity.Created.Value();
}
if (entity.Expires.HasValue())
{
jsonRoot["expires"] = entity.Expires.Value();
}
if (entity.RetentionPeriod.HasValue())
{
jsonRoot["retention_period"] = entity.RetentionPeriod.Value();
}
if (entity.Size.HasValue())
{
jsonRoot["size"] = entity.Size.Value();
}
if (entity.ItemsCount.HasValue())
{
jsonRoot["items_count"] = entity.ItemsCount.Value();
}
if (entity.Tags.HasValue())
{
jsonRoot["tags"] = Core::Json::_internal::json::object();
for (auto const& kv : entity.Tags.Value())
{
jsonRoot["tags"][kv.first] = kv.second;
}
}
if (entity.Etag.HasValue())
{
jsonRoot["etag"] = entity.Etag.Value();
}
jsonBody = jsonRoot.dump();
}
Core::IO::MemoryBodyStream requestBody(
reinterpret_cast<std::uint8_t const*>(jsonBody.data()), jsonBody.length());
Core::Http::Request request(Core::Http::HttpMethod::Put, url, &requestBody);
request.SetHeader("Content-Type", contentType.ToString());
request.SetHeader("Accept", accept);
request.SetHeader("Sync-Token", options.SyncToken);
request.SetHeader("Content-Length", std::to_string(requestBody.Length()));
auto rawResponse = m_pipeline->Send(request, context);
auto const httpStatusCode = rawResponse->GetStatusCode();
if (httpStatusCode != Core::Http::HttpStatusCode::Created)
{
throw Core::RequestFailedException(rawResponse);
}
CreateSnapshotResult response{};
{
auto const& responseBody = rawResponse->GetBody();
if (responseBody.size() > 0)
{
auto const jsonRoot
= Core::Json::_internal::json::parse(responseBody.begin(), responseBody.end());
response.Name = jsonRoot["name"].get<std::string>();
if (jsonRoot.contains("status") && !jsonRoot["status"].is_null())
{
response.Status = SnapshotStatus(jsonRoot["status"].get<std::string>());
}
for (auto const& jsonItem : jsonRoot["filters"])
{
KeyValueFilter vectorItem{};
vectorItem.Key = jsonItem["key"].get<std::string>();
if (jsonItem.contains("label") && !jsonItem["label"].is_null())
{
vectorItem.Label = jsonItem["label"].get<std::string>();
}
if (jsonItem.contains("tags"))
{
vectorItem.Tags = std::vector<std::string>{};
for (auto const& jsonItemNested : jsonItem["tags"])
{
std::string vecItem{};
vecItem = jsonItemNested.get<std::string>();
vectorItem.Tags.Value().emplace_back(std::move(vecItem));
}
}
response.Filters.emplace_back(std::move(vectorItem));
}
if (jsonRoot.contains("composition_type") && !jsonRoot["composition_type"].is_null())
{
response.CompositionType = CompositionType(jsonRoot["composition_type"].get<std::string>());
}
if (jsonRoot.contains("created") && !jsonRoot["created"].is_null())
{
response.Created = jsonRoot["created"].get<std::string>();
}
if (jsonRoot.contains("expires") && !jsonRoot["expires"].is_null())
{
response.Expires = jsonRoot["expires"].get<std::string>();
}
if (jsonRoot.contains("retention_period") && !jsonRoot["retention_period"].is_null())
{
response.RetentionPeriod = jsonRoot["retention_period"].is_string()
? std::stoll(jsonRoot["retention_period"].get<std::string>())
: jsonRoot["retention_period"].get<std::int64_t>();
}
if (jsonRoot.contains("size") && !jsonRoot["size"].is_null())
{
response.Size = jsonRoot["size"].is_string()
? std::stoll(jsonRoot["size"].get<std::string>())
: jsonRoot["size"].get<std::int64_t>();
}
if (jsonRoot.contains("items_count") && !jsonRoot["items_count"].is_null())
{
response.ItemsCount = jsonRoot["items_count"].is_string()
? std::stoll(jsonRoot["items_count"].get<std::string>())
: jsonRoot["items_count"].get<std::int64_t>();
}
if (jsonRoot.contains("tags"))
{
response.Tags = std::map<std::string, std::string>{};
for (auto const& kv : jsonRoot["tags"].items())
{
std::string value{};
value = kv.value().get<std::string>();
response.Tags.Value().emplace(kv.key(), value);
}
}
if (jsonRoot.contains("etag") && !jsonRoot["etag"].is_null())
{
response.Etag = jsonRoot["etag"].get<std::string>();
}
}
}
response.SyncToken = rawResponse->GetHeaders().at("Sync-Token");
response.ETag = rawResponse->GetHeaders().at("ETag");
response.Link = rawResponse->GetHeaders().at("Link");
response.OperationLocation = Core::Url(rawResponse->GetHeaders().at("Operation-Location"));
response.ContentType
= CreateSnapshotResponseContentType(rawResponse->GetHeaders().at("Content-Type"));
return Response<CreateSnapshotResult>(std::move(response), std::move(rawResponse));
}