1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Supported secretmanager for kms.

Browse Source
This commit is contained in:
sdk-team
2020-02-28 17:10:17 +08:00
parent ca9bc6363b
commit 14fa5fe61a
89 changed files with 3497 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
kms/CMakeLists.txt
View File

@@ -37,18 +37,24 @@ set(kms_public_header_model
include/alibabacloud/kms/model/CreateKeyResult.h
include/alibabacloud/kms/model/CreateKeyVersionRequest.h
include/alibabacloud/kms/model/CreateKeyVersionResult.h
include/alibabacloud/kms/model/CreateSecretRequest.h
include/alibabacloud/kms/model/CreateSecretResult.h
include/alibabacloud/kms/model/DecryptRequest.h
include/alibabacloud/kms/model/DecryptResult.h
include/alibabacloud/kms/model/DeleteAliasRequest.h
include/alibabacloud/kms/model/DeleteAliasResult.h
include/alibabacloud/kms/model/DeleteKeyMaterialRequest.h
include/alibabacloud/kms/model/DeleteKeyMaterialResult.h
include/alibabacloud/kms/model/DeleteSecretRequest.h
include/alibabacloud/kms/model/DeleteSecretResult.h
include/alibabacloud/kms/model/DescribeKeyRequest.h
include/alibabacloud/kms/model/DescribeKeyResult.h
include/alibabacloud/kms/model/DescribeKeyVersionRequest.h
include/alibabacloud/kms/model/DescribeKeyVersionResult.h
include/alibabacloud/kms/model/DescribeRegionsRequest.h
include/alibabacloud/kms/model/DescribeRegionsResult.h
include/alibabacloud/kms/model/DescribeSecretRequest.h
include/alibabacloud/kms/model/DescribeSecretResult.h
include/alibabacloud/kms/model/DescribeServiceRequest.h
include/alibabacloud/kms/model/DescribeServiceResult.h
include/alibabacloud/kms/model/DisableKeyRequest.h
@@ -65,6 +71,10 @@ set(kms_public_header_model
include/alibabacloud/kms/model/GetParametersForImportResult.h
include/alibabacloud/kms/model/GetPublicKeyRequest.h
include/alibabacloud/kms/model/GetPublicKeyResult.h
include/alibabacloud/kms/model/GetRandomPasswordRequest.h
include/alibabacloud/kms/model/GetRandomPasswordResult.h
include/alibabacloud/kms/model/GetSecretValueRequest.h
include/alibabacloud/kms/model/GetSecretValueResult.h
include/alibabacloud/kms/model/ImportKeyMaterialRequest.h
include/alibabacloud/kms/model/ImportKeyMaterialResult.h
include/alibabacloud/kms/model/ListAliasesRequest.h
@@ -77,6 +87,14 @@ set(kms_public_header_model
include/alibabacloud/kms/model/ListKeysResult.h
include/alibabacloud/kms/model/ListResourceTagsRequest.h
include/alibabacloud/kms/model/ListResourceTagsResult.h
include/alibabacloud/kms/model/ListSecretVersionIdsRequest.h
include/alibabacloud/kms/model/ListSecretVersionIdsResult.h
include/alibabacloud/kms/model/ListSecretsRequest.h
include/alibabacloud/kms/model/ListSecretsResult.h
include/alibabacloud/kms/model/PutSecretValueRequest.h
include/alibabacloud/kms/model/PutSecretValueResult.h
include/alibabacloud/kms/model/RestoreSecretRequest.h
include/alibabacloud/kms/model/RestoreSecretResult.h
include/alibabacloud/kms/model/ScheduleKeyDeletionRequest.h
include/alibabacloud/kms/model/ScheduleKeyDeletionResult.h
include/alibabacloud/kms/model/TagResourceRequest.h
@@ -88,7 +106,11 @@ set(kms_public_header_model
include/alibabacloud/kms/model/UpdateKeyDescriptionRequest.h
include/alibabacloud/kms/model/UpdateKeyDescriptionResult.h
include/alibabacloud/kms/model/UpdateRotationPolicyRequest.h
include/alibabacloud/kms/model/UpdateRotationPolicyResult.h )
include/alibabacloud/kms/model/UpdateRotationPolicyResult.h
include/alibabacloud/kms/model/UpdateSecretRequest.h
include/alibabacloud/kms/model/UpdateSecretResult.h
include/alibabacloud/kms/model/UpdateSecretVersionStageRequest.h
include/alibabacloud/kms/model/UpdateSecretVersionStageResult.h )
set(kms_src
src/KmsClient.cc
@@ -108,18 +130,24 @@ set(kms_src
src/model/CreateKeyResult.cc
src/model/CreateKeyVersionRequest.cc
src/model/CreateKeyVersionResult.cc
src/model/CreateSecretRequest.cc
src/model/CreateSecretResult.cc
src/model/DecryptRequest.cc
src/model/DecryptResult.cc
src/model/DeleteAliasRequest.cc
src/model/DeleteAliasResult.cc
src/model/DeleteKeyMaterialRequest.cc
src/model/DeleteKeyMaterialResult.cc
src/model/DeleteSecretRequest.cc
src/model/DeleteSecretResult.cc
src/model/DescribeKeyRequest.cc
src/model/DescribeKeyResult.cc
src/model/DescribeKeyVersionRequest.cc
src/model/DescribeKeyVersionResult.cc
src/model/DescribeRegionsRequest.cc
src/model/DescribeRegionsResult.cc
src/model/DescribeSecretRequest.cc
src/model/DescribeSecretResult.cc
src/model/DescribeServiceRequest.cc
src/model/DescribeServiceResult.cc
src/model/DisableKeyRequest.cc
@@ -136,6 +164,10 @@ set(kms_src
src/model/GetParametersForImportResult.cc
src/model/GetPublicKeyRequest.cc
src/model/GetPublicKeyResult.cc
src/model/GetRandomPasswordRequest.cc
src/model/GetRandomPasswordResult.cc
src/model/GetSecretValueRequest.cc
src/model/GetSecretValueResult.cc
src/model/ImportKeyMaterialRequest.cc
src/model/ImportKeyMaterialResult.cc
src/model/ListAliasesRequest.cc
@@ -148,6 +180,14 @@ set(kms_src
src/model/ListKeysResult.cc
src/model/ListResourceTagsRequest.cc
src/model/ListResourceTagsResult.cc
src/model/ListSecretVersionIdsRequest.cc
src/model/ListSecretVersionIdsResult.cc
src/model/ListSecretsRequest.cc
src/model/ListSecretsResult.cc
src/model/PutSecretValueRequest.cc
src/model/PutSecretValueResult.cc
src/model/RestoreSecretRequest.cc
src/model/RestoreSecretResult.cc
src/model/ScheduleKeyDeletionRequest.cc
src/model/ScheduleKeyDeletionResult.cc
src/model/TagResourceRequest.cc
@@ -159,7 +199,11 @@ set(kms_src
src/model/UpdateKeyDescriptionRequest.cc
src/model/UpdateKeyDescriptionResult.cc
src/model/UpdateRotationPolicyRequest.cc
src/model/UpdateRotationPolicyResult.cc )
src/model/UpdateRotationPolicyResult.cc
src/model/UpdateSecretRequest.cc
src/model/UpdateSecretResult.cc
src/model/UpdateSecretVersionStageRequest.cc
src/model/UpdateSecretVersionStageResult.cc )
add_library(kms ${LIB_TYPE}
${kms_public_header}

88
kms/include/alibabacloud/kms/KmsClient.h
View File

@@ -38,18 +38,24 @@
#include "model/CreateKeyResult.h"
#include "model/CreateKeyVersionRequest.h"
#include "model/CreateKeyVersionResult.h"
#include "model/CreateSecretRequest.h"
#include "model/CreateSecretResult.h"
#include "model/DecryptRequest.h"
#include "model/DecryptResult.h"
#include "model/DeleteAliasRequest.h"
#include "model/DeleteAliasResult.h"
#include "model/DeleteKeyMaterialRequest.h"
#include "model/DeleteKeyMaterialResult.h"
#include "model/DeleteSecretRequest.h"
#include "model/DeleteSecretResult.h"
#include "model/DescribeKeyRequest.h"
#include "model/DescribeKeyResult.h"
#include "model/DescribeKeyVersionRequest.h"
#include "model/DescribeKeyVersionResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/DescribeSecretRequest.h"
#include "model/DescribeSecretResult.h"
#include "model/DescribeServiceRequest.h"
#include "model/DescribeServiceResult.h"
#include "model/DisableKeyRequest.h"
@@ -66,6 +72,10 @@
#include "model/GetParametersForImportResult.h"
#include "model/GetPublicKeyRequest.h"
#include "model/GetPublicKeyResult.h"
#include "model/GetRandomPasswordRequest.h"
#include "model/GetRandomPasswordResult.h"
#include "model/GetSecretValueRequest.h"
#include "model/GetSecretValueResult.h"
#include "model/ImportKeyMaterialRequest.h"
#include "model/ImportKeyMaterialResult.h"
#include "model/ListAliasesRequest.h"
@@ -78,6 +88,14 @@
#include "model/ListKeysResult.h"
#include "model/ListResourceTagsRequest.h"
#include "model/ListResourceTagsResult.h"
#include "model/ListSecretVersionIdsRequest.h"
#include "model/ListSecretVersionIdsResult.h"
#include "model/ListSecretsRequest.h"
#include "model/ListSecretsResult.h"
#include "model/PutSecretValueRequest.h"
#include "model/PutSecretValueResult.h"
#include "model/RestoreSecretRequest.h"
#include "model/RestoreSecretResult.h"
#include "model/ScheduleKeyDeletionRequest.h"
#include "model/ScheduleKeyDeletionResult.h"
#include "model/TagResourceRequest.h"
@@ -90,6 +108,10 @@
#include "model/UpdateKeyDescriptionResult.h"
#include "model/UpdateRotationPolicyRequest.h"
#include "model/UpdateRotationPolicyResult.h"
#include "model/UpdateSecretRequest.h"
#include "model/UpdateSecretResult.h"
#include "model/UpdateSecretVersionStageRequest.h"
#include "model/UpdateSecretVersionStageResult.h"
namespace AlibabaCloud
@@ -123,6 +145,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CreateKeyVersionResult> CreateKeyVersionOutcome;
typedef std::future<CreateKeyVersionOutcome> CreateKeyVersionOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::CreateKeyVersionRequest&, const CreateKeyVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateKeyVersionAsyncHandler;
typedef Outcome<Error, Model::CreateSecretResult> CreateSecretOutcome;
typedef std::future<CreateSecretOutcome> CreateSecretOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::CreateSecretRequest&, const CreateSecretOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSecretAsyncHandler;
typedef Outcome<Error, Model::DecryptResult> DecryptOutcome;
typedef std::future<DecryptOutcome> DecryptOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::DecryptRequest&, const DecryptOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DecryptAsyncHandler;
@@ -132,6 +157,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteKeyMaterialResult> DeleteKeyMaterialOutcome;
typedef std::future<DeleteKeyMaterialOutcome> DeleteKeyMaterialOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::DeleteKeyMaterialRequest&, const DeleteKeyMaterialOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteKeyMaterialAsyncHandler;
typedef Outcome<Error, Model::DeleteSecretResult> DeleteSecretOutcome;
typedef std::future<DeleteSecretOutcome> DeleteSecretOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::DeleteSecretRequest&, const DeleteSecretOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSecretAsyncHandler;
typedef Outcome<Error, Model::DescribeKeyResult> DescribeKeyOutcome;
typedef std::future<DescribeKeyOutcome> DescribeKeyOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::DescribeKeyRequest&, const DescribeKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeKeyAsyncHandler;
@@ -141,6 +169,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::DescribeSecretResult> DescribeSecretOutcome;
typedef std::future<DescribeSecretOutcome> DescribeSecretOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::DescribeSecretRequest&, const DescribeSecretOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSecretAsyncHandler;
typedef Outcome<Error, Model::DescribeServiceResult> DescribeServiceOutcome;
typedef std::future<DescribeServiceOutcome> DescribeServiceOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::DescribeServiceRequest&, const DescribeServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeServiceAsyncHandler;
@@ -165,6 +196,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::GetPublicKeyResult> GetPublicKeyOutcome;
typedef std::future<GetPublicKeyOutcome> GetPublicKeyOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::GetPublicKeyRequest&, const GetPublicKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPublicKeyAsyncHandler;
typedef Outcome<Error, Model::GetRandomPasswordResult> GetRandomPasswordOutcome;
typedef std::future<GetRandomPasswordOutcome> GetRandomPasswordOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::GetRandomPasswordRequest&, const GetRandomPasswordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetRandomPasswordAsyncHandler;
typedef Outcome<Error, Model::GetSecretValueResult> GetSecretValueOutcome;
typedef std::future<GetSecretValueOutcome> GetSecretValueOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::GetSecretValueRequest&, const GetSecretValueOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSecretValueAsyncHandler;
typedef Outcome<Error, Model::ImportKeyMaterialResult> ImportKeyMaterialOutcome;
typedef std::future<ImportKeyMaterialOutcome> ImportKeyMaterialOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ImportKeyMaterialRequest&, const ImportKeyMaterialOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImportKeyMaterialAsyncHandler;
@@ -183,6 +220,18 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ListResourceTagsResult> ListResourceTagsOutcome;
typedef std::future<ListResourceTagsOutcome> ListResourceTagsOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ListResourceTagsRequest&, const ListResourceTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListResourceTagsAsyncHandler;
typedef Outcome<Error, Model::ListSecretVersionIdsResult> ListSecretVersionIdsOutcome;
typedef std::future<ListSecretVersionIdsOutcome> ListSecretVersionIdsOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ListSecretVersionIdsRequest&, const ListSecretVersionIdsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSecretVersionIdsAsyncHandler;
typedef Outcome<Error, Model::ListSecretsResult> ListSecretsOutcome;
typedef std::future<ListSecretsOutcome> ListSecretsOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ListSecretsRequest&, const ListSecretsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSecretsAsyncHandler;
typedef Outcome<Error, Model::PutSecretValueResult> PutSecretValueOutcome;
typedef std::future<PutSecretValueOutcome> PutSecretValueOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::PutSecretValueRequest&, const PutSecretValueOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PutSecretValueAsyncHandler;
typedef Outcome<Error, Model::RestoreSecretResult> RestoreSecretOutcome;
typedef std::future<RestoreSecretOutcome> RestoreSecretOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::RestoreSecretRequest&, const RestoreSecretOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestoreSecretAsyncHandler;
typedef Outcome<Error, Model::ScheduleKeyDeletionResult> ScheduleKeyDeletionOutcome;
typedef std::future<ScheduleKeyDeletionOutcome> ScheduleKeyDeletionOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ScheduleKeyDeletionRequest&, const ScheduleKeyDeletionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ScheduleKeyDeletionAsyncHandler;
@@ -201,6 +250,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::UpdateRotationPolicyResult> UpdateRotationPolicyOutcome;
typedef std::future<UpdateRotationPolicyOutcome> UpdateRotationPolicyOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::UpdateRotationPolicyRequest&, const UpdateRotationPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateRotationPolicyAsyncHandler;
typedef Outcome<Error, Model::UpdateSecretResult> UpdateSecretOutcome;
typedef std::future<UpdateSecretOutcome> UpdateSecretOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::UpdateSecretRequest&, const UpdateSecretOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateSecretAsyncHandler;
typedef Outcome<Error, Model::UpdateSecretVersionStageResult> UpdateSecretVersionStageOutcome;
typedef std::future<UpdateSecretVersionStageOutcome> UpdateSecretVersionStageOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::UpdateSecretVersionStageRequest&, const UpdateSecretVersionStageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateSecretVersionStageAsyncHandler;
KmsClient(const Credentials &credentials, const ClientConfiguration &configuration);
KmsClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -230,6 +285,9 @@ namespace AlibabaCloud
CreateKeyVersionOutcome createKeyVersion(const Model::CreateKeyVersionRequest &request)const;
void createKeyVersionAsync(const Model::CreateKeyVersionRequest& request, const CreateKeyVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateKeyVersionOutcomeCallable createKeyVersionCallable(const Model::CreateKeyVersionRequest& request) const;
CreateSecretOutcome createSecret(const Model::CreateSecretRequest &request)const;
void createSecretAsync(const Model::CreateSecretRequest& request, const CreateSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateSecretOutcomeCallable createSecretCallable(const Model::CreateSecretRequest& request) const;
DecryptOutcome decrypt(const Model::DecryptRequest &request)const;
void decryptAsync(const Model::DecryptRequest& request, const DecryptAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DecryptOutcomeCallable decryptCallable(const Model::DecryptRequest& request) const;
@@ -239,6 +297,9 @@ namespace AlibabaCloud
DeleteKeyMaterialOutcome deleteKeyMaterial(const Model::DeleteKeyMaterialRequest &request)const;
void deleteKeyMaterialAsync(const Model::DeleteKeyMaterialRequest& request, const DeleteKeyMaterialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteKeyMaterialOutcomeCallable deleteKeyMaterialCallable(const Model::DeleteKeyMaterialRequest& request) const;
DeleteSecretOutcome deleteSecret(const Model::DeleteSecretRequest &request)const;
void deleteSecretAsync(const Model::DeleteSecretRequest& request, const DeleteSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteSecretOutcomeCallable deleteSecretCallable(const Model::DeleteSecretRequest& request) const;
DescribeKeyOutcome describeKey(const Model::DescribeKeyRequest &request)const;
void describeKeyAsync(const Model::DescribeKeyRequest& request, const DescribeKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeKeyOutcomeCallable describeKeyCallable(const Model::DescribeKeyRequest& request) const;
@@ -248,6 +309,9 @@ namespace AlibabaCloud
DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
DescribeSecretOutcome describeSecret(const Model::DescribeSecretRequest &request)const;
void describeSecretAsync(const Model::DescribeSecretRequest& request, const DescribeSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSecretOutcomeCallable describeSecretCallable(const Model::DescribeSecretRequest& request) const;
DescribeServiceOutcome describeService(const Model::DescribeServiceRequest &request)const;
void describeServiceAsync(const Model::DescribeServiceRequest& request, const DescribeServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeServiceOutcomeCallable describeServiceCallable(const Model::DescribeServiceRequest& request) const;
@@ -272,6 +336,12 @@ namespace AlibabaCloud
GetPublicKeyOutcome getPublicKey(const Model::GetPublicKeyRequest &request)const;
void getPublicKeyAsync(const Model::GetPublicKeyRequest& request, const GetPublicKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetPublicKeyOutcomeCallable getPublicKeyCallable(const Model::GetPublicKeyRequest& request) const;
GetRandomPasswordOutcome getRandomPassword(const Model::GetRandomPasswordRequest &request)const;
void getRandomPasswordAsync(const Model::GetRandomPasswordRequest& request, const GetRandomPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetRandomPasswordOutcomeCallable getRandomPasswordCallable(const Model::GetRandomPasswordRequest& request) const;
GetSecretValueOutcome getSecretValue(const Model::GetSecretValueRequest &request)const;
void getSecretValueAsync(const Model::GetSecretValueRequest& request, const GetSecretValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetSecretValueOutcomeCallable getSecretValueCallable(const Model::GetSecretValueRequest& request) const;
ImportKeyMaterialOutcome importKeyMaterial(const Model::ImportKeyMaterialRequest &request)const;
void importKeyMaterialAsync(const Model::ImportKeyMaterialRequest& request, const ImportKeyMaterialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImportKeyMaterialOutcomeCallable importKeyMaterialCallable(const Model::ImportKeyMaterialRequest& request) const;
@@ -290,6 +360,18 @@ namespace AlibabaCloud
ListResourceTagsOutcome listResourceTags(const Model::ListResourceTagsRequest &request)const;
void listResourceTagsAsync(const Model::ListResourceTagsRequest& request, const ListResourceTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListResourceTagsOutcomeCallable listResourceTagsCallable(const Model::ListResourceTagsRequest& request) const;
ListSecretVersionIdsOutcome listSecretVersionIds(const Model::ListSecretVersionIdsRequest &request)const;
void listSecretVersionIdsAsync(const Model::ListSecretVersionIdsRequest& request, const ListSecretVersionIdsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListSecretVersionIdsOutcomeCallable listSecretVersionIdsCallable(const Model::ListSecretVersionIdsRequest& request) const;
ListSecretsOutcome listSecrets(const Model::ListSecretsRequest &request)const;
void listSecretsAsync(const Model::ListSecretsRequest& request, const ListSecretsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListSecretsOutcomeCallable listSecretsCallable(const Model::ListSecretsRequest& request) const;
PutSecretValueOutcome putSecretValue(const Model::PutSecretValueRequest &request)const;
void putSecretValueAsync(const Model::PutSecretValueRequest& request, const PutSecretValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
PutSecretValueOutcomeCallable putSecretValueCallable(const Model::PutSecretValueRequest& request) const;
RestoreSecretOutcome restoreSecret(const Model::RestoreSecretRequest &request)const;
void restoreSecretAsync(const Model::RestoreSecretRequest& request, const RestoreSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RestoreSecretOutcomeCallable restoreSecretCallable(const Model::RestoreSecretRequest& request) const;
ScheduleKeyDeletionOutcome scheduleKeyDeletion(const Model::ScheduleKeyDeletionRequest &request)const;
void scheduleKeyDeletionAsync(const Model::ScheduleKeyDeletionRequest& request, const ScheduleKeyDeletionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ScheduleKeyDeletionOutcomeCallable scheduleKeyDeletionCallable(const Model::ScheduleKeyDeletionRequest& request) const;
@@ -308,6 +390,12 @@ namespace AlibabaCloud
UpdateRotationPolicyOutcome updateRotationPolicy(const Model::UpdateRotationPolicyRequest &request)const;
void updateRotationPolicyAsync(const Model::UpdateRotationPolicyRequest& request, const UpdateRotationPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateRotationPolicyOutcomeCallable updateRotationPolicyCallable(const Model::UpdateRotationPolicyRequest& request) const;
UpdateSecretOutcome updateSecret(const Model::UpdateSecretRequest &request)const;
void updateSecretAsync(const Model::UpdateSecretRequest& request, const UpdateSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateSecretOutcomeCallable updateSecretCallable(const Model::UpdateSecretRequest& request) const;
UpdateSecretVersionStageOutcome updateSecretVersionStage(const Model::UpdateSecretVersionStageRequest &request)const;
void updateSecretVersionStageAsync(const Model::UpdateSecretVersionStageRequest& request, const UpdateSecretVersionStageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateSecretVersionStageOutcomeCallable updateSecretVersionStageCallable(const Model::UpdateSecretVersionStageRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;

66
kms/include/alibabacloud/kms/model/CreateSecretRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_CREATESECRETREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_CREATESECRETREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT CreateSecretRequest : public RpcServiceRequest
{
public:
CreateSecretRequest();
~CreateSecretRequest();
std::string getVersionId()const;
void setVersionId(const std::string& versionId);
std::string getSecretData()const;
void setSecretData(const std::string& secretData);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getSecretName()const;
void setSecretName(const std::string& secretName);
std::string getEncryptionKeyId()const;
void setEncryptionKeyId(const std::string& encryptionKeyId);
std::string getSecretDataType()const;
void setSecretDataType(const std::string& secretDataType);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string versionId_;
std::string secretData_;
std::string description_;
std::string secretName_;
std::string encryptionKeyId_;
std::string secretDataType_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_CREATESECRETREQUEST_H_

55
kms/include/alibabacloud/kms/model/CreateSecretResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_CREATESECRETRESULT_H_
#define ALIBABACLOUD_KMS_MODEL_CREATESECRETRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT CreateSecretResult : public ServiceResult
{
public:
CreateSecretResult();
explicit CreateSecretResult(const std::string &payload);
~CreateSecretResult();
std::string getVersionId()const;
std::string getSecretName()const;
std::string getArn()const;
protected:
void parse(const std::string &payload);
private:
std::string versionId_;
std::string secretName_;
std::string arn_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_CREATESECRETRESULT_H_

54
kms/include/alibabacloud/kms/model/DeleteSecretRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_DELETESECRETREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_DELETESECRETREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT DeleteSecretRequest : public RpcServiceRequest
{
public:
DeleteSecretRequest();
~DeleteSecretRequest();
std::string getForceDeleteWithoutRecovery()const;
void setForceDeleteWithoutRecovery(const std::string& forceDeleteWithoutRecovery);
std::string getRecoveryWindowInDays()const;
void setRecoveryWindowInDays(const std::string& recoveryWindowInDays);
std::string getSecretName()const;
void setSecretName(const std::string& secretName);
private:
std::string forceDeleteWithoutRecovery_;
std::string recoveryWindowInDays_;
std::string secretName_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_DELETESECRETREQUEST_H_

53
kms/include/alibabacloud/kms/model/DeleteSecretResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_DELETESECRETRESULT_H_
#define ALIBABACLOUD_KMS_MODEL_DELETESECRETRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT DeleteSecretResult : public ServiceResult
{
public:
DeleteSecretResult();
explicit DeleteSecretResult(const std::string &payload);
~DeleteSecretResult();
std::string getSecretName()const;
std::string getPlannedDeleteTime()const;
protected:
void parse(const std::string &payload);
private:
std::string secretName_;
std::string plannedDeleteTime_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_DELETESECRETRESULT_H_

51
kms/include/alibabacloud/kms/model/DescribeSecretRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_DESCRIBESECRETREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_DESCRIBESECRETREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT DescribeSecretRequest : public RpcServiceRequest
{
public:
DescribeSecretRequest();
~DescribeSecretRequest();
std::string getSecretName()const;
void setSecretName(const std::string& secretName);
std::string getFetchTags()const;
void setFetchTags(const std::string& fetchTags);
private:
std::string secretName_;
std::string fetchTags_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_DESCRIBESECRETREQUEST_H_

70
kms/include/alibabacloud/kms/model/DescribeSecretResult.h Normal file
View File

@@ -0,0 +1,70 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_DESCRIBESECRETRESULT_H_
#define ALIBABACLOUD_KMS_MODEL_DESCRIBESECRETRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT DescribeSecretResult : public ServiceResult
{
public:
struct Tag
{
std::string tagKey;
std::string tagValue;
};
DescribeSecretResult();
explicit DescribeSecretResult(const std::string &payload);
~DescribeSecretResult();
std::string getSecretName()const;
std::string getDescription()const;
std::string getCreateTime()const;
std::string getUpdateTime()const;
std::string getPlannedDeleteTime()const;
std::string getArn()const;
std::vector<Tag> getTags()const;
std::string getEncryptionKeyId()const;
protected:
void parse(const std::string &payload);
private:
std::string secretName_;
std::string description_;
std::string createTime_;
std::string updateTime_;
std::string plannedDeleteTime_;
std::string arn_;
std::vector<Tag> tags_;
std::string encryptionKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_DESCRIBESECRETRESULT_H_

8
kms/include/alibabacloud/kms/model/DescribeServiceResult.h
View File

@@ -36,17 +36,25 @@ namespace AlibabaCloud
{
std::string type;
};
struct KeySpec
{
std::vector<std::string> supportedProtectionLevels;
std::vector<std::string> usages;
std::string name;
};
DescribeServiceResult();
explicit DescribeServiceResult(const std::string &payload);
~DescribeServiceResult();
std::vector<ProtectionLevel> getProtectionLevels()const;
std::vector<KeySpec> getKeySpecs()const;
protected:
void parse(const std::string &payload);
private:
std::vector<ProtectionLevel> protectionLevels_;
std::vector<KeySpec> keySpecs_;
};
}

66
kms/include/alibabacloud/kms/model/GetRandomPasswordRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_GETRANDOMPASSWORDREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_GETRANDOMPASSWORDREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT GetRandomPasswordRequest : public RpcServiceRequest
{
public:
GetRandomPasswordRequest();
~GetRandomPasswordRequest();
std::string getExcludeLowercase()const;
void setExcludeLowercase(const std::string& excludeLowercase);
std::string getExcludeCharacters()const;
void setExcludeCharacters(const std::string& excludeCharacters);
std::string getPasswordLength()const;
void setPasswordLength(const std::string& passwordLength);
std::string getExcludePunctuation()const;
void setExcludePunctuation(const std::string& excludePunctuation);
std::string getExcludeUppercase()const;
void setExcludeUppercase(const std::string& excludeUppercase);
std::string getRequireEachIncludedType()const;
void setRequireEachIncludedType(const std::string& requireEachIncludedType);
std::string getExcludeNumbers()const;
void setExcludeNumbers(const std::string& excludeNumbers);
private:
std::string excludeLowercase_;
std::string excludeCharacters_;
std::string passwordLength_;
std::string excludePunctuation_;
std::string excludeUppercase_;
std::string requireEachIncludedType_;
std::string excludeNumbers_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_GETRANDOMPASSWORDREQUEST_H_

51
kms/include/alibabacloud/kms/model/GetRandomPasswordResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_GETRANDOMPASSWORDRESULT_H_
#define ALIBABACLOUD_KMS_MODEL_GETRANDOMPASSWORDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT GetRandomPasswordResult : public ServiceResult
{
public:
GetRandomPasswordResult();
explicit GetRandomPasswordResult(const std::string &payload);
~GetRandomPasswordResult();
std::string getRandomPassword()const;
protected:
void parse(const std::string &payload);
private:
std::string randomPassword_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_GETRANDOMPASSWORDRESULT_H_

54
kms/include/alibabacloud/kms/model/GetSecretValueRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_GETSECRETVALUEREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_GETSECRETVALUEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT GetSecretValueRequest : public RpcServiceRequest
{
public:
GetSecretValueRequest();
~GetSecretValueRequest();
std::string getVersionId()const;
void setVersionId(const std::string& versionId);
std::string getVersionStage()const;
void setVersionStage(const std::string& versionStage);
std::string getSecretName()const;
void setSecretName(const std::string& secretName);
private:
std::string versionId_;
std::string versionStage_;
std::string secretName_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_GETSECRETVALUEREQUEST_H_

61
kms/include/alibabacloud/kms/model/GetSecretValueResult.h Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_GETSECRETVALUERESULT_H_
#define ALIBABACLOUD_KMS_MODEL_GETSECRETVALUERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT GetSecretValueResult : public ServiceResult
{
public:
GetSecretValueResult();
explicit GetSecretValueResult(const std::string &payload);
~GetSecretValueResult();
std::string getSecretName()const;
std::string getVersionId()const;
std::string getCreateTime()const;
std::string getSecretDataType()const;
std::string getSecretData()const;
std::vector<std::string> getVersionStages()const;
protected:
void parse(const std::string &payload);
private:
std::string secretName_;
std::string versionId_;
std::string createTime_;
std::string secretDataType_;
std::string secretData_;
std::vector<std::string> versionStages_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_GETSECRETVALUERESULT_H_

57
kms/include/alibabacloud/kms/model/ListSecretVersionIdsRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_LISTSECRETVERSIONIDSREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_LISTSECRETVERSIONIDSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT ListSecretVersionIdsRequest : public RpcServiceRequest
{
public:
ListSecretVersionIdsRequest();
~ListSecretVersionIdsRequest();
std::string getIncludeDeprecated()const;
void setIncludeDeprecated(const std::string& includeDeprecated);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getSecretName()const;
void setSecretName(const std::string& secretName);
int getPageNumber()const;
void setPageNumber(int pageNumber);
private:
std::string includeDeprecated_;
int pageSize_;
std::string secretName_;
int pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_LISTSECRETVERSIONIDSREQUEST_H_

65
kms/include/alibabacloud/kms/model/ListSecretVersionIdsResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_LISTSECRETVERSIONIDSRESULT_H_
#define ALIBABACLOUD_KMS_MODEL_LISTSECRETVERSIONIDSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT ListSecretVersionIdsResult : public ServiceResult
{
public:
struct VersionId
{
std::string versionId;
std::string createTime;
std::vector<std::string> versionStages;
};
ListSecretVersionIdsResult();
explicit ListSecretVersionIdsResult(const std::string &payload);
~ListSecretVersionIdsResult();
std::string getSecretName()const;
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<VersionId> getVersionIds()const;
protected:
void parse(const std::string &payload);
private:
std::string secretName_;
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<VersionId> versionIds_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_LISTSECRETVERSIONIDSRESULT_H_

54
kms/include/alibabacloud/kms/model/ListSecretsRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_LISTSECRETSREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_LISTSECRETSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT ListSecretsRequest : public RpcServiceRequest
{
public:
ListSecretsRequest();
~ListSecretsRequest();
int getPageSize()const;
void setPageSize(int pageSize);
std::string getFetchTags()const;
void setFetchTags(const std::string& fetchTags);
int getPageNumber()const;
void setPageNumber(int pageNumber);
private:
int pageSize_;
std::string fetchTags_;
int pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_LISTSECRETSREQUEST_H_

70
kms/include/alibabacloud/kms/model/ListSecretsResult.h Normal file
View File

@@ -0,0 +1,70 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_LISTSECRETSRESULT_H_
#define ALIBABACLOUD_KMS_MODEL_LISTSECRETSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT ListSecretsResult : public ServiceResult
{
public:
struct Secret
{
struct Tag
{
std::string tagKey;
std::string tagValue;
};
std::string secretName;
std::string createTime;
std::string updateTime;
std::string plannedDeleteTime;
std::vector<Secret::Tag> tags;
};
ListSecretsResult();
explicit ListSecretsResult(const std::string &payload);
~ListSecretsResult();
int getTotalCount()const;
std::vector<Secret> getSecretList()const;
int getPageSize()const;
int getPageNumber()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
std::vector<Secret> secretList_;
int pageSize_;
int pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_LISTSECRETSRESULT_H_

60
kms/include/alibabacloud/kms/model/PutSecretValueRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_PUTSECRETVALUEREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_PUTSECRETVALUEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT PutSecretValueRequest : public RpcServiceRequest
{
public:
PutSecretValueRequest();
~PutSecretValueRequest();
std::string getVersionId()const;
void setVersionId(const std::string& versionId);
std::string getVersionStages()const;
void setVersionStages(const std::string& versionStages);
std::string getSecretData()const;
void setSecretData(const std::string& secretData);
std::string getSecretName()const;
void setSecretName(const std::string& secretName);
std::string getSecretDataType()const;
void setSecretDataType(const std::string& secretDataType);
private:
std::string versionId_;
std::string versionStages_;
std::string secretData_;
std::string secretName_;
std::string secretDataType_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_PUTSECRETVALUEREQUEST_H_

55
kms/include/alibabacloud/kms/model/PutSecretValueResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_PUTSECRETVALUERESULT_H_
#define ALIBABACLOUD_KMS_MODEL_PUTSECRETVALUERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT PutSecretValueResult : public ServiceResult
{
public:
PutSecretValueResult();
explicit PutSecretValueResult(const std::string &payload);
~PutSecretValueResult();
std::string getSecretName()const;
std::string getVersionId()const;
std::vector<std::string> getVersionStages()const;
protected:
void parse(const std::string &payload);
private:
std::string secretName_;
std::string versionId_;
std::vector<std::string> versionStages_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_PUTSECRETVALUERESULT_H_

48
kms/include/alibabacloud/kms/model/RestoreSecretRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_RESTORESECRETREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_RESTORESECRETREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT RestoreSecretRequest : public RpcServiceRequest
{
public:
RestoreSecretRequest();
~RestoreSecretRequest();
std::string getSecretName()const;
void setSecretName(const std::string& secretName);
private:
std::string secretName_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_RESTORESECRETREQUEST_H_

51
kms/include/alibabacloud/kms/model/RestoreSecretResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_RESTORESECRETRESULT_H_
#define ALIBABACLOUD_KMS_MODEL_RESTORESECRETRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT RestoreSecretResult : public ServiceResult
{
public:
RestoreSecretResult();
explicit RestoreSecretResult(const std::string &payload);
~RestoreSecretResult();
std::string getSecretName()const;
protected:
void parse(const std::string &payload);
private:
std::string secretName_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_RESTORESECRETRESULT_H_

3
kms/include/alibabacloud/kms/model/TagResourceRequest.h
View File

@@ -37,11 +37,14 @@ namespace AlibabaCloud
std::string getKeyId()const;
void setKeyId(const std::string& keyId);
std::string getSecretName()const;
void setSecretName(const std::string& secretName);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string keyId_;
std::string secretName_;
std::string tags_;
};

3
kms/include/alibabacloud/kms/model/UntagResourceRequest.h
View File

@@ -39,10 +39,13 @@ namespace AlibabaCloud
void setTagKeys(const std::string& tagKeys);
std::string getKeyId()const;
void setKeyId(const std::string& keyId);
std::string getSecretName()const;
void setSecretName(const std::string& secretName);
private:
std::string tagKeys_;
std::string keyId_;
std::string secretName_;
};
}

2
kms/include/alibabacloud/kms/model/UntagResourceResult.h
View File

@@ -37,12 +37,10 @@ namespace AlibabaCloud
UntagResourceResult();
explicit UntagResourceResult(const std::string &payload);
~UntagResourceResult();
std::string getKeyId()const;
protected:
void parse(const std::string &payload);
private:
std::string keyId_;
};
}

51
kms/include/alibabacloud/kms/model/UpdateSecretRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_UPDATESECRETREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_UPDATESECRETREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT UpdateSecretRequest : public RpcServiceRequest
{
public:
UpdateSecretRequest();
~UpdateSecretRequest();
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getSecretName()const;
void setSecretName(const std::string& secretName);
private:
std::string description_;
std::string secretName_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_UPDATESECRETREQUEST_H_

51
kms/include/alibabacloud/kms/model/UpdateSecretResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_UPDATESECRETRESULT_H_
#define ALIBABACLOUD_KMS_MODEL_UPDATESECRETRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT UpdateSecretResult : public ServiceResult
{
public:
UpdateSecretResult();
explicit UpdateSecretResult(const std::string &payload);
~UpdateSecretResult();
std::string getSecretName()const;
protected:
void parse(const std::string &payload);
private:
std::string secretName_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_UPDATESECRETRESULT_H_

57
kms/include/alibabacloud/kms/model/UpdateSecretVersionStageRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_UPDATESECRETVERSIONSTAGEREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_UPDATESECRETVERSIONSTAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT UpdateSecretVersionStageRequest : public RpcServiceRequest
{
public:
UpdateSecretVersionStageRequest();
~UpdateSecretVersionStageRequest();
std::string getRemoveFromVersion()const;
void setRemoveFromVersion(const std::string& removeFromVersion);
std::string getMoveToVersion()const;
void setMoveToVersion(const std::string& moveToVersion);
std::string getVersionStage()const;
void setVersionStage(const std::string& versionStage);
std::string getSecretName()const;
void setSecretName(const std::string& secretName);
private:
std::string removeFromVersion_;
std::string moveToVersion_;
std::string versionStage_;
std::string secretName_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_UPDATESECRETVERSIONSTAGEREQUEST_H_

51
kms/include/alibabacloud/kms/model/UpdateSecretVersionStageResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_UPDATESECRETVERSIONSTAGERESULT_H_
#define ALIBABACLOUD_KMS_MODEL_UPDATESECRETVERSIONSTAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/kms/KmsExport.h>
namespace AlibabaCloud
{
namespace Kms
{
namespace Model
{
class ALIBABACLOUD_KMS_EXPORT UpdateSecretVersionStageResult : public ServiceResult
{
public:
UpdateSecretVersionStageResult();
explicit UpdateSecretVersionStageResult(const std::string &payload);
~UpdateSecretVersionStageResult();
std::string getSecretName()const;
protected:
void parse(const std::string &payload);
private:
std::string secretName_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_UPDATESECRETVERSIONSTAGERESULT_H_

396
kms/src/KmsClient.cc
View File

@@ -339,6 +339,42 @@ KmsClient::CreateKeyVersionOutcomeCallable KmsClient::createKeyVersionCallable(c
return task->get_future();
}
KmsClient::CreateSecretOutcome KmsClient::createSecret(const CreateSecretRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateSecretOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateSecretOutcome(CreateSecretResult(outcome.result()));
else
return CreateSecretOutcome(outcome.error());
}
void KmsClient::createSecretAsync(const CreateSecretRequest& request, const CreateSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createSecret(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::CreateSecretOutcomeCallable KmsClient::createSecretCallable(const CreateSecretRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateSecretOutcome()>>(
[this, request]()
{
return this->createSecret(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::DecryptOutcome KmsClient::decrypt(const DecryptRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -447,6 +483,42 @@ KmsClient::DeleteKeyMaterialOutcomeCallable KmsClient::deleteKeyMaterialCallable
return task->get_future();
}
KmsClient::DeleteSecretOutcome KmsClient::deleteSecret(const DeleteSecretRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteSecretOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteSecretOutcome(DeleteSecretResult(outcome.result()));
else
return DeleteSecretOutcome(outcome.error());
}
void KmsClient::deleteSecretAsync(const DeleteSecretRequest& request, const DeleteSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteSecret(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::DeleteSecretOutcomeCallable KmsClient::deleteSecretCallable(const DeleteSecretRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteSecretOutcome()>>(
[this, request]()
{
return this->deleteSecret(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::DescribeKeyOutcome KmsClient::describeKey(const DescribeKeyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -555,6 +627,42 @@ KmsClient::DescribeRegionsOutcomeCallable KmsClient::describeRegionsCallable(con
return task->get_future();
}
KmsClient::DescribeSecretOutcome KmsClient::describeSecret(const DescribeSecretRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeSecretOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeSecretOutcome(DescribeSecretResult(outcome.result()));
else
return DescribeSecretOutcome(outcome.error());
}
void KmsClient::describeSecretAsync(const DescribeSecretRequest& request, const DescribeSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeSecret(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::DescribeSecretOutcomeCallable KmsClient::describeSecretCallable(const DescribeSecretRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeSecretOutcome()>>(
[this, request]()
{
return this->describeSecret(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::DescribeServiceOutcome KmsClient::describeService(const DescribeServiceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -843,6 +951,78 @@ KmsClient::GetPublicKeyOutcomeCallable KmsClient::getPublicKeyCallable(const Get
return task->get_future();
}
KmsClient::GetRandomPasswordOutcome KmsClient::getRandomPassword(const GetRandomPasswordRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetRandomPasswordOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetRandomPasswordOutcome(GetRandomPasswordResult(outcome.result()));
else
return GetRandomPasswordOutcome(outcome.error());
}
void KmsClient::getRandomPasswordAsync(const GetRandomPasswordRequest& request, const GetRandomPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getRandomPassword(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::GetRandomPasswordOutcomeCallable KmsClient::getRandomPasswordCallable(const GetRandomPasswordRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetRandomPasswordOutcome()>>(
[this, request]()
{
return this->getRandomPassword(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::GetSecretValueOutcome KmsClient::getSecretValue(const GetSecretValueRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetSecretValueOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetSecretValueOutcome(GetSecretValueResult(outcome.result()));
else
return GetSecretValueOutcome(outcome.error());
}
void KmsClient::getSecretValueAsync(const GetSecretValueRequest& request, const GetSecretValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getSecretValue(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::GetSecretValueOutcomeCallable KmsClient::getSecretValueCallable(const GetSecretValueRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetSecretValueOutcome()>>(
[this, request]()
{
return this->getSecretValue(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::ImportKeyMaterialOutcome KmsClient::importKeyMaterial(const ImportKeyMaterialRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1059,6 +1239,150 @@ KmsClient::ListResourceTagsOutcomeCallable KmsClient::listResourceTagsCallable(c
return task->get_future();
}
KmsClient::ListSecretVersionIdsOutcome KmsClient::listSecretVersionIds(const ListSecretVersionIdsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListSecretVersionIdsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListSecretVersionIdsOutcome(ListSecretVersionIdsResult(outcome.result()));
else
return ListSecretVersionIdsOutcome(outcome.error());
}
void KmsClient::listSecretVersionIdsAsync(const ListSecretVersionIdsRequest& request, const ListSecretVersionIdsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listSecretVersionIds(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::ListSecretVersionIdsOutcomeCallable KmsClient::listSecretVersionIdsCallable(const ListSecretVersionIdsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListSecretVersionIdsOutcome()>>(
[this, request]()
{
return this->listSecretVersionIds(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::ListSecretsOutcome KmsClient::listSecrets(const ListSecretsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListSecretsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListSecretsOutcome(ListSecretsResult(outcome.result()));
else
return ListSecretsOutcome(outcome.error());
}
void KmsClient::listSecretsAsync(const ListSecretsRequest& request, const ListSecretsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listSecrets(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::ListSecretsOutcomeCallable KmsClient::listSecretsCallable(const ListSecretsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListSecretsOutcome()>>(
[this, request]()
{
return this->listSecrets(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::PutSecretValueOutcome KmsClient::putSecretValue(const PutSecretValueRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return PutSecretValueOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return PutSecretValueOutcome(PutSecretValueResult(outcome.result()));
else
return PutSecretValueOutcome(outcome.error());
}
void KmsClient::putSecretValueAsync(const PutSecretValueRequest& request, const PutSecretValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, putSecretValue(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::PutSecretValueOutcomeCallable KmsClient::putSecretValueCallable(const PutSecretValueRequest &request) const
{
auto task = std::make_shared<std::packaged_task<PutSecretValueOutcome()>>(
[this, request]()
{
return this->putSecretValue(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::RestoreSecretOutcome KmsClient::restoreSecret(const RestoreSecretRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RestoreSecretOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RestoreSecretOutcome(RestoreSecretResult(outcome.result()));
else
return RestoreSecretOutcome(outcome.error());
}
void KmsClient::restoreSecretAsync(const RestoreSecretRequest& request, const RestoreSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, restoreSecret(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::RestoreSecretOutcomeCallable KmsClient::restoreSecretCallable(const RestoreSecretRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RestoreSecretOutcome()>>(
[this, request]()
{
return this->restoreSecret(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::ScheduleKeyDeletionOutcome KmsClient::scheduleKeyDeletion(const ScheduleKeyDeletionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1275,3 +1599,75 @@ KmsClient::UpdateRotationPolicyOutcomeCallable KmsClient::updateRotationPolicyCa
return task->get_future();
}
KmsClient::UpdateSecretOutcome KmsClient::updateSecret(const UpdateSecretRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateSecretOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateSecretOutcome(UpdateSecretResult(outcome.result()));
else
return UpdateSecretOutcome(outcome.error());
}
void KmsClient::updateSecretAsync(const UpdateSecretRequest& request, const UpdateSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateSecret(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::UpdateSecretOutcomeCallable KmsClient::updateSecretCallable(const UpdateSecretRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateSecretOutcome()>>(
[this, request]()
{
return this->updateSecret(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::UpdateSecretVersionStageOutcome KmsClient::updateSecretVersionStage(const UpdateSecretVersionStageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateSecretVersionStageOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateSecretVersionStageOutcome(UpdateSecretVersionStageResult(outcome.result()));
else
return UpdateSecretVersionStageOutcome(outcome.error());
}
void KmsClient::updateSecretVersionStageAsync(const UpdateSecretVersionStageRequest& request, const UpdateSecretVersionStageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateSecretVersionStage(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::UpdateSecretVersionStageOutcomeCallable KmsClient::updateSecretVersionStageCallable(const UpdateSecretVersionStageRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateSecretVersionStageOutcome()>>(
[this, request]()
{
return this->updateSecretVersionStage(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

10
kms/src/model/AsymmetricDecryptRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::AsymmetricDecryptRequest;
AsymmetricDecryptRequest::AsymmetricDecryptRequest() :
RpcServiceRequest("kms", "2016-01-20", "AsymmetricDecrypt")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
AsymmetricDecryptRequest::~AsymmetricDecryptRequest()
@@ -35,7 +35,7 @@ std::string AsymmetricDecryptRequest::getKeyVersionId()const
void AsymmetricDecryptRequest::setKeyVersionId(const std::string& keyVersionId)
{
keyVersionId_ = keyVersionId;
setCoreParameter("KeyVersionId", keyVersionId);
setParameter("KeyVersionId", keyVersionId);
}
std::string AsymmetricDecryptRequest::getKeyId()const
@@ -46,7 +46,7 @@ std::string AsymmetricDecryptRequest::getKeyId()const
void AsymmetricDecryptRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}
std::string AsymmetricDecryptRequest::getCiphertextBlob()const
@@ -57,7 +57,7 @@ std::string AsymmetricDecryptRequest::getCiphertextBlob()const
void AsymmetricDecryptRequest::setCiphertextBlob(const std::string& ciphertextBlob)
{
ciphertextBlob_ = ciphertextBlob;
setCoreParameter("CiphertextBlob", ciphertextBlob);
setParameter("CiphertextBlob", ciphertextBlob);
}
std::string AsymmetricDecryptRequest::getAlgorithm()const
@@ -68,6 +68,6 @@ std::string AsymmetricDecryptRequest::getAlgorithm()const
void AsymmetricDecryptRequest::setAlgorithm(const std::string& algorithm)
{
algorithm_ = algorithm;
setCoreParameter("Algorithm", algorithm);
setParameter("Algorithm", algorithm);
}

10
kms/src/model/AsymmetricEncryptRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::AsymmetricEncryptRequest;
AsymmetricEncryptRequest::AsymmetricEncryptRequest() :
RpcServiceRequest("kms", "2016-01-20", "AsymmetricEncrypt")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
AsymmetricEncryptRequest::~AsymmetricEncryptRequest()
@@ -35,7 +35,7 @@ std::string AsymmetricEncryptRequest::getKeyVersionId()const
void AsymmetricEncryptRequest::setKeyVersionId(const std::string& keyVersionId)
{
keyVersionId_ = keyVersionId;
setCoreParameter("KeyVersionId", keyVersionId);
setParameter("KeyVersionId", keyVersionId);
}
std::string AsymmetricEncryptRequest::getKeyId()const
@@ -46,7 +46,7 @@ std::string AsymmetricEncryptRequest::getKeyId()const
void AsymmetricEncryptRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}
std::string AsymmetricEncryptRequest::getPlaintext()const
@@ -57,7 +57,7 @@ std::string AsymmetricEncryptRequest::getPlaintext()const
void AsymmetricEncryptRequest::setPlaintext(const std::string& plaintext)
{
plaintext_ = plaintext;
setCoreParameter("Plaintext", plaintext);
setParameter("Plaintext", plaintext);
}
std::string AsymmetricEncryptRequest::getAlgorithm()const
@@ -68,6 +68,6 @@ std::string AsymmetricEncryptRequest::getAlgorithm()const
void AsymmetricEncryptRequest::setAlgorithm(const std::string& algorithm)
{
algorithm_ = algorithm;
setCoreParameter("Algorithm", algorithm);
setParameter("Algorithm", algorithm);
}

10
kms/src/model/AsymmetricSignRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::AsymmetricSignRequest;
AsymmetricSignRequest::AsymmetricSignRequest() :
RpcServiceRequest("kms", "2016-01-20", "AsymmetricSign")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
AsymmetricSignRequest::~AsymmetricSignRequest()
@@ -35,7 +35,7 @@ std::string AsymmetricSignRequest::getKeyVersionId()const
void AsymmetricSignRequest::setKeyVersionId(const std::string& keyVersionId)
{
keyVersionId_ = keyVersionId;
setCoreParameter("KeyVersionId", keyVersionId);
setParameter("KeyVersionId", keyVersionId);
}
std::string AsymmetricSignRequest::getDigest()const
@@ -46,7 +46,7 @@ std::string AsymmetricSignRequest::getDigest()const
void AsymmetricSignRequest::setDigest(const std::string& digest)
{
digest_ = digest;
setCoreParameter("Digest", digest);
setParameter("Digest", digest);
}
std::string AsymmetricSignRequest::getKeyId()const
@@ -57,7 +57,7 @@ std::string AsymmetricSignRequest::getKeyId()const
void AsymmetricSignRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}
std::string AsymmetricSignRequest::getAlgorithm()const
@@ -68,6 +68,6 @@ std::string AsymmetricSignRequest::getAlgorithm()const
void AsymmetricSignRequest::setAlgorithm(const std::string& algorithm)
{
algorithm_ = algorithm;
setCoreParameter("Algorithm", algorithm);
setParameter("Algorithm", algorithm);
}

12
kms/src/model/AsymmetricVerifyRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::AsymmetricVerifyRequest;
AsymmetricVerifyRequest::AsymmetricVerifyRequest() :
RpcServiceRequest("kms", "2016-01-20", "AsymmetricVerify")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
AsymmetricVerifyRequest::~AsymmetricVerifyRequest()
@@ -35,7 +35,7 @@ std::string AsymmetricVerifyRequest::getKeyVersionId()const
void AsymmetricVerifyRequest::setKeyVersionId(const std::string& keyVersionId)
{
keyVersionId_ = keyVersionId;
setCoreParameter("KeyVersionId", keyVersionId);
setParameter("KeyVersionId", keyVersionId);
}
std::string AsymmetricVerifyRequest::getDigest()const
@@ -46,7 +46,7 @@ std::string AsymmetricVerifyRequest::getDigest()const
void AsymmetricVerifyRequest::setDigest(const std::string& digest)
{
digest_ = digest;
setCoreParameter("Digest", digest);
setParameter("Digest", digest);
}
std::string AsymmetricVerifyRequest::getKeyId()const
@@ -57,7 +57,7 @@ std::string AsymmetricVerifyRequest::getKeyId()const
void AsymmetricVerifyRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}
std::string AsymmetricVerifyRequest::getValue()const
@@ -68,7 +68,7 @@ std::string AsymmetricVerifyRequest::getValue()const
void AsymmetricVerifyRequest::setValue(const std::string& value)
{
value_ = value;
setCoreParameter("Value", value);
setParameter("Value", value);
}
std::string AsymmetricVerifyRequest::getAlgorithm()const
@@ -79,6 +79,6 @@ std::string AsymmetricVerifyRequest::getAlgorithm()const
void AsymmetricVerifyRequest::setAlgorithm(const std::string& algorithm)
{
algorithm_ = algorithm;
setCoreParameter("Algorithm", algorithm);
setParameter("Algorithm", algorithm);
}

4
kms/src/model/CancelKeyDeletionRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::CancelKeyDeletionRequest;
CancelKeyDeletionRequest::CancelKeyDeletionRequest() :
RpcServiceRequest("kms", "2016-01-20", "CancelKeyDeletion")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
CancelKeyDeletionRequest::~CancelKeyDeletionRequest()
@@ -35,6 +35,6 @@ std::string CancelKeyDeletionRequest::getKeyId()const
void CancelKeyDeletionRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}

6
kms/src/model/CreateAliasRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::CreateAliasRequest;
CreateAliasRequest::CreateAliasRequest() :
RpcServiceRequest("kms", "2016-01-20", "CreateAlias")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
CreateAliasRequest::~CreateAliasRequest()
@@ -35,7 +35,7 @@ std::string CreateAliasRequest::getAliasName()const
void CreateAliasRequest::setAliasName(const std::string& aliasName)
{
aliasName_ = aliasName;
setCoreParameter("AliasName", aliasName);
setParameter("AliasName", aliasName);
}
std::string CreateAliasRequest::getKeyId()const
@@ -46,6 +46,6 @@ std::string CreateAliasRequest::getKeyId()const
void CreateAliasRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}

16
kms/src/model/CreateKeyRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::CreateKeyRequest;
CreateKeyRequest::CreateKeyRequest() :
RpcServiceRequest("kms", "2016-01-20", "CreateKey")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
CreateKeyRequest::~CreateKeyRequest()
@@ -35,7 +35,7 @@ std::string CreateKeyRequest::getProtectionLevel()const
void CreateKeyRequest::setProtectionLevel(const std::string& protectionLevel)
{
protectionLevel_ = protectionLevel;
setCoreParameter("ProtectionLevel", protectionLevel);
setParameter("ProtectionLevel", protectionLevel);
}
std::string CreateKeyRequest::getKeyUsage()const
@@ -46,7 +46,7 @@ std::string CreateKeyRequest::getKeyUsage()const
void CreateKeyRequest::setKeyUsage(const std::string& keyUsage)
{
keyUsage_ = keyUsage;
setCoreParameter("KeyUsage", keyUsage);
setParameter("KeyUsage", keyUsage);
}
std::string CreateKeyRequest::getOrigin()const
@@ -57,7 +57,7 @@ std::string CreateKeyRequest::getOrigin()const
void CreateKeyRequest::setOrigin(const std::string& origin)
{
origin_ = origin;
setCoreParameter("Origin", origin);
setParameter("Origin", origin);
}
std::string CreateKeyRequest::getDescription()const
@@ -68,7 +68,7 @@ std::string CreateKeyRequest::getDescription()const
void CreateKeyRequest::setDescription(const std::string& description)
{
description_ = description;
setCoreParameter("Description", description);
setParameter("Description", description);
}
std::string CreateKeyRequest::getKeySpec()const
@@ -79,7 +79,7 @@ std::string CreateKeyRequest::getKeySpec()const
void CreateKeyRequest::setKeySpec(const std::string& keySpec)
{
keySpec_ = keySpec;
setCoreParameter("KeySpec", keySpec);
setParameter("KeySpec", keySpec);
}
std::string CreateKeyRequest::getRotationInterval()const
@@ -90,7 +90,7 @@ std::string CreateKeyRequest::getRotationInterval()const
void CreateKeyRequest::setRotationInterval(const std::string& rotationInterval)
{
rotationInterval_ = rotationInterval;
setCoreParameter("RotationInterval", rotationInterval);
setParameter("RotationInterval", rotationInterval);
}
bool CreateKeyRequest::getEnableAutomaticRotation()const
@@ -101,6 +101,6 @@ bool CreateKeyRequest::getEnableAutomaticRotation()const
void CreateKeyRequest::setEnableAutomaticRotation(bool enableAutomaticRotation)
{
enableAutomaticRotation_ = enableAutomaticRotation;
setCoreParameter("EnableAutomaticRotation", enableAutomaticRotation ? "true" : "false");
setParameter("EnableAutomaticRotation", enableAutomaticRotation ? "true" : "false");
}

4
kms/src/model/CreateKeyVersionRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::CreateKeyVersionRequest;
CreateKeyVersionRequest::CreateKeyVersionRequest() :
RpcServiceRequest("kms", "2016-01-20", "CreateKeyVersion")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
CreateKeyVersionRequest::~CreateKeyVersionRequest()
@@ -35,6 +35,6 @@ std::string CreateKeyVersionRequest::getKeyId()const
void CreateKeyVersionRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}

106
kms/src/model/CreateSecretRequest.cc Normal file
View File

@@ -0,0 +1,106 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/CreateSecretRequest.h>
using AlibabaCloud::Kms::Model::CreateSecretRequest;
CreateSecretRequest::CreateSecretRequest() :
RpcServiceRequest("kms", "2016-01-20", "CreateSecret")
{
setMethod(HttpRequest::Method::POST);
}
CreateSecretRequest::~CreateSecretRequest()
{}
std::string CreateSecretRequest::getVersionId()const
{
return versionId_;
}
void CreateSecretRequest::setVersionId(const std::string& versionId)
{
versionId_ = versionId;
setParameter("VersionId", versionId);
}
std::string CreateSecretRequest::getSecretData()const
{
return secretData_;
}
void CreateSecretRequest::setSecretData(const std::string& secretData)
{
secretData_ = secretData;
setParameter("SecretData", secretData);
}
std::string CreateSecretRequest::getDescription()const
{
return description_;
}
void CreateSecretRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
std::string CreateSecretRequest::getSecretName()const
{
return secretName_;
}
void CreateSecretRequest::setSecretName(const std::string& secretName)
{
secretName_ = secretName;
setParameter("SecretName", secretName);
}
std::string CreateSecretRequest::getEncryptionKeyId()const
{
return encryptionKeyId_;
}
void CreateSecretRequest::setEncryptionKeyId(const std::string& encryptionKeyId)
{
encryptionKeyId_ = encryptionKeyId;
setParameter("EncryptionKeyId", encryptionKeyId);
}
std::string CreateSecretRequest::getSecretDataType()const
{
return secretDataType_;
}
void CreateSecretRequest::setSecretDataType(const std::string& secretDataType)
{
secretDataType_ = secretDataType;
setParameter("SecretDataType", secretDataType);
}
std::string CreateSecretRequest::getTags()const
{
return tags_;
}
void CreateSecretRequest::setTags(const std::string& tags)
{
tags_ = tags;
setParameter("Tags", tags);
}

65
kms/src/model/CreateSecretResult.cc Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/CreateSecretResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
CreateSecretResult::CreateSecretResult() :
ServiceResult()
{}
CreateSecretResult::CreateSecretResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateSecretResult::~CreateSecretResult()
{}
void CreateSecretResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Arn"].isNull())
arn_ = value["Arn"].asString();
if(!value["VersionId"].isNull())
versionId_ = value["VersionId"].asString();
if(!value["SecretName"].isNull())
secretName_ = value["SecretName"].asString();
}
std::string CreateSecretResult::getVersionId()const
{
return versionId_;
}
std::string CreateSecretResult::getSecretName()const
{
return secretName_;
}
std::string CreateSecretResult::getArn()const
{
return arn_;
}

6
kms/src/model/DecryptRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DecryptRequest;
DecryptRequest::DecryptRequest() :
RpcServiceRequest("kms", "2016-01-20", "Decrypt")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
DecryptRequest::~DecryptRequest()
@@ -35,7 +35,7 @@ std::string DecryptRequest::getEncryptionContext()const
void DecryptRequest::setEncryptionContext(const std::string& encryptionContext)
{
encryptionContext_ = encryptionContext;
setCoreParameter("EncryptionContext", encryptionContext);
setParameter("EncryptionContext", encryptionContext);
}
std::string DecryptRequest::getCiphertextBlob()const
@@ -46,6 +46,6 @@ std::string DecryptRequest::getCiphertextBlob()const
void DecryptRequest::setCiphertextBlob(const std::string& ciphertextBlob)
{
ciphertextBlob_ = ciphertextBlob;
setCoreParameter("CiphertextBlob", ciphertextBlob);
setParameter("CiphertextBlob", ciphertextBlob);
}

4
kms/src/model/DeleteAliasRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DeleteAliasRequest;
DeleteAliasRequest::DeleteAliasRequest() :
RpcServiceRequest("kms", "2016-01-20", "DeleteAlias")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
DeleteAliasRequest::~DeleteAliasRequest()
@@ -35,6 +35,6 @@ std::string DeleteAliasRequest::getAliasName()const
void DeleteAliasRequest::setAliasName(const std::string& aliasName)
{
aliasName_ = aliasName;
setCoreParameter("AliasName", aliasName);
setParameter("AliasName", aliasName);
}

4
kms/src/model/DeleteKeyMaterialRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DeleteKeyMaterialRequest;
DeleteKeyMaterialRequest::DeleteKeyMaterialRequest() :
RpcServiceRequest("kms", "2016-01-20", "DeleteKeyMaterial")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
DeleteKeyMaterialRequest::~DeleteKeyMaterialRequest()
@@ -35,6 +35,6 @@ std::string DeleteKeyMaterialRequest::getKeyId()const
void DeleteKeyMaterialRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}

62
kms/src/model/DeleteSecretRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/DeleteSecretRequest.h>
using AlibabaCloud::Kms::Model::DeleteSecretRequest;
DeleteSecretRequest::DeleteSecretRequest() :
RpcServiceRequest("kms", "2016-01-20", "DeleteSecret")
{
setMethod(HttpRequest::Method::POST);
}
DeleteSecretRequest::~DeleteSecretRequest()
{}
std::string DeleteSecretRequest::getForceDeleteWithoutRecovery()const
{
return forceDeleteWithoutRecovery_;
}
void DeleteSecretRequest::setForceDeleteWithoutRecovery(const std::string& forceDeleteWithoutRecovery)
{
forceDeleteWithoutRecovery_ = forceDeleteWithoutRecovery;
setParameter("ForceDeleteWithoutRecovery", forceDeleteWithoutRecovery);
}
std::string DeleteSecretRequest::getRecoveryWindowInDays()const
{
return recoveryWindowInDays_;
}
void DeleteSecretRequest::setRecoveryWindowInDays(const std::string& recoveryWindowInDays)
{
recoveryWindowInDays_ = recoveryWindowInDays;
setParameter("RecoveryWindowInDays", recoveryWindowInDays);
}
std::string DeleteSecretRequest::getSecretName()const
{
return secretName_;
}
void DeleteSecretRequest::setSecretName(const std::string& secretName)
{
secretName_ = secretName;
setParameter("SecretName", secretName);
}

58
kms/src/model/DeleteSecretResult.cc Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/DeleteSecretResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
DeleteSecretResult::DeleteSecretResult() :
ServiceResult()
{}
DeleteSecretResult::DeleteSecretResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteSecretResult::~DeleteSecretResult()
{}
void DeleteSecretResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["SecretName"].isNull())
secretName_ = value["SecretName"].asString();
if(!value["PlannedDeleteTime"].isNull())
plannedDeleteTime_ = value["PlannedDeleteTime"].asString();
}
std::string DeleteSecretResult::getSecretName()const
{
return secretName_;
}
std::string DeleteSecretResult::getPlannedDeleteTime()const
{
return plannedDeleteTime_;
}

4
kms/src/model/DescribeKeyRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DescribeKeyRequest;
DescribeKeyRequest::DescribeKeyRequest() :
RpcServiceRequest("kms", "2016-01-20", "DescribeKey")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
DescribeKeyRequest::~DescribeKeyRequest()
@@ -35,6 +35,6 @@ std::string DescribeKeyRequest::getKeyId()const
void DescribeKeyRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}

6
kms/src/model/DescribeKeyVersionRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DescribeKeyVersionRequest;
DescribeKeyVersionRequest::DescribeKeyVersionRequest() :
RpcServiceRequest("kms", "2016-01-20", "DescribeKeyVersion")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
DescribeKeyVersionRequest::~DescribeKeyVersionRequest()
@@ -35,7 +35,7 @@ std::string DescribeKeyVersionRequest::getKeyVersionId()const
void DescribeKeyVersionRequest::setKeyVersionId(const std::string& keyVersionId)
{
keyVersionId_ = keyVersionId;
setCoreParameter("KeyVersionId", keyVersionId);
setParameter("KeyVersionId", keyVersionId);
}
std::string DescribeKeyVersionRequest::getKeyId()const
@@ -46,6 +46,6 @@ std::string DescribeKeyVersionRequest::getKeyId()const
void DescribeKeyVersionRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}

2
kms/src/model/DescribeRegionsRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DescribeRegionsRequest;
DescribeRegionsRequest::DescribeRegionsRequest() :
RpcServiceRequest("kms", "2016-01-20", "DescribeRegions")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
DescribeRegionsRequest::~DescribeRegionsRequest()

51
kms/src/model/DescribeSecretRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/DescribeSecretRequest.h>
using AlibabaCloud::Kms::Model::DescribeSecretRequest;
DescribeSecretRequest::DescribeSecretRequest() :
RpcServiceRequest("kms", "2016-01-20", "DescribeSecret")
{
setMethod(HttpRequest::Method::POST);
}
DescribeSecretRequest::~DescribeSecretRequest()
{}
std::string DescribeSecretRequest::getSecretName()const
{
return secretName_;
}
void DescribeSecretRequest::setSecretName(const std::string& secretName)
{
secretName_ = secretName;
setParameter("SecretName", secretName);
}
std::string DescribeSecretRequest::getFetchTags()const
{
return fetchTags_;
}
void DescribeSecretRequest::setFetchTags(const std::string& fetchTags)
{
fetchTags_ = fetchTags;
setParameter("FetchTags", fetchTags);
}

108
kms/src/model/DescribeSecretResult.cc Normal file
View File

@@ -0,0 +1,108 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/DescribeSecretResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
DescribeSecretResult::DescribeSecretResult() :
ServiceResult()
{}
DescribeSecretResult::DescribeSecretResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeSecretResult::~DescribeSecretResult()
{}
void DescribeSecretResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allTagsNode = value["Tags"]["Tag"];
for (auto valueTagsTag : allTagsNode)
{
Tag tagsObject;
if(!valueTagsTag["TagKey"].isNull())
tagsObject.tagKey = valueTagsTag["TagKey"].asString();
if(!valueTagsTag["TagValue"].isNull())
tagsObject.tagValue = valueTagsTag["TagValue"].asString();
tags_.push_back(tagsObject);
}
if(!value["Arn"].isNull())
arn_ = value["Arn"].asString();
if(!value["SecretName"].isNull())
secretName_ = value["SecretName"].asString();
if(!value["EncryptionKeyId"].isNull())
encryptionKeyId_ = value["EncryptionKeyId"].asString();
if(!value["Description"].isNull())
description_ = value["Description"].asString();
if(!value["CreateTime"].isNull())
createTime_ = value["CreateTime"].asString();
if(!value["UpdateTime"].isNull())
updateTime_ = value["UpdateTime"].asString();
if(!value["PlannedDeleteTime"].isNull())
plannedDeleteTime_ = value["PlannedDeleteTime"].asString();
}
std::string DescribeSecretResult::getSecretName()const
{
return secretName_;
}
std::string DescribeSecretResult::getDescription()const
{
return description_;
}
std::string DescribeSecretResult::getCreateTime()const
{
return createTime_;
}
std::string DescribeSecretResult::getUpdateTime()const
{
return updateTime_;
}
std::string DescribeSecretResult::getPlannedDeleteTime()const
{
return plannedDeleteTime_;
}
std::string DescribeSecretResult::getArn()const
{
return arn_;
}
std::vector<DescribeSecretResult::Tag> DescribeSecretResult::getTags()const
{
return tags_;
}
std::string DescribeSecretResult::getEncryptionKeyId()const
{
return encryptionKeyId_;
}

2
kms/src/model/DescribeServiceRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DescribeServiceRequest;
DescribeServiceRequest::DescribeServiceRequest() :
RpcServiceRequest("kms", "2016-01-20", "DescribeService")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
DescribeServiceRequest::~DescribeServiceRequest()

19
kms/src/model/DescribeServiceResult.cc
View File

@@ -47,6 +47,20 @@ void DescribeServiceResult::parse(const std::string &payload)
protectionLevelsObject.type = valueProtectionLevelsProtectionLevel["Type"].asString();
protectionLevels_.push_back(protectionLevelsObject);
}
auto allKeySpecsNode = value["KeySpecs"]["KeySpec"];
for (auto valueKeySpecsKeySpec : allKeySpecsNode)
{
KeySpec keySpecsObject;
if(!valueKeySpecsKeySpec["Name"].isNull())
keySpecsObject.name = valueKeySpecsKeySpec["Name"].asString();
auto allSupportedProtectionLevels = value["SupportedProtectionLevels"]["SupportedProtectionLevel"];
for (auto value : allSupportedProtectionLevels)
keySpecsObject.supportedProtectionLevels.push_back(value.asString());
auto allUsages = value["Usages"]["Usage"];
for (auto value : allUsages)
keySpecsObject.usages.push_back(value.asString());
keySpecs_.push_back(keySpecsObject);
}
}
@@ -55,3 +69,8 @@ std::vector<DescribeServiceResult::ProtectionLevel> DescribeServiceResult::getPr
return protectionLevels_;
}
std::vector<DescribeServiceResult::KeySpec> DescribeServiceResult::getKeySpecs()const
{
return keySpecs_;
}

4
kms/src/model/DisableKeyRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DisableKeyRequest;
DisableKeyRequest::DisableKeyRequest() :
RpcServiceRequest("kms", "2016-01-20", "DisableKey")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
DisableKeyRequest::~DisableKeyRequest()
@@ -35,6 +35,6 @@ std::string DisableKeyRequest::getKeyId()const
void DisableKeyRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}

4
kms/src/model/EnableKeyRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::EnableKeyRequest;
EnableKeyRequest::EnableKeyRequest() :
RpcServiceRequest("kms", "2016-01-20", "EnableKey")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
EnableKeyRequest::~EnableKeyRequest()
@@ -35,6 +35,6 @@ std::string EnableKeyRequest::getKeyId()const
void EnableKeyRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}

8
kms/src/model/EncryptRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::EncryptRequest;
EncryptRequest::EncryptRequest() :
RpcServiceRequest("kms", "2016-01-20", "Encrypt")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
EncryptRequest::~EncryptRequest()
@@ -35,7 +35,7 @@ std::string EncryptRequest::getEncryptionContext()const
void EncryptRequest::setEncryptionContext(const std::string& encryptionContext)
{
encryptionContext_ = encryptionContext;
setCoreParameter("EncryptionContext", encryptionContext);
setParameter("EncryptionContext", encryptionContext);
}
std::string EncryptRequest::getKeyId()const
@@ -46,7 +46,7 @@ std::string EncryptRequest::getKeyId()const
void EncryptRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}
std::string EncryptRequest::getPlaintext()const
@@ -57,6 +57,6 @@ std::string EncryptRequest::getPlaintext()const
void EncryptRequest::setPlaintext(const std::string& plaintext)
{
plaintext_ = plaintext;
setCoreParameter("Plaintext", plaintext);
setParameter("Plaintext", plaintext);
}

10
kms/src/model/GenerateDataKeyRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::GenerateDataKeyRequest;
GenerateDataKeyRequest::GenerateDataKeyRequest() :
RpcServiceRequest("kms", "2016-01-20", "GenerateDataKey")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
GenerateDataKeyRequest::~GenerateDataKeyRequest()
@@ -35,7 +35,7 @@ std::string GenerateDataKeyRequest::getEncryptionContext()const
void GenerateDataKeyRequest::setEncryptionContext(const std::string& encryptionContext)
{
encryptionContext_ = encryptionContext;
setCoreParameter("EncryptionContext", encryptionContext);
setParameter("EncryptionContext", encryptionContext);
}
std::string GenerateDataKeyRequest::getKeyId()const
@@ -46,7 +46,7 @@ std::string GenerateDataKeyRequest::getKeyId()const
void GenerateDataKeyRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}
std::string GenerateDataKeyRequest::getKeySpec()const
@@ -57,7 +57,7 @@ std::string GenerateDataKeyRequest::getKeySpec()const
void GenerateDataKeyRequest::setKeySpec(const std::string& keySpec)
{
keySpec_ = keySpec;
setCoreParameter("KeySpec", keySpec);
setParameter("KeySpec", keySpec);
}
int GenerateDataKeyRequest::getNumberOfBytes()const
@@ -68,6 +68,6 @@ int GenerateDataKeyRequest::getNumberOfBytes()const
void GenerateDataKeyRequest::setNumberOfBytes(int numberOfBytes)
{
numberOfBytes_ = numberOfBytes;
setCoreParameter("NumberOfBytes", std::to_string(numberOfBytes));
setParameter("NumberOfBytes", std::to_string(numberOfBytes));
}

10
kms/src/model/GenerateDataKeyWithoutPlaintextRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::GenerateDataKeyWithoutPlaintextRequest;
GenerateDataKeyWithoutPlaintextRequest::GenerateDataKeyWithoutPlaintextRequest() :
RpcServiceRequest("kms", "2016-01-20", "GenerateDataKeyWithoutPlaintext")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
GenerateDataKeyWithoutPlaintextRequest::~GenerateDataKeyWithoutPlaintextRequest()
@@ -35,7 +35,7 @@ std::string GenerateDataKeyWithoutPlaintextRequest::getEncryptionContext()const
void GenerateDataKeyWithoutPlaintextRequest::setEncryptionContext(const std::string& encryptionContext)
{
encryptionContext_ = encryptionContext;
setCoreParameter("EncryptionContext", encryptionContext);
setParameter("EncryptionContext", encryptionContext);
}
std::string GenerateDataKeyWithoutPlaintextRequest::getKeyId()const
@@ -46,7 +46,7 @@ std::string GenerateDataKeyWithoutPlaintextRequest::getKeyId()const
void GenerateDataKeyWithoutPlaintextRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}
std::string GenerateDataKeyWithoutPlaintextRequest::getKeySpec()const
@@ -57,7 +57,7 @@ std::string GenerateDataKeyWithoutPlaintextRequest::getKeySpec()const
void GenerateDataKeyWithoutPlaintextRequest::setKeySpec(const std::string& keySpec)
{
keySpec_ = keySpec;
setCoreParameter("KeySpec", keySpec);
setParameter("KeySpec", keySpec);
}
int GenerateDataKeyWithoutPlaintextRequest::getNumberOfBytes()const
@@ -68,6 +68,6 @@ int GenerateDataKeyWithoutPlaintextRequest::getNumberOfBytes()const
void GenerateDataKeyWithoutPlaintextRequest::setNumberOfBytes(int numberOfBytes)
{
numberOfBytes_ = numberOfBytes;
setCoreParameter("NumberOfBytes", std::to_string(numberOfBytes));
setParameter("NumberOfBytes", std::to_string(numberOfBytes));
}

8
kms/src/model/GetParametersForImportRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::GetParametersForImportRequest;
GetParametersForImportRequest::GetParametersForImportRequest() :
RpcServiceRequest("kms", "2016-01-20", "GetParametersForImport")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
GetParametersForImportRequest::~GetParametersForImportRequest()
@@ -35,7 +35,7 @@ std::string GetParametersForImportRequest::getKeyId()const
void GetParametersForImportRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}
std::string GetParametersForImportRequest::getWrappingAlgorithm()const
@@ -46,7 +46,7 @@ std::string GetParametersForImportRequest::getWrappingAlgorithm()const
void GetParametersForImportRequest::setWrappingAlgorithm(const std::string& wrappingAlgorithm)
{
wrappingAlgorithm_ = wrappingAlgorithm;
setCoreParameter("WrappingAlgorithm", wrappingAlgorithm);
setParameter("WrappingAlgorithm", wrappingAlgorithm);
}
std::string GetParametersForImportRequest::getWrappingKeySpec()const
@@ -57,6 +57,6 @@ std::string GetParametersForImportRequest::getWrappingKeySpec()const
void GetParametersForImportRequest::setWrappingKeySpec(const std::string& wrappingKeySpec)
{
wrappingKeySpec_ = wrappingKeySpec;
setCoreParameter("WrappingKeySpec", wrappingKeySpec);
setParameter("WrappingKeySpec", wrappingKeySpec);
}

6
kms/src/model/GetPublicKeyRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::GetPublicKeyRequest;
GetPublicKeyRequest::GetPublicKeyRequest() :
RpcServiceRequest("kms", "2016-01-20", "GetPublicKey")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
GetPublicKeyRequest::~GetPublicKeyRequest()
@@ -35,7 +35,7 @@ std::string GetPublicKeyRequest::getKeyVersionId()const
void GetPublicKeyRequest::setKeyVersionId(const std::string& keyVersionId)
{
keyVersionId_ = keyVersionId;
setCoreParameter("KeyVersionId", keyVersionId);
setParameter("KeyVersionId", keyVersionId);
}
std::string GetPublicKeyRequest::getKeyId()const
@@ -46,6 +46,6 @@ std::string GetPublicKeyRequest::getKeyId()const
void GetPublicKeyRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}

106
kms/src/model/GetRandomPasswordRequest.cc Normal file
View File

@@ -0,0 +1,106 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/GetRandomPasswordRequest.h>
using AlibabaCloud::Kms::Model::GetRandomPasswordRequest;
GetRandomPasswordRequest::GetRandomPasswordRequest() :
RpcServiceRequest("kms", "2016-01-20", "GetRandomPassword")
{
setMethod(HttpRequest::Method::POST);
}
GetRandomPasswordRequest::~GetRandomPasswordRequest()
{}
std::string GetRandomPasswordRequest::getExcludeLowercase()const
{
return excludeLowercase_;
}
void GetRandomPasswordRequest::setExcludeLowercase(const std::string& excludeLowercase)
{
excludeLowercase_ = excludeLowercase;
setParameter("ExcludeLowercase", excludeLowercase);
}
std::string GetRandomPasswordRequest::getExcludeCharacters()const
{
return excludeCharacters_;
}
void GetRandomPasswordRequest::setExcludeCharacters(const std::string& excludeCharacters)
{
excludeCharacters_ = excludeCharacters;
setParameter("ExcludeCharacters", excludeCharacters);
}
std::string GetRandomPasswordRequest::getPasswordLength()const
{
return passwordLength_;
}
void GetRandomPasswordRequest::setPasswordLength(const std::string& passwordLength)
{
passwordLength_ = passwordLength;
setParameter("PasswordLength", passwordLength);
}
std::string GetRandomPasswordRequest::getExcludePunctuation()const
{
return excludePunctuation_;
}
void GetRandomPasswordRequest::setExcludePunctuation(const std::string& excludePunctuation)
{
excludePunctuation_ = excludePunctuation;
setParameter("ExcludePunctuation", excludePunctuation);
}
std::string GetRandomPasswordRequest::getExcludeUppercase()const
{
return excludeUppercase_;
}
void GetRandomPasswordRequest::setExcludeUppercase(const std::string& excludeUppercase)
{
excludeUppercase_ = excludeUppercase;
setParameter("ExcludeUppercase", excludeUppercase);
}
std::string GetRandomPasswordRequest::getRequireEachIncludedType()const
{
return requireEachIncludedType_;
}
void GetRandomPasswordRequest::setRequireEachIncludedType(const std::string& requireEachIncludedType)
{
requireEachIncludedType_ = requireEachIncludedType;
setParameter("RequireEachIncludedType", requireEachIncludedType);
}
std::string GetRandomPasswordRequest::getExcludeNumbers()const
{
return excludeNumbers_;
}
void GetRandomPasswordRequest::setExcludeNumbers(const std::string& excludeNumbers)
{
excludeNumbers_ = excludeNumbers;
setParameter("ExcludeNumbers", excludeNumbers);
}

51
kms/src/model/GetRandomPasswordResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/GetRandomPasswordResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
GetRandomPasswordResult::GetRandomPasswordResult() :
ServiceResult()
{}
GetRandomPasswordResult::GetRandomPasswordResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetRandomPasswordResult::~GetRandomPasswordResult()
{}
void GetRandomPasswordResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["RandomPassword"].isNull())
randomPassword_ = value["RandomPassword"].asString();
}
std::string GetRandomPasswordResult::getRandomPassword()const
{
return randomPassword_;
}

62
kms/src/model/GetSecretValueRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/GetSecretValueRequest.h>
using AlibabaCloud::Kms::Model::GetSecretValueRequest;
GetSecretValueRequest::GetSecretValueRequest() :
RpcServiceRequest("kms", "2016-01-20", "GetSecretValue")
{
setMethod(HttpRequest::Method::POST);
}
GetSecretValueRequest::~GetSecretValueRequest()
{}
std::string GetSecretValueRequest::getVersionId()const
{
return versionId_;
}
void GetSecretValueRequest::setVersionId(const std::string& versionId)
{
versionId_ = versionId;
setParameter("VersionId", versionId);
}
std::string GetSecretValueRequest::getVersionStage()const
{
return versionStage_;
}
void GetSecretValueRequest::setVersionStage(const std::string& versionStage)
{
versionStage_ = versionStage;
setParameter("VersionStage", versionStage);
}
std::string GetSecretValueRequest::getSecretName()const
{
return secretName_;
}
void GetSecretValueRequest::setSecretName(const std::string& secretName)
{
secretName_ = secretName;
setParameter("SecretName", secretName);
}

87
kms/src/model/GetSecretValueResult.cc Normal file
View File

@@ -0,0 +1,87 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/GetSecretValueResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
GetSecretValueResult::GetSecretValueResult() :
ServiceResult()
{}
GetSecretValueResult::GetSecretValueResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetSecretValueResult::~GetSecretValueResult()
{}
void GetSecretValueResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allVersionStages = value["VersionStages"]["VersionStage"];
for (const auto &item : allVersionStages)
versionStages_.push_back(item.asString());
if(!value["SecretName"].isNull())
secretName_ = value["SecretName"].asString();
if(!value["VersionId"].isNull())
versionId_ = value["VersionId"].asString();
if(!value["CreateTime"].isNull())
createTime_ = value["CreateTime"].asString();
if(!value["SecretData"].isNull())
secretData_ = value["SecretData"].asString();
if(!value["SecretDataType"].isNull())
secretDataType_ = value["SecretDataType"].asString();
}
std::string GetSecretValueResult::getSecretName()const
{
return secretName_;
}
std::string GetSecretValueResult::getVersionId()const
{
return versionId_;
}
std::string GetSecretValueResult::getCreateTime()const
{
return createTime_;
}
std::string GetSecretValueResult::getSecretDataType()const
{
return secretDataType_;
}
std::string GetSecretValueResult::getSecretData()const
{
return secretData_;
}
std::vector<std::string> GetSecretValueResult::getVersionStages()const
{
return versionStages_;
}

10
kms/src/model/ImportKeyMaterialRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::ImportKeyMaterialRequest;
ImportKeyMaterialRequest::ImportKeyMaterialRequest() :
RpcServiceRequest("kms", "2016-01-20", "ImportKeyMaterial")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
ImportKeyMaterialRequest::~ImportKeyMaterialRequest()
@@ -35,7 +35,7 @@ std::string ImportKeyMaterialRequest::getImportToken()const
void ImportKeyMaterialRequest::setImportToken(const std::string& importToken)
{
importToken_ = importToken;
setCoreParameter("ImportToken", importToken);
setParameter("ImportToken", importToken);
}
std::string ImportKeyMaterialRequest::getEncryptedKeyMaterial()const
@@ -46,7 +46,7 @@ std::string ImportKeyMaterialRequest::getEncryptedKeyMaterial()const
void ImportKeyMaterialRequest::setEncryptedKeyMaterial(const std::string& encryptedKeyMaterial)
{
encryptedKeyMaterial_ = encryptedKeyMaterial;
setCoreParameter("EncryptedKeyMaterial", encryptedKeyMaterial);
setParameter("EncryptedKeyMaterial", encryptedKeyMaterial);
}
long ImportKeyMaterialRequest::getKeyMaterialExpireUnix()const
@@ -57,7 +57,7 @@ long ImportKeyMaterialRequest::getKeyMaterialExpireUnix()const
void ImportKeyMaterialRequest::setKeyMaterialExpireUnix(long keyMaterialExpireUnix)
{
keyMaterialExpireUnix_ = keyMaterialExpireUnix;
setCoreParameter("KeyMaterialExpireUnix", std::to_string(keyMaterialExpireUnix));
setParameter("KeyMaterialExpireUnix", std::to_string(keyMaterialExpireUnix));
}
std::string ImportKeyMaterialRequest::getKeyId()const
@@ -68,6 +68,6 @@ std::string ImportKeyMaterialRequest::getKeyId()const
void ImportKeyMaterialRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}

8
kms/src/model/ListAliasesByKeyIdRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::ListAliasesByKeyIdRequest;
ListAliasesByKeyIdRequest::ListAliasesByKeyIdRequest() :
RpcServiceRequest("kms", "2016-01-20", "ListAliasesByKeyId")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
ListAliasesByKeyIdRequest::~ListAliasesByKeyIdRequest()
@@ -35,7 +35,7 @@ int ListAliasesByKeyIdRequest::getPageSize()const
void ListAliasesByKeyIdRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
setParameter("PageSize", std::to_string(pageSize));
}
std::string ListAliasesByKeyIdRequest::getKeyId()const
@@ -46,7 +46,7 @@ std::string ListAliasesByKeyIdRequest::getKeyId()const
void ListAliasesByKeyIdRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}
int ListAliasesByKeyIdRequest::getPageNumber()const
@@ -57,6 +57,6 @@ int ListAliasesByKeyIdRequest::getPageNumber()const
void ListAliasesByKeyIdRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setCoreParameter("PageNumber", std::to_string(pageNumber));
setParameter("PageNumber", std::to_string(pageNumber));
}

6
kms/src/model/ListAliasesRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::ListAliasesRequest;
ListAliasesRequest::ListAliasesRequest() :
RpcServiceRequest("kms", "2016-01-20", "ListAliases")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
ListAliasesRequest::~ListAliasesRequest()
@@ -35,7 +35,7 @@ int ListAliasesRequest::getPageSize()const
void ListAliasesRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
setParameter("PageSize", std::to_string(pageSize));
}
int ListAliasesRequest::getPageNumber()const
@@ -46,6 +46,6 @@ int ListAliasesRequest::getPageNumber()const
void ListAliasesRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setCoreParameter("PageNumber", std::to_string(pageNumber));
setParameter("PageNumber", std::to_string(pageNumber));
}

8
kms/src/model/ListKeyVersionsRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::ListKeyVersionsRequest;
ListKeyVersionsRequest::ListKeyVersionsRequest() :
RpcServiceRequest("kms", "2016-01-20", "ListKeyVersions")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
ListKeyVersionsRequest::~ListKeyVersionsRequest()
@@ -35,7 +35,7 @@ int ListKeyVersionsRequest::getPageSize()const
void ListKeyVersionsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
setParameter("PageSize", std::to_string(pageSize));
}
std::string ListKeyVersionsRequest::getKeyId()const
@@ -46,7 +46,7 @@ std::string ListKeyVersionsRequest::getKeyId()const
void ListKeyVersionsRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}
int ListKeyVersionsRequest::getPageNumber()const
@@ -57,6 +57,6 @@ int ListKeyVersionsRequest::getPageNumber()const
void ListKeyVersionsRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setCoreParameter("PageNumber", std::to_string(pageNumber));
setParameter("PageNumber", std::to_string(pageNumber));
}

6
kms/src/model/ListKeysRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::ListKeysRequest;
ListKeysRequest::ListKeysRequest() :
RpcServiceRequest("kms", "2016-01-20", "ListKeys")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
ListKeysRequest::~ListKeysRequest()
@@ -35,7 +35,7 @@ int ListKeysRequest::getPageSize()const
void ListKeysRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
setParameter("PageSize", std::to_string(pageSize));
}
int ListKeysRequest::getPageNumber()const
@@ -46,6 +46,6 @@ int ListKeysRequest::getPageNumber()const
void ListKeysRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setCoreParameter("PageNumber", std::to_string(pageNumber));
setParameter("PageNumber", std::to_string(pageNumber));
}

4
kms/src/model/ListResourceTagsRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::ListResourceTagsRequest;
ListResourceTagsRequest::ListResourceTagsRequest() :
RpcServiceRequest("kms", "2016-01-20", "ListResourceTags")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
ListResourceTagsRequest::~ListResourceTagsRequest()
@@ -35,6 +35,6 @@ std::string ListResourceTagsRequest::getKeyId()const
void ListResourceTagsRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}

73
kms/src/model/ListSecretVersionIdsRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/ListSecretVersionIdsRequest.h>
using AlibabaCloud::Kms::Model::ListSecretVersionIdsRequest;
ListSecretVersionIdsRequest::ListSecretVersionIdsRequest() :
RpcServiceRequest("kms", "2016-01-20", "ListSecretVersionIds")
{
setMethod(HttpRequest::Method::POST);
}
ListSecretVersionIdsRequest::~ListSecretVersionIdsRequest()
{}
std::string ListSecretVersionIdsRequest::getIncludeDeprecated()const
{
return includeDeprecated_;
}
void ListSecretVersionIdsRequest::setIncludeDeprecated(const std::string& includeDeprecated)
{
includeDeprecated_ = includeDeprecated;
setParameter("IncludeDeprecated", includeDeprecated);
}
int ListSecretVersionIdsRequest::getPageSize()const
{
return pageSize_;
}
void ListSecretVersionIdsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string ListSecretVersionIdsRequest::getSecretName()const
{
return secretName_;
}
void ListSecretVersionIdsRequest::setSecretName(const std::string& secretName)
{
secretName_ = secretName;
setParameter("SecretName", secretName);
}
int ListSecretVersionIdsRequest::getPageNumber()const
{
return pageNumber_;
}
void ListSecretVersionIdsRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}

90
kms/src/model/ListSecretVersionIdsResult.cc Normal file
View File

@@ -0,0 +1,90 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/ListSecretVersionIdsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
ListSecretVersionIdsResult::ListSecretVersionIdsResult() :
ServiceResult()
{}
ListSecretVersionIdsResult::ListSecretVersionIdsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListSecretVersionIdsResult::~ListSecretVersionIdsResult()
{}
void ListSecretVersionIdsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allVersionIdsNode = value["VersionIds"]["VersionId"];
for (auto valueVersionIdsVersionId : allVersionIdsNode)
{
VersionId versionIdsObject;
if(!valueVersionIdsVersionId["CreateTime"].isNull())
versionIdsObject.createTime = valueVersionIdsVersionId["CreateTime"].asString();
if(!valueVersionIdsVersionId["VersionId"].isNull())
versionIdsObject.versionId = valueVersionIdsVersionId["VersionId"].asString();
auto allVersionStages = value["VersionStages"]["VersionStage"];
for (auto value : allVersionStages)
versionIdsObject.versionStages.push_back(value.asString());
versionIds_.push_back(versionIdsObject);
}
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["SecretName"].isNull())
secretName_ = value["SecretName"].asString();
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
std::string ListSecretVersionIdsResult::getSecretName()const
{
return secretName_;
}
int ListSecretVersionIdsResult::getTotalCount()const
{
return totalCount_;
}
int ListSecretVersionIdsResult::getPageSize()const
{
return pageSize_;
}
int ListSecretVersionIdsResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<ListSecretVersionIdsResult::VersionId> ListSecretVersionIdsResult::getVersionIds()const
{
return versionIds_;
}

62
kms/src/model/ListSecretsRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/ListSecretsRequest.h>
using AlibabaCloud::Kms::Model::ListSecretsRequest;
ListSecretsRequest::ListSecretsRequest() :
RpcServiceRequest("kms", "2016-01-20", "ListSecrets")
{
setMethod(HttpRequest::Method::POST);
}
ListSecretsRequest::~ListSecretsRequest()
{}
int ListSecretsRequest::getPageSize()const
{
return pageSize_;
}
void ListSecretsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string ListSecretsRequest::getFetchTags()const
{
return fetchTags_;
}
void ListSecretsRequest::setFetchTags(const std::string& fetchTags)
{
fetchTags_ = fetchTags;
setParameter("FetchTags", fetchTags);
}
int ListSecretsRequest::getPageNumber()const
{
return pageNumber_;
}
void ListSecretsRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}

94
kms/src/model/ListSecretsResult.cc Normal file
View File

@@ -0,0 +1,94 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/ListSecretsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
ListSecretsResult::ListSecretsResult() :
ServiceResult()
{}
ListSecretsResult::ListSecretsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListSecretsResult::~ListSecretsResult()
{}
void ListSecretsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allSecretListNode = value["SecretList"]["Secret"];
for (auto valueSecretListSecret : allSecretListNode)
{
Secret secretListObject;
if(!valueSecretListSecret["SecretName"].isNull())
secretListObject.secretName = valueSecretListSecret["SecretName"].asString();
if(!valueSecretListSecret["CreateTime"].isNull())
secretListObject.createTime = valueSecretListSecret["CreateTime"].asString();
if(!valueSecretListSecret["UpdateTime"].isNull())
secretListObject.updateTime = valueSecretListSecret["UpdateTime"].asString();
if(!valueSecretListSecret["PlannedDeleteTime"].isNull())
secretListObject.plannedDeleteTime = valueSecretListSecret["PlannedDeleteTime"].asString();
auto allTagsNode = allSecretListNode["Tags"]["Tag"];
for (auto allSecretListNodeTagsTag : allTagsNode)
{
Secret::Tag tagsObject;
if(!allSecretListNodeTagsTag["TagKey"].isNull())
tagsObject.tagKey = allSecretListNodeTagsTag["TagKey"].asString();
if(!allSecretListNodeTagsTag["TagValue"].isNull())
tagsObject.tagValue = allSecretListNodeTagsTag["TagValue"].asString();
secretListObject.tags.push_back(tagsObject);
}
secretList_.push_back(secretListObject);
}
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
int ListSecretsResult::getTotalCount()const
{
return totalCount_;
}
std::vector<ListSecretsResult::Secret> ListSecretsResult::getSecretList()const
{
return secretList_;
}
int ListSecretsResult::getPageSize()const
{
return pageSize_;
}
int ListSecretsResult::getPageNumber()const
{
return pageNumber_;
}

84
kms/src/model/PutSecretValueRequest.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/PutSecretValueRequest.h>
using AlibabaCloud::Kms::Model::PutSecretValueRequest;
PutSecretValueRequest::PutSecretValueRequest() :
RpcServiceRequest("kms", "2016-01-20", "PutSecretValue")
{
setMethod(HttpRequest::Method::POST);
}
PutSecretValueRequest::~PutSecretValueRequest()
{}
std::string PutSecretValueRequest::getVersionId()const
{
return versionId_;
}
void PutSecretValueRequest::setVersionId(const std::string& versionId)
{
versionId_ = versionId;
setParameter("VersionId", versionId);
}
std::string PutSecretValueRequest::getVersionStages()const
{
return versionStages_;
}
void PutSecretValueRequest::setVersionStages(const std::string& versionStages)
{
versionStages_ = versionStages;
setParameter("VersionStages", versionStages);
}
std::string PutSecretValueRequest::getSecretData()const
{
return secretData_;
}
void PutSecretValueRequest::setSecretData(const std::string& secretData)
{
secretData_ = secretData;
setParameter("SecretData", secretData);
}
std::string PutSecretValueRequest::getSecretName()const
{
return secretName_;
}
void PutSecretValueRequest::setSecretName(const std::string& secretName)
{
secretName_ = secretName;
setParameter("SecretName", secretName);
}
std::string PutSecretValueRequest::getSecretDataType()const
{
return secretDataType_;
}
void PutSecretValueRequest::setSecretDataType(const std::string& secretDataType)
{
secretDataType_ = secretDataType;
setParameter("SecretDataType", secretDataType);
}

66
kms/src/model/PutSecretValueResult.cc Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/PutSecretValueResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
PutSecretValueResult::PutSecretValueResult() :
ServiceResult()
{}
PutSecretValueResult::PutSecretValueResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
PutSecretValueResult::~PutSecretValueResult()
{}
void PutSecretValueResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allVersionStages = value["VersionStages"]["VersionStage"];
for (const auto &item : allVersionStages)
versionStages_.push_back(item.asString());
if(!value["SecretName"].isNull())
secretName_ = value["SecretName"].asString();
if(!value["VersionId"].isNull())
versionId_ = value["VersionId"].asString();
}
std::string PutSecretValueResult::getSecretName()const
{
return secretName_;
}
std::string PutSecretValueResult::getVersionId()const
{
return versionId_;
}
std::vector<std::string> PutSecretValueResult::getVersionStages()const
{
return versionStages_;
}

40
kms/src/model/RestoreSecretRequest.cc Normal file
View File

@@ -0,0 +1,40 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/RestoreSecretRequest.h>
using AlibabaCloud::Kms::Model::RestoreSecretRequest;
RestoreSecretRequest::RestoreSecretRequest() :
RpcServiceRequest("kms", "2016-01-20", "RestoreSecret")
{
setMethod(HttpRequest::Method::POST);
}
RestoreSecretRequest::~RestoreSecretRequest()
{}
std::string RestoreSecretRequest::getSecretName()const
{
return secretName_;
}
void RestoreSecretRequest::setSecretName(const std::string& secretName)
{
secretName_ = secretName;
setParameter("SecretName", secretName);
}

51
kms/src/model/RestoreSecretResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/RestoreSecretResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
RestoreSecretResult::RestoreSecretResult() :
ServiceResult()
{}
RestoreSecretResult::RestoreSecretResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RestoreSecretResult::~RestoreSecretResult()
{}
void RestoreSecretResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["SecretName"].isNull())
secretName_ = value["SecretName"].asString();
}
std::string RestoreSecretResult::getSecretName()const
{
return secretName_;
}

6
kms/src/model/ScheduleKeyDeletionRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::ScheduleKeyDeletionRequest;
ScheduleKeyDeletionRequest::ScheduleKeyDeletionRequest() :
RpcServiceRequest("kms", "2016-01-20", "ScheduleKeyDeletion")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
ScheduleKeyDeletionRequest::~ScheduleKeyDeletionRequest()
@@ -35,7 +35,7 @@ int ScheduleKeyDeletionRequest::getPendingWindowInDays()const
void ScheduleKeyDeletionRequest::setPendingWindowInDays(int pendingWindowInDays)
{
pendingWindowInDays_ = pendingWindowInDays;
setCoreParameter("PendingWindowInDays", std::to_string(pendingWindowInDays));
setParameter("PendingWindowInDays", std::to_string(pendingWindowInDays));
}
std::string ScheduleKeyDeletionRequest::getKeyId()const
@@ -46,6 +46,6 @@ std::string ScheduleKeyDeletionRequest::getKeyId()const
void ScheduleKeyDeletionRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}

17
kms/src/model/TagResourceRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::TagResourceRequest;
TagResourceRequest::TagResourceRequest() :
RpcServiceRequest("kms", "2016-01-20", "TagResource")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
TagResourceRequest::~TagResourceRequest()
@@ -35,7 +35,18 @@ std::string TagResourceRequest::getKeyId()const
void TagResourceRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}
std::string TagResourceRequest::getSecretName()const
{
return secretName_;
}
void TagResourceRequest::setSecretName(const std::string& secretName)
{
secretName_ = secretName;
setParameter("SecretName", secretName);
}
std::string TagResourceRequest::getTags()const
@@ -46,6 +57,6 @@ std::string TagResourceRequest::getTags()const
void TagResourceRequest::setTags(const std::string& tags)
{
tags_ = tags;
setCoreParameter("Tags", tags);
setParameter("Tags", tags);
}

17
kms/src/model/UntagResourceRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::UntagResourceRequest;
UntagResourceRequest::UntagResourceRequest() :
RpcServiceRequest("kms", "2016-01-20", "UntagResource")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
UntagResourceRequest::~UntagResourceRequest()
@@ -35,7 +35,7 @@ std::string UntagResourceRequest::getTagKeys()const
void UntagResourceRequest::setTagKeys(const std::string& tagKeys)
{
tagKeys_ = tagKeys;
setCoreParameter("TagKeys", tagKeys);
setParameter("TagKeys", tagKeys);
}
std::string UntagResourceRequest::getKeyId()const
@@ -46,6 +46,17 @@ std::string UntagResourceRequest::getKeyId()const
void UntagResourceRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}
std::string UntagResourceRequest::getSecretName()const
{
return secretName_;
}
void UntagResourceRequest::setSecretName(const std::string& secretName)
{
secretName_ = secretName;
setParameter("SecretName", secretName);
}

7
kms/src/model/UntagResourceResult.cc
View File

@@ -39,13 +39,6 @@ void UntagResourceResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["KeyId"].isNull())
keyId_ = value["KeyId"].asString();
}
std::string UntagResourceResult::getKeyId()const
{
return keyId_;
}

6
kms/src/model/UpdateAliasRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::UpdateAliasRequest;
UpdateAliasRequest::UpdateAliasRequest() :
RpcServiceRequest("kms", "2016-01-20", "UpdateAlias")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
UpdateAliasRequest::~UpdateAliasRequest()
@@ -35,7 +35,7 @@ std::string UpdateAliasRequest::getAliasName()const
void UpdateAliasRequest::setAliasName(const std::string& aliasName)
{
aliasName_ = aliasName;
setCoreParameter("AliasName", aliasName);
setParameter("AliasName", aliasName);
}
std::string UpdateAliasRequest::getKeyId()const
@@ -46,6 +46,6 @@ std::string UpdateAliasRequest::getKeyId()const
void UpdateAliasRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}

6
kms/src/model/UpdateKeyDescriptionRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::UpdateKeyDescriptionRequest;
UpdateKeyDescriptionRequest::UpdateKeyDescriptionRequest() :
RpcServiceRequest("kms", "2016-01-20", "UpdateKeyDescription")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
UpdateKeyDescriptionRequest::~UpdateKeyDescriptionRequest()
@@ -35,7 +35,7 @@ std::string UpdateKeyDescriptionRequest::getKeyId()const
void UpdateKeyDescriptionRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}
std::string UpdateKeyDescriptionRequest::getDescription()const
@@ -46,6 +46,6 @@ std::string UpdateKeyDescriptionRequest::getDescription()const
void UpdateKeyDescriptionRequest::setDescription(const std::string& description)
{
description_ = description;
setCoreParameter("Description", description);
setParameter("Description", description);
}

8
kms/src/model/UpdateRotationPolicyRequest.cc
View File

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::UpdateRotationPolicyRequest;
UpdateRotationPolicyRequest::UpdateRotationPolicyRequest() :
RpcServiceRequest("kms", "2016-01-20", "UpdateRotationPolicy")
{
setMethod(HttpRequest::Method::Post);
setMethod(HttpRequest::Method::POST);
}
UpdateRotationPolicyRequest::~UpdateRotationPolicyRequest()
@@ -35,7 +35,7 @@ std::string UpdateRotationPolicyRequest::getKeyId()const
void UpdateRotationPolicyRequest::setKeyId(const std::string& keyId)
{
keyId_ = keyId;
setCoreParameter("KeyId", keyId);
setParameter("KeyId", keyId);
}
std::string UpdateRotationPolicyRequest::getRotationInterval()const
@@ -46,7 +46,7 @@ std::string UpdateRotationPolicyRequest::getRotationInterval()const
void UpdateRotationPolicyRequest::setRotationInterval(const std::string& rotationInterval)
{
rotationInterval_ = rotationInterval;
setCoreParameter("RotationInterval", rotationInterval);
setParameter("RotationInterval", rotationInterval);
}
bool UpdateRotationPolicyRequest::getEnableAutomaticRotation()const
@@ -57,6 +57,6 @@ bool UpdateRotationPolicyRequest::getEnableAutomaticRotation()const
void UpdateRotationPolicyRequest::setEnableAutomaticRotation(bool enableAutomaticRotation)
{
enableAutomaticRotation_ = enableAutomaticRotation;
setCoreParameter("EnableAutomaticRotation", enableAutomaticRotation ? "true" : "false");
setParameter("EnableAutomaticRotation", enableAutomaticRotation ? "true" : "false");
}

51
kms/src/model/UpdateSecretRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/UpdateSecretRequest.h>
using AlibabaCloud::Kms::Model::UpdateSecretRequest;
UpdateSecretRequest::UpdateSecretRequest() :
RpcServiceRequest("kms", "2016-01-20", "UpdateSecret")
{
setMethod(HttpRequest::Method::POST);
}
UpdateSecretRequest::~UpdateSecretRequest()
{}
std::string UpdateSecretRequest::getDescription()const
{
return description_;
}
void UpdateSecretRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
std::string UpdateSecretRequest::getSecretName()const
{
return secretName_;
}
void UpdateSecretRequest::setSecretName(const std::string& secretName)
{
secretName_ = secretName;
setParameter("SecretName", secretName);
}

51
kms/src/model/UpdateSecretResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/UpdateSecretResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
UpdateSecretResult::UpdateSecretResult() :
ServiceResult()
{}
UpdateSecretResult::UpdateSecretResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateSecretResult::~UpdateSecretResult()
{}
void UpdateSecretResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["SecretName"].isNull())
secretName_ = value["SecretName"].asString();
}
std::string UpdateSecretResult::getSecretName()const
{
return secretName_;
}

73
kms/src/model/UpdateSecretVersionStageRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/UpdateSecretVersionStageRequest.h>
using AlibabaCloud::Kms::Model::UpdateSecretVersionStageRequest;
UpdateSecretVersionStageRequest::UpdateSecretVersionStageRequest() :
RpcServiceRequest("kms", "2016-01-20", "UpdateSecretVersionStage")
{
setMethod(HttpRequest::Method::POST);
}
UpdateSecretVersionStageRequest::~UpdateSecretVersionStageRequest()
{}
std::string UpdateSecretVersionStageRequest::getRemoveFromVersion()const
{
return removeFromVersion_;
}
void UpdateSecretVersionStageRequest::setRemoveFromVersion(const std::string& removeFromVersion)
{
removeFromVersion_ = removeFromVersion;
setParameter("RemoveFromVersion", removeFromVersion);
}
std::string UpdateSecretVersionStageRequest::getMoveToVersion()const
{
return moveToVersion_;
}
void UpdateSecretVersionStageRequest::setMoveToVersion(const std::string& moveToVersion)
{
moveToVersion_ = moveToVersion;
setParameter("MoveToVersion", moveToVersion);
}
std::string UpdateSecretVersionStageRequest::getVersionStage()const
{
return versionStage_;
}
void UpdateSecretVersionStageRequest::setVersionStage(const std::string& versionStage)
{
versionStage_ = versionStage;
setParameter("VersionStage", versionStage);
}
std::string UpdateSecretVersionStageRequest::getSecretName()const
{
return secretName_;
}
void UpdateSecretVersionStageRequest::setSecretName(const std::string& secretName)
{
secretName_ = secretName;
setParameter("SecretName", secretName);
}

51
kms/src/model/UpdateSecretVersionStageResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/kms/model/UpdateSecretVersionStageResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
UpdateSecretVersionStageResult::UpdateSecretVersionStageResult() :
ServiceResult()
{}
UpdateSecretVersionStageResult::UpdateSecretVersionStageResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateSecretVersionStageResult::~UpdateSecretVersionStageResult()
{}
void UpdateSecretVersionStageResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["SecretName"].isNull())
secretName_ = value["SecretName"].asString();
}
std::string UpdateSecretVersionStageResult::getSecretName()const
{
return secretName_;
}