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

Add Certificate Manager Api.

Browse Source
This commit is contained in:
sdk-team
2020-11-27 02:44:58 +00:00
parent 8fdebda354
commit 3c991c9ca9
65 changed files with 4105 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
kms/CMakeLists.txt
View File

@@ -31,8 +31,18 @@ set(kms_public_header_model
include/alibabacloud/kms/model/AsymmetricVerifyResult.h
include/alibabacloud/kms/model/CancelKeyDeletionRequest.h
include/alibabacloud/kms/model/CancelKeyDeletionResult.h
include/alibabacloud/kms/model/CertificatePrivateKeyDecryptRequest.h
include/alibabacloud/kms/model/CertificatePrivateKeyDecryptResult.h
include/alibabacloud/kms/model/CertificatePrivateKeySignRequest.h
include/alibabacloud/kms/model/CertificatePrivateKeySignResult.h
include/alibabacloud/kms/model/CertificatePublicKeyEncryptRequest.h
include/alibabacloud/kms/model/CertificatePublicKeyEncryptResult.h
include/alibabacloud/kms/model/CertificatePublicKeyVerifyRequest.h
include/alibabacloud/kms/model/CertificatePublicKeyVerifyResult.h
include/alibabacloud/kms/model/CreateAliasRequest.h
include/alibabacloud/kms/model/CreateAliasResult.h
include/alibabacloud/kms/model/CreateCertificateRequest.h
include/alibabacloud/kms/model/CreateCertificateResult.h
include/alibabacloud/kms/model/CreateKeyRequest.h
include/alibabacloud/kms/model/CreateKeyResult.h
include/alibabacloud/kms/model/CreateKeyVersionRequest.h
@@ -43,12 +53,16 @@ set(kms_public_header_model
include/alibabacloud/kms/model/DecryptResult.h
include/alibabacloud/kms/model/DeleteAliasRequest.h
include/alibabacloud/kms/model/DeleteAliasResult.h
include/alibabacloud/kms/model/DeleteCertificateRequest.h
include/alibabacloud/kms/model/DeleteCertificateResult.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/DescribeAccountKmsStatusRequest.h
include/alibabacloud/kms/model/DescribeAccountKmsStatusResult.h
include/alibabacloud/kms/model/DescribeCertificateRequest.h
include/alibabacloud/kms/model/DescribeCertificateResult.h
include/alibabacloud/kms/model/DescribeKeyRequest.h
include/alibabacloud/kms/model/DescribeKeyResult.h
include/alibabacloud/kms/model/DescribeKeyVersionRequest.h
@@ -65,6 +79,8 @@ set(kms_public_header_model
include/alibabacloud/kms/model/EnableKeyResult.h
include/alibabacloud/kms/model/EncryptRequest.h
include/alibabacloud/kms/model/EncryptResult.h
include/alibabacloud/kms/model/ExportCertificateRequest.h
include/alibabacloud/kms/model/ExportCertificateResult.h
include/alibabacloud/kms/model/ExportDataKeyRequest.h
include/alibabacloud/kms/model/ExportDataKeyResult.h
include/alibabacloud/kms/model/GenerateAndExportDataKeyRequest.h
@@ -73,6 +89,8 @@ set(kms_public_header_model
include/alibabacloud/kms/model/GenerateDataKeyResult.h
include/alibabacloud/kms/model/GenerateDataKeyWithoutPlaintextRequest.h
include/alibabacloud/kms/model/GenerateDataKeyWithoutPlaintextResult.h
include/alibabacloud/kms/model/GetCertificateRequest.h
include/alibabacloud/kms/model/GetCertificateResult.h
include/alibabacloud/kms/model/GetParametersForImportRequest.h
include/alibabacloud/kms/model/GetParametersForImportResult.h
include/alibabacloud/kms/model/GetPublicKeyRequest.h
@@ -81,12 +99,18 @@ set(kms_public_header_model
include/alibabacloud/kms/model/GetRandomPasswordResult.h
include/alibabacloud/kms/model/GetSecretValueRequest.h
include/alibabacloud/kms/model/GetSecretValueResult.h
include/alibabacloud/kms/model/ImportCertificateRequest.h
include/alibabacloud/kms/model/ImportCertificateResult.h
include/alibabacloud/kms/model/ImportEncryptionCertificateRequest.h
include/alibabacloud/kms/model/ImportEncryptionCertificateResult.h
include/alibabacloud/kms/model/ImportKeyMaterialRequest.h
include/alibabacloud/kms/model/ImportKeyMaterialResult.h
include/alibabacloud/kms/model/ListAliasesRequest.h
include/alibabacloud/kms/model/ListAliasesResult.h
include/alibabacloud/kms/model/ListAliasesByKeyIdRequest.h
include/alibabacloud/kms/model/ListAliasesByKeyIdResult.h
include/alibabacloud/kms/model/ListCertificatesRequest.h
include/alibabacloud/kms/model/ListCertificatesResult.h
include/alibabacloud/kms/model/ListKeyVersionsRequest.h
include/alibabacloud/kms/model/ListKeyVersionsResult.h
include/alibabacloud/kms/model/ListKeysRequest.h
@@ -113,6 +137,8 @@ set(kms_public_header_model
include/alibabacloud/kms/model/UntagResourceResult.h
include/alibabacloud/kms/model/UpdateAliasRequest.h
include/alibabacloud/kms/model/UpdateAliasResult.h
include/alibabacloud/kms/model/UpdateCertificateStatusRequest.h
include/alibabacloud/kms/model/UpdateCertificateStatusResult.h
include/alibabacloud/kms/model/UpdateKeyDescriptionRequest.h
include/alibabacloud/kms/model/UpdateKeyDescriptionResult.h
include/alibabacloud/kms/model/UpdateRotationPolicyRequest.h
@@ -120,7 +146,9 @@ set(kms_public_header_model
include/alibabacloud/kms/model/UpdateSecretRequest.h
include/alibabacloud/kms/model/UpdateSecretResult.h
include/alibabacloud/kms/model/UpdateSecretVersionStageRequest.h
include/alibabacloud/kms/model/UpdateSecretVersionStageResult.h )
include/alibabacloud/kms/model/UpdateSecretVersionStageResult.h
include/alibabacloud/kms/model/UploadCertificateRequest.h
include/alibabacloud/kms/model/UploadCertificateResult.h )
set(kms_src
src/KmsClient.cc
@@ -134,8 +162,18 @@ set(kms_src
src/model/AsymmetricVerifyResult.cc
src/model/CancelKeyDeletionRequest.cc
src/model/CancelKeyDeletionResult.cc
src/model/CertificatePrivateKeyDecryptRequest.cc
src/model/CertificatePrivateKeyDecryptResult.cc
src/model/CertificatePrivateKeySignRequest.cc
src/model/CertificatePrivateKeySignResult.cc
src/model/CertificatePublicKeyEncryptRequest.cc
src/model/CertificatePublicKeyEncryptResult.cc
src/model/CertificatePublicKeyVerifyRequest.cc
src/model/CertificatePublicKeyVerifyResult.cc
src/model/CreateAliasRequest.cc
src/model/CreateAliasResult.cc
src/model/CreateCertificateRequest.cc
src/model/CreateCertificateResult.cc
src/model/CreateKeyRequest.cc
src/model/CreateKeyResult.cc
src/model/CreateKeyVersionRequest.cc
@@ -146,12 +184,16 @@ set(kms_src
src/model/DecryptResult.cc
src/model/DeleteAliasRequest.cc
src/model/DeleteAliasResult.cc
src/model/DeleteCertificateRequest.cc
src/model/DeleteCertificateResult.cc
src/model/DeleteKeyMaterialRequest.cc
src/model/DeleteKeyMaterialResult.cc
src/model/DeleteSecretRequest.cc
src/model/DeleteSecretResult.cc
src/model/DescribeAccountKmsStatusRequest.cc
src/model/DescribeAccountKmsStatusResult.cc
src/model/DescribeCertificateRequest.cc
src/model/DescribeCertificateResult.cc
src/model/DescribeKeyRequest.cc
src/model/DescribeKeyResult.cc
src/model/DescribeKeyVersionRequest.cc
@@ -168,6 +210,8 @@ set(kms_src
src/model/EnableKeyResult.cc
src/model/EncryptRequest.cc
src/model/EncryptResult.cc
src/model/ExportCertificateRequest.cc
src/model/ExportCertificateResult.cc
src/model/ExportDataKeyRequest.cc
src/model/ExportDataKeyResult.cc
src/model/GenerateAndExportDataKeyRequest.cc
@@ -176,6 +220,8 @@ set(kms_src
src/model/GenerateDataKeyResult.cc
src/model/GenerateDataKeyWithoutPlaintextRequest.cc
src/model/GenerateDataKeyWithoutPlaintextResult.cc
src/model/GetCertificateRequest.cc
src/model/GetCertificateResult.cc
src/model/GetParametersForImportRequest.cc
src/model/GetParametersForImportResult.cc
src/model/GetPublicKeyRequest.cc
@@ -184,12 +230,18 @@ set(kms_src
src/model/GetRandomPasswordResult.cc
src/model/GetSecretValueRequest.cc
src/model/GetSecretValueResult.cc
src/model/ImportCertificateRequest.cc
src/model/ImportCertificateResult.cc
src/model/ImportEncryptionCertificateRequest.cc
src/model/ImportEncryptionCertificateResult.cc
src/model/ImportKeyMaterialRequest.cc
src/model/ImportKeyMaterialResult.cc
src/model/ListAliasesRequest.cc
src/model/ListAliasesResult.cc
src/model/ListAliasesByKeyIdRequest.cc
src/model/ListAliasesByKeyIdResult.cc
src/model/ListCertificatesRequest.cc
src/model/ListCertificatesResult.cc
src/model/ListKeyVersionsRequest.cc
src/model/ListKeyVersionsResult.cc
src/model/ListKeysRequest.cc
@@ -216,6 +268,8 @@ set(kms_src
src/model/UntagResourceResult.cc
src/model/UpdateAliasRequest.cc
src/model/UpdateAliasResult.cc
src/model/UpdateCertificateStatusRequest.cc
src/model/UpdateCertificateStatusResult.cc
src/model/UpdateKeyDescriptionRequest.cc
src/model/UpdateKeyDescriptionResult.cc
src/model/UpdateRotationPolicyRequest.cc
@@ -223,7 +277,9 @@ set(kms_src
src/model/UpdateSecretRequest.cc
src/model/UpdateSecretResult.cc
src/model/UpdateSecretVersionStageRequest.cc
src/model/UpdateSecretVersionStageResult.cc )
src/model/UpdateSecretVersionStageResult.cc
src/model/UploadCertificateRequest.cc
src/model/UploadCertificateResult.cc )
add_library(kms ${LIB_TYPE}
${kms_public_header}

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

@@ -32,8 +32,18 @@
#include "model/AsymmetricVerifyResult.h"
#include "model/CancelKeyDeletionRequest.h"
#include "model/CancelKeyDeletionResult.h"
#include "model/CertificatePrivateKeyDecryptRequest.h"
#include "model/CertificatePrivateKeyDecryptResult.h"
#include "model/CertificatePrivateKeySignRequest.h"
#include "model/CertificatePrivateKeySignResult.h"
#include "model/CertificatePublicKeyEncryptRequest.h"
#include "model/CertificatePublicKeyEncryptResult.h"
#include "model/CertificatePublicKeyVerifyRequest.h"
#include "model/CertificatePublicKeyVerifyResult.h"
#include "model/CreateAliasRequest.h"
#include "model/CreateAliasResult.h"
#include "model/CreateCertificateRequest.h"
#include "model/CreateCertificateResult.h"
#include "model/CreateKeyRequest.h"
#include "model/CreateKeyResult.h"
#include "model/CreateKeyVersionRequest.h"
@@ -44,12 +54,16 @@
#include "model/DecryptResult.h"
#include "model/DeleteAliasRequest.h"
#include "model/DeleteAliasResult.h"
#include "model/DeleteCertificateRequest.h"
#include "model/DeleteCertificateResult.h"
#include "model/DeleteKeyMaterialRequest.h"
#include "model/DeleteKeyMaterialResult.h"
#include "model/DeleteSecretRequest.h"
#include "model/DeleteSecretResult.h"
#include "model/DescribeAccountKmsStatusRequest.h"
#include "model/DescribeAccountKmsStatusResult.h"
#include "model/DescribeCertificateRequest.h"
#include "model/DescribeCertificateResult.h"
#include "model/DescribeKeyRequest.h"
#include "model/DescribeKeyResult.h"
#include "model/DescribeKeyVersionRequest.h"
@@ -66,6 +80,8 @@
#include "model/EnableKeyResult.h"
#include "model/EncryptRequest.h"
#include "model/EncryptResult.h"
#include "model/ExportCertificateRequest.h"
#include "model/ExportCertificateResult.h"
#include "model/ExportDataKeyRequest.h"
#include "model/ExportDataKeyResult.h"
#include "model/GenerateAndExportDataKeyRequest.h"
@@ -74,6 +90,8 @@
#include "model/GenerateDataKeyResult.h"
#include "model/GenerateDataKeyWithoutPlaintextRequest.h"
#include "model/GenerateDataKeyWithoutPlaintextResult.h"
#include "model/GetCertificateRequest.h"
#include "model/GetCertificateResult.h"
#include "model/GetParametersForImportRequest.h"
#include "model/GetParametersForImportResult.h"
#include "model/GetPublicKeyRequest.h"
@@ -82,12 +100,18 @@
#include "model/GetRandomPasswordResult.h"
#include "model/GetSecretValueRequest.h"
#include "model/GetSecretValueResult.h"
#include "model/ImportCertificateRequest.h"
#include "model/ImportCertificateResult.h"
#include "model/ImportEncryptionCertificateRequest.h"
#include "model/ImportEncryptionCertificateResult.h"
#include "model/ImportKeyMaterialRequest.h"
#include "model/ImportKeyMaterialResult.h"
#include "model/ListAliasesRequest.h"
#include "model/ListAliasesResult.h"
#include "model/ListAliasesByKeyIdRequest.h"
#include "model/ListAliasesByKeyIdResult.h"
#include "model/ListCertificatesRequest.h"
#include "model/ListCertificatesResult.h"
#include "model/ListKeyVersionsRequest.h"
#include "model/ListKeyVersionsResult.h"
#include "model/ListKeysRequest.h"
@@ -114,6 +138,8 @@
#include "model/UntagResourceResult.h"
#include "model/UpdateAliasRequest.h"
#include "model/UpdateAliasResult.h"
#include "model/UpdateCertificateStatusRequest.h"
#include "model/UpdateCertificateStatusResult.h"
#include "model/UpdateKeyDescriptionRequest.h"
#include "model/UpdateKeyDescriptionResult.h"
#include "model/UpdateRotationPolicyRequest.h"
@@ -122,6 +148,8 @@
#include "model/UpdateSecretResult.h"
#include "model/UpdateSecretVersionStageRequest.h"
#include "model/UpdateSecretVersionStageResult.h"
#include "model/UploadCertificateRequest.h"
#include "model/UploadCertificateResult.h"
namespace AlibabaCloud
@@ -146,9 +174,24 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CancelKeyDeletionResult> CancelKeyDeletionOutcome;
typedef std::future<CancelKeyDeletionOutcome> CancelKeyDeletionOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::CancelKeyDeletionRequest&, const CancelKeyDeletionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelKeyDeletionAsyncHandler;
typedef Outcome<Error, Model::CertificatePrivateKeyDecryptResult> CertificatePrivateKeyDecryptOutcome;
typedef std::future<CertificatePrivateKeyDecryptOutcome> CertificatePrivateKeyDecryptOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::CertificatePrivateKeyDecryptRequest&, const CertificatePrivateKeyDecryptOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CertificatePrivateKeyDecryptAsyncHandler;
typedef Outcome<Error, Model::CertificatePrivateKeySignResult> CertificatePrivateKeySignOutcome;
typedef std::future<CertificatePrivateKeySignOutcome> CertificatePrivateKeySignOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::CertificatePrivateKeySignRequest&, const CertificatePrivateKeySignOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CertificatePrivateKeySignAsyncHandler;
typedef Outcome<Error, Model::CertificatePublicKeyEncryptResult> CertificatePublicKeyEncryptOutcome;
typedef std::future<CertificatePublicKeyEncryptOutcome> CertificatePublicKeyEncryptOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::CertificatePublicKeyEncryptRequest&, const CertificatePublicKeyEncryptOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CertificatePublicKeyEncryptAsyncHandler;
typedef Outcome<Error, Model::CertificatePublicKeyVerifyResult> CertificatePublicKeyVerifyOutcome;
typedef std::future<CertificatePublicKeyVerifyOutcome> CertificatePublicKeyVerifyOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::CertificatePublicKeyVerifyRequest&, const CertificatePublicKeyVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CertificatePublicKeyVerifyAsyncHandler;
typedef Outcome<Error, Model::CreateAliasResult> CreateAliasOutcome;
typedef std::future<CreateAliasOutcome> CreateAliasOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::CreateAliasRequest&, const CreateAliasOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAliasAsyncHandler;
typedef Outcome<Error, Model::CreateCertificateResult> CreateCertificateOutcome;
typedef std::future<CreateCertificateOutcome> CreateCertificateOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::CreateCertificateRequest&, const CreateCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCertificateAsyncHandler;
typedef Outcome<Error, Model::CreateKeyResult> CreateKeyOutcome;
typedef std::future<CreateKeyOutcome> CreateKeyOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::CreateKeyRequest&, const CreateKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateKeyAsyncHandler;
@@ -164,6 +207,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteAliasResult> DeleteAliasOutcome;
typedef std::future<DeleteAliasOutcome> DeleteAliasOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::DeleteAliasRequest&, const DeleteAliasOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAliasAsyncHandler;
typedef Outcome<Error, Model::DeleteCertificateResult> DeleteCertificateOutcome;
typedef std::future<DeleteCertificateOutcome> DeleteCertificateOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::DeleteCertificateRequest&, const DeleteCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCertificateAsyncHandler;
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;
@@ -173,6 +219,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeAccountKmsStatusResult> DescribeAccountKmsStatusOutcome;
typedef std::future<DescribeAccountKmsStatusOutcome> DescribeAccountKmsStatusOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::DescribeAccountKmsStatusRequest&, const DescribeAccountKmsStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountKmsStatusAsyncHandler;
typedef Outcome<Error, Model::DescribeCertificateResult> DescribeCertificateOutcome;
typedef std::future<DescribeCertificateOutcome> DescribeCertificateOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::DescribeCertificateRequest&, const DescribeCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCertificateAsyncHandler;
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;
@@ -197,6 +246,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::EncryptResult> EncryptOutcome;
typedef std::future<EncryptOutcome> EncryptOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::EncryptRequest&, const EncryptOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EncryptAsyncHandler;
typedef Outcome<Error, Model::ExportCertificateResult> ExportCertificateOutcome;
typedef std::future<ExportCertificateOutcome> ExportCertificateOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ExportCertificateRequest&, const ExportCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExportCertificateAsyncHandler;
typedef Outcome<Error, Model::ExportDataKeyResult> ExportDataKeyOutcome;
typedef std::future<ExportDataKeyOutcome> ExportDataKeyOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ExportDataKeyRequest&, const ExportDataKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExportDataKeyAsyncHandler;
@@ -209,6 +261,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::GenerateDataKeyWithoutPlaintextResult> GenerateDataKeyWithoutPlaintextOutcome;
typedef std::future<GenerateDataKeyWithoutPlaintextOutcome> GenerateDataKeyWithoutPlaintextOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::GenerateDataKeyWithoutPlaintextRequest&, const GenerateDataKeyWithoutPlaintextOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateDataKeyWithoutPlaintextAsyncHandler;
typedef Outcome<Error, Model::GetCertificateResult> GetCertificateOutcome;
typedef std::future<GetCertificateOutcome> GetCertificateOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::GetCertificateRequest&, const GetCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetCertificateAsyncHandler;
typedef Outcome<Error, Model::GetParametersForImportResult> GetParametersForImportOutcome;
typedef std::future<GetParametersForImportOutcome> GetParametersForImportOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::GetParametersForImportRequest&, const GetParametersForImportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetParametersForImportAsyncHandler;
@@ -221,6 +276,12 @@ namespace AlibabaCloud
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::ImportCertificateResult> ImportCertificateOutcome;
typedef std::future<ImportCertificateOutcome> ImportCertificateOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ImportCertificateRequest&, const ImportCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImportCertificateAsyncHandler;
typedef Outcome<Error, Model::ImportEncryptionCertificateResult> ImportEncryptionCertificateOutcome;
typedef std::future<ImportEncryptionCertificateOutcome> ImportEncryptionCertificateOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ImportEncryptionCertificateRequest&, const ImportEncryptionCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImportEncryptionCertificateAsyncHandler;
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;
@@ -230,6 +291,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ListAliasesByKeyIdResult> ListAliasesByKeyIdOutcome;
typedef std::future<ListAliasesByKeyIdOutcome> ListAliasesByKeyIdOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ListAliasesByKeyIdRequest&, const ListAliasesByKeyIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAliasesByKeyIdAsyncHandler;
typedef Outcome<Error, Model::ListCertificatesResult> ListCertificatesOutcome;
typedef std::future<ListCertificatesOutcome> ListCertificatesOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ListCertificatesRequest&, const ListCertificatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCertificatesAsyncHandler;
typedef Outcome<Error, Model::ListKeyVersionsResult> ListKeyVersionsOutcome;
typedef std::future<ListKeyVersionsOutcome> ListKeyVersionsOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ListKeyVersionsRequest&, const ListKeyVersionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListKeyVersionsAsyncHandler;
@@ -269,6 +333,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::UpdateAliasResult> UpdateAliasOutcome;
typedef std::future<UpdateAliasOutcome> UpdateAliasOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::UpdateAliasRequest&, const UpdateAliasOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAliasAsyncHandler;
typedef Outcome<Error, Model::UpdateCertificateStatusResult> UpdateCertificateStatusOutcome;
typedef std::future<UpdateCertificateStatusOutcome> UpdateCertificateStatusOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::UpdateCertificateStatusRequest&, const UpdateCertificateStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateCertificateStatusAsyncHandler;
typedef Outcome<Error, Model::UpdateKeyDescriptionResult> UpdateKeyDescriptionOutcome;
typedef std::future<UpdateKeyDescriptionOutcome> UpdateKeyDescriptionOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::UpdateKeyDescriptionRequest&, const UpdateKeyDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateKeyDescriptionAsyncHandler;
@@ -281,6 +348,9 @@ namespace AlibabaCloud
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;
typedef Outcome<Error, Model::UploadCertificateResult> UploadCertificateOutcome;
typedef std::future<UploadCertificateOutcome> UploadCertificateOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::UploadCertificateRequest&, const UploadCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UploadCertificateAsyncHandler;
KmsClient(const Credentials &credentials, const ClientConfiguration &configuration);
KmsClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -301,9 +371,24 @@ namespace AlibabaCloud
CancelKeyDeletionOutcome cancelKeyDeletion(const Model::CancelKeyDeletionRequest &request)const;
void cancelKeyDeletionAsync(const Model::CancelKeyDeletionRequest& request, const CancelKeyDeletionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CancelKeyDeletionOutcomeCallable cancelKeyDeletionCallable(const Model::CancelKeyDeletionRequest& request) const;
CertificatePrivateKeyDecryptOutcome certificatePrivateKeyDecrypt(const Model::CertificatePrivateKeyDecryptRequest &request)const;
void certificatePrivateKeyDecryptAsync(const Model::CertificatePrivateKeyDecryptRequest& request, const CertificatePrivateKeyDecryptAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CertificatePrivateKeyDecryptOutcomeCallable certificatePrivateKeyDecryptCallable(const Model::CertificatePrivateKeyDecryptRequest& request) const;
CertificatePrivateKeySignOutcome certificatePrivateKeySign(const Model::CertificatePrivateKeySignRequest &request)const;
void certificatePrivateKeySignAsync(const Model::CertificatePrivateKeySignRequest& request, const CertificatePrivateKeySignAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CertificatePrivateKeySignOutcomeCallable certificatePrivateKeySignCallable(const Model::CertificatePrivateKeySignRequest& request) const;
CertificatePublicKeyEncryptOutcome certificatePublicKeyEncrypt(const Model::CertificatePublicKeyEncryptRequest &request)const;
void certificatePublicKeyEncryptAsync(const Model::CertificatePublicKeyEncryptRequest& request, const CertificatePublicKeyEncryptAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CertificatePublicKeyEncryptOutcomeCallable certificatePublicKeyEncryptCallable(const Model::CertificatePublicKeyEncryptRequest& request) const;
CertificatePublicKeyVerifyOutcome certificatePublicKeyVerify(const Model::CertificatePublicKeyVerifyRequest &request)const;
void certificatePublicKeyVerifyAsync(const Model::CertificatePublicKeyVerifyRequest& request, const CertificatePublicKeyVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CertificatePublicKeyVerifyOutcomeCallable certificatePublicKeyVerifyCallable(const Model::CertificatePublicKeyVerifyRequest& request) const;
CreateAliasOutcome createAlias(const Model::CreateAliasRequest &request)const;
void createAliasAsync(const Model::CreateAliasRequest& request, const CreateAliasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateAliasOutcomeCallable createAliasCallable(const Model::CreateAliasRequest& request) const;
CreateCertificateOutcome createCertificate(const Model::CreateCertificateRequest &request)const;
void createCertificateAsync(const Model::CreateCertificateRequest& request, const CreateCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateCertificateOutcomeCallable createCertificateCallable(const Model::CreateCertificateRequest& request) const;
CreateKeyOutcome createKey(const Model::CreateKeyRequest &request)const;
void createKeyAsync(const Model::CreateKeyRequest& request, const CreateKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateKeyOutcomeCallable createKeyCallable(const Model::CreateKeyRequest& request) const;
@@ -319,6 +404,9 @@ namespace AlibabaCloud
DeleteAliasOutcome deleteAlias(const Model::DeleteAliasRequest &request)const;
void deleteAliasAsync(const Model::DeleteAliasRequest& request, const DeleteAliasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteAliasOutcomeCallable deleteAliasCallable(const Model::DeleteAliasRequest& request) const;
DeleteCertificateOutcome deleteCertificate(const Model::DeleteCertificateRequest &request)const;
void deleteCertificateAsync(const Model::DeleteCertificateRequest& request, const DeleteCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteCertificateOutcomeCallable deleteCertificateCallable(const Model::DeleteCertificateRequest& request) const;
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;
@@ -328,6 +416,9 @@ namespace AlibabaCloud
DescribeAccountKmsStatusOutcome describeAccountKmsStatus(const Model::DescribeAccountKmsStatusRequest &request)const;
void describeAccountKmsStatusAsync(const Model::DescribeAccountKmsStatusRequest& request, const DescribeAccountKmsStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAccountKmsStatusOutcomeCallable describeAccountKmsStatusCallable(const Model::DescribeAccountKmsStatusRequest& request) const;
DescribeCertificateOutcome describeCertificate(const Model::DescribeCertificateRequest &request)const;
void describeCertificateAsync(const Model::DescribeCertificateRequest& request, const DescribeCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCertificateOutcomeCallable describeCertificateCallable(const Model::DescribeCertificateRequest& 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;
@@ -352,6 +443,9 @@ namespace AlibabaCloud
EncryptOutcome encrypt(const Model::EncryptRequest &request)const;
void encryptAsync(const Model::EncryptRequest& request, const EncryptAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EncryptOutcomeCallable encryptCallable(const Model::EncryptRequest& request) const;
ExportCertificateOutcome exportCertificate(const Model::ExportCertificateRequest &request)const;
void exportCertificateAsync(const Model::ExportCertificateRequest& request, const ExportCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExportCertificateOutcomeCallable exportCertificateCallable(const Model::ExportCertificateRequest& request) const;
ExportDataKeyOutcome exportDataKey(const Model::ExportDataKeyRequest &request)const;
void exportDataKeyAsync(const Model::ExportDataKeyRequest& request, const ExportDataKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExportDataKeyOutcomeCallable exportDataKeyCallable(const Model::ExportDataKeyRequest& request) const;
@@ -364,6 +458,9 @@ namespace AlibabaCloud
GenerateDataKeyWithoutPlaintextOutcome generateDataKeyWithoutPlaintext(const Model::GenerateDataKeyWithoutPlaintextRequest &request)const;
void generateDataKeyWithoutPlaintextAsync(const Model::GenerateDataKeyWithoutPlaintextRequest& request, const GenerateDataKeyWithoutPlaintextAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GenerateDataKeyWithoutPlaintextOutcomeCallable generateDataKeyWithoutPlaintextCallable(const Model::GenerateDataKeyWithoutPlaintextRequest& request) const;
GetCertificateOutcome getCertificate(const Model::GetCertificateRequest &request)const;
void getCertificateAsync(const Model::GetCertificateRequest& request, const GetCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetCertificateOutcomeCallable getCertificateCallable(const Model::GetCertificateRequest& request) const;
GetParametersForImportOutcome getParametersForImport(const Model::GetParametersForImportRequest &request)const;
void getParametersForImportAsync(const Model::GetParametersForImportRequest& request, const GetParametersForImportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetParametersForImportOutcomeCallable getParametersForImportCallable(const Model::GetParametersForImportRequest& request) const;
@@ -376,6 +473,12 @@ namespace AlibabaCloud
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;
ImportCertificateOutcome importCertificate(const Model::ImportCertificateRequest &request)const;
void importCertificateAsync(const Model::ImportCertificateRequest& request, const ImportCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImportCertificateOutcomeCallable importCertificateCallable(const Model::ImportCertificateRequest& request) const;
ImportEncryptionCertificateOutcome importEncryptionCertificate(const Model::ImportEncryptionCertificateRequest &request)const;
void importEncryptionCertificateAsync(const Model::ImportEncryptionCertificateRequest& request, const ImportEncryptionCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImportEncryptionCertificateOutcomeCallable importEncryptionCertificateCallable(const Model::ImportEncryptionCertificateRequest& 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;
@@ -385,6 +488,9 @@ namespace AlibabaCloud
ListAliasesByKeyIdOutcome listAliasesByKeyId(const Model::ListAliasesByKeyIdRequest &request)const;
void listAliasesByKeyIdAsync(const Model::ListAliasesByKeyIdRequest& request, const ListAliasesByKeyIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListAliasesByKeyIdOutcomeCallable listAliasesByKeyIdCallable(const Model::ListAliasesByKeyIdRequest& request) const;
ListCertificatesOutcome listCertificates(const Model::ListCertificatesRequest &request)const;
void listCertificatesAsync(const Model::ListCertificatesRequest& request, const ListCertificatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListCertificatesOutcomeCallable listCertificatesCallable(const Model::ListCertificatesRequest& request) const;
ListKeyVersionsOutcome listKeyVersions(const Model::ListKeyVersionsRequest &request)const;
void listKeyVersionsAsync(const Model::ListKeyVersionsRequest& request, const ListKeyVersionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListKeyVersionsOutcomeCallable listKeyVersionsCallable(const Model::ListKeyVersionsRequest& request) const;
@@ -424,6 +530,9 @@ namespace AlibabaCloud
UpdateAliasOutcome updateAlias(const Model::UpdateAliasRequest &request)const;
void updateAliasAsync(const Model::UpdateAliasRequest& request, const UpdateAliasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateAliasOutcomeCallable updateAliasCallable(const Model::UpdateAliasRequest& request) const;
UpdateCertificateStatusOutcome updateCertificateStatus(const Model::UpdateCertificateStatusRequest &request)const;
void updateCertificateStatusAsync(const Model::UpdateCertificateStatusRequest& request, const UpdateCertificateStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateCertificateStatusOutcomeCallable updateCertificateStatusCallable(const Model::UpdateCertificateStatusRequest& request) const;
UpdateKeyDescriptionOutcome updateKeyDescription(const Model::UpdateKeyDescriptionRequest &request)const;
void updateKeyDescriptionAsync(const Model::UpdateKeyDescriptionRequest& request, const UpdateKeyDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateKeyDescriptionOutcomeCallable updateKeyDescriptionCallable(const Model::UpdateKeyDescriptionRequest& request) const;
@@ -436,6 +545,9 @@ namespace AlibabaCloud
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;
UploadCertificateOutcome uploadCertificate(const Model::UploadCertificateRequest &request)const;
void uploadCertificateAsync(const Model::UploadCertificateRequest& request, const UploadCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UploadCertificateOutcomeCallable uploadCertificateCallable(const Model::UploadCertificateRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;

54
kms/include/alibabacloud/kms/model/CertificatePrivateKeyDecryptRequest.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_CERTIFICATEPRIVATEKEYDECRYPTREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYDECRYPTREQUEST_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 CertificatePrivateKeyDecryptRequest : public RpcServiceRequest
{
public:
CertificatePrivateKeyDecryptRequest();
~CertificatePrivateKeyDecryptRequest();
std::string getCertificateId()const;
void setCertificateId(const std::string& certificateId);
std::string getAlgorithm()const;
void setAlgorithm(const std::string& algorithm);
std::string getCiphertextBlob()const;
void setCiphertextBlob(const std::string& ciphertextBlob);
private:
std::string certificateId_;
std::string algorithm_;
std::string ciphertextBlob_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYDECRYPTREQUEST_H_

53
kms/include/alibabacloud/kms/model/CertificatePrivateKeyDecryptResult.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_CERTIFICATEPRIVATEKEYDECRYPTRESULT_H_
#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYDECRYPTRESULT_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 CertificatePrivateKeyDecryptResult : public ServiceResult
{
public:
CertificatePrivateKeyDecryptResult();
explicit CertificatePrivateKeyDecryptResult(const std::string &payload);
~CertificatePrivateKeyDecryptResult();
std::string getCertificateId()const;
std::string getPlaintext()const;
protected:
void parse(const std::string &payload);
private:
std::string certificateId_;
std::string plaintext_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYDECRYPTRESULT_H_

57
kms/include/alibabacloud/kms/model/CertificatePrivateKeySignRequest.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_CERTIFICATEPRIVATEKEYSIGNREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYSIGNREQUEST_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 CertificatePrivateKeySignRequest : public RpcServiceRequest
{
public:
CertificatePrivateKeySignRequest();
~CertificatePrivateKeySignRequest();
std::string getMessageType()const;
void setMessageType(const std::string& messageType);
std::string getCertificateId()const;
void setCertificateId(const std::string& certificateId);
std::string getMessage()const;
void setMessage(const std::string& message);
std::string getAlgorithm()const;
void setAlgorithm(const std::string& algorithm);
private:
std::string messageType_;
std::string certificateId_;
std::string message_;
std::string algorithm_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYSIGNREQUEST_H_

53
kms/include/alibabacloud/kms/model/CertificatePrivateKeySignResult.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_CERTIFICATEPRIVATEKEYSIGNRESULT_H_
#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYSIGNRESULT_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 CertificatePrivateKeySignResult : public ServiceResult
{
public:
CertificatePrivateKeySignResult();
explicit CertificatePrivateKeySignResult(const std::string &payload);
~CertificatePrivateKeySignResult();
std::string getSignatureValue()const;
std::string getCertificateId()const;
protected:
void parse(const std::string &payload);
private:
std::string signatureValue_;
std::string certificateId_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYSIGNRESULT_H_

54
kms/include/alibabacloud/kms/model/CertificatePublicKeyEncryptRequest.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_CERTIFICATEPUBLICKEYENCRYPTREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYENCRYPTREQUEST_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 CertificatePublicKeyEncryptRequest : public RpcServiceRequest
{
public:
CertificatePublicKeyEncryptRequest();
~CertificatePublicKeyEncryptRequest();
std::string getCertificateId()const;
void setCertificateId(const std::string& certificateId);
std::string getPlaintext()const;
void setPlaintext(const std::string& plaintext);
std::string getAlgorithm()const;
void setAlgorithm(const std::string& algorithm);
private:
std::string certificateId_;
std::string plaintext_;
std::string algorithm_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYENCRYPTREQUEST_H_

53
kms/include/alibabacloud/kms/model/CertificatePublicKeyEncryptResult.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_CERTIFICATEPUBLICKEYENCRYPTRESULT_H_
#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYENCRYPTRESULT_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 CertificatePublicKeyEncryptResult : public ServiceResult
{
public:
CertificatePublicKeyEncryptResult();
explicit CertificatePublicKeyEncryptResult(const std::string &payload);
~CertificatePublicKeyEncryptResult();
std::string getCertificateId()const;
std::string getCiphertextBlob()const;
protected:
void parse(const std::string &payload);
private:
std::string certificateId_;
std::string ciphertextBlob_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYENCRYPTRESULT_H_

60
kms/include/alibabacloud/kms/model/CertificatePublicKeyVerifyRequest.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_CERTIFICATEPUBLICKEYVERIFYREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYVERIFYREQUEST_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 CertificatePublicKeyVerifyRequest : public RpcServiceRequest
{
public:
CertificatePublicKeyVerifyRequest();
~CertificatePublicKeyVerifyRequest();
std::string getSignatureValue()const;
void setSignatureValue(const std::string& signatureValue);
std::string getMessageType()const;
void setMessageType(const std::string& messageType);
std::string getCertificateId()const;
void setCertificateId(const std::string& certificateId);
std::string getMessage()const;
void setMessage(const std::string& message);
std::string getAlgorithm()const;
void setAlgorithm(const std::string& algorithm);
private:
std::string signatureValue_;
std::string messageType_;
std::string certificateId_;
std::string message_;
std::string algorithm_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYVERIFYREQUEST_H_

53
kms/include/alibabacloud/kms/model/CertificatePublicKeyVerifyResult.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_CERTIFICATEPUBLICKEYVERIFYRESULT_H_
#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYVERIFYRESULT_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 CertificatePublicKeyVerifyResult : public ServiceResult
{
public:
CertificatePublicKeyVerifyResult();
explicit CertificatePublicKeyVerifyResult(const std::string &payload);
~CertificatePublicKeyVerifyResult();
std::string getCertificateId()const;
bool getSignatureValid()const;
protected:
void parse(const std::string &payload);
private:
std::string certificateId_;
bool signatureValid_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYVERIFYRESULT_H_

57
kms/include/alibabacloud/kms/model/CreateCertificateRequest.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_CREATECERTIFICATEREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_CREATECERTIFICATEREQUEST_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 CreateCertificateRequest : public RpcServiceRequest
{
public:
CreateCertificateRequest();
~CreateCertificateRequest();
std::string getProtectionLevel()const;
void setProtectionLevel(const std::string& protectionLevel);
std::string getSubject()const;
void setSubject(const std::string& subject);
std::map<std::string, std::string> getSubjectAlternativeNames()const;
void setSubjectAlternativeNames(const std::map<std::string, std::string>& subjectAlternativeNames);
std::string getKeySpec()const;
void setKeySpec(const std::string& keySpec);
private:
std::string protectionLevel_;
std::string subject_;
std::map<std::string, std::string> subjectAlternativeNames_;
std::string keySpec_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_CREATECERTIFICATEREQUEST_H_

55
kms/include/alibabacloud/kms/model/CreateCertificateResult.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_CREATECERTIFICATERESULT_H_
#define ALIBABACLOUD_KMS_MODEL_CREATECERTIFICATERESULT_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 CreateCertificateResult : public ServiceResult
{
public:
CreateCertificateResult();
explicit CreateCertificateResult(const std::string &payload);
~CreateCertificateResult();
std::string getCsr()const;
std::string getCertificateId()const;
std::string getArn()const;
protected:
void parse(const std::string &payload);
private:
std::string csr_;
std::string certificateId_;
std::string arn_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_CREATECERTIFICATERESULT_H_

48
kms/include/alibabacloud/kms/model/DeleteCertificateRequest.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_DELETECERTIFICATEREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_DELETECERTIFICATEREQUEST_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 DeleteCertificateRequest : public RpcServiceRequest
{
public:
DeleteCertificateRequest();
~DeleteCertificateRequest();
std::string getCertificateId()const;
void setCertificateId(const std::string& certificateId);
private:
std::string certificateId_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_DELETECERTIFICATEREQUEST_H_

49
kms/include/alibabacloud/kms/model/DeleteCertificateResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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_DELETECERTIFICATERESULT_H_
#define ALIBABACLOUD_KMS_MODEL_DELETECERTIFICATERESULT_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 DeleteCertificateResult : public ServiceResult
{
public:
DeleteCertificateResult();
explicit DeleteCertificateResult(const std::string &payload);
~DeleteCertificateResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_DELETECERTIFICATERESULT_H_

48
kms/include/alibabacloud/kms/model/DescribeCertificateRequest.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_DESCRIBECERTIFICATEREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_DESCRIBECERTIFICATEREQUEST_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 DescribeCertificateRequest : public RpcServiceRequest
{
public:
DescribeCertificateRequest();
~DescribeCertificateRequest();
std::string getCertificateId()const;
void setCertificateId(const std::string& certificateId);
private:
std::string certificateId_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_DESCRIBECERTIFICATEREQUEST_H_

83
kms/include/alibabacloud/kms/model/DescribeCertificateResult.h Normal file
View File

@@ -0,0 +1,83 @@
/*
* 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_DESCRIBECERTIFICATERESULT_H_
#define ALIBABACLOUD_KMS_MODEL_DESCRIBECERTIFICATERESULT_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 DescribeCertificateResult : public ServiceResult
{
public:
DescribeCertificateResult();
explicit DescribeCertificateResult(const std::string &payload);
~DescribeCertificateResult();
std::string getStatus()const;
std::string getProtectionLevel()const;
std::string getIssuer()const;
std::string getCertificateId()const;
std::string getKeySpec()const;
std::string getCreatedAt()const;
std::vector<std::string> getSubjectAlternativeNames()const;
std::string getSignatureAlgorithm()const;
std::string getSubjectKeyIdentifier()const;
std::string getNotAfter()const;
std::string getUpdatedAt()const;
std::string getSubject()const;
std::string getSerial()const;
std::string getSubjectPublicKey()const;
std::string getArn()const;
std::string getNotBefore()const;
std::string getTags()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
std::string protectionLevel_;
std::string issuer_;
std::string certificateId_;
std::string keySpec_;
std::string createdAt_;
std::vector<std::string> subjectAlternativeNames_;
std::string signatureAlgorithm_;
std::string subjectKeyIdentifier_;
std::string notAfter_;
std::string updatedAt_;
std::string subject_;
std::string serial_;
std::string subjectPublicKey_;
std::string arn_;
std::string notBefore_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_DESCRIBECERTIFICATERESULT_H_

54
kms/include/alibabacloud/kms/model/ExportCertificateRequest.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_EXPORTCERTIFICATEREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_EXPORTCERTIFICATEREQUEST_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 ExportCertificateRequest : public RpcServiceRequest
{
public:
ExportCertificateRequest();
~ExportCertificateRequest();
std::string getCertificateId()const;
void setCertificateId(const std::string& certificateId);
std::string getPassphrase()const;
void setPassphrase(const std::string& passphrase);
std::string getExportFormat()const;
void setExportFormat(const std::string& exportFormat);
private:
std::string certificateId_;
std::string passphrase_;
std::string exportFormat_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_EXPORTCERTIFICATEREQUEST_H_

59
kms/include/alibabacloud/kms/model/ExportCertificateResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* 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_EXPORTCERTIFICATERESULT_H_
#define ALIBABACLOUD_KMS_MODEL_EXPORTCERTIFICATERESULT_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 ExportCertificateResult : public ServiceResult
{
public:
ExportCertificateResult();
explicit ExportCertificateResult(const std::string &payload);
~ExportCertificateResult();
std::string getPrivateKey()const;
std::string getCertificateId()const;
std::string getCertificateChain()const;
std::string getPKCS12Blob()const;
std::string getCertificate()const;
protected:
void parse(const std::string &payload);
private:
std::string privateKey_;
std::string certificateId_;
std::string certificateChain_;
std::string pKCS12Blob_;
std::string certificate_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_EXPORTCERTIFICATERESULT_H_

48
kms/include/alibabacloud/kms/model/GetCertificateRequest.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_GETCERTIFICATEREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_GETCERTIFICATEREQUEST_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 GetCertificateRequest : public RpcServiceRequest
{
public:
GetCertificateRequest();
~GetCertificateRequest();
std::string getCertificateId()const;
void setCertificateId(const std::string& certificateId);
private:
std::string certificateId_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_GETCERTIFICATEREQUEST_H_

57
kms/include/alibabacloud/kms/model/GetCertificateResult.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_GETCERTIFICATERESULT_H_
#define ALIBABACLOUD_KMS_MODEL_GETCERTIFICATERESULT_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 GetCertificateResult : public ServiceResult
{
public:
GetCertificateResult();
explicit GetCertificateResult(const std::string &payload);
~GetCertificateResult();
std::string getCsr()const;
std::string getCertificateId()const;
std::string getCertificateChain()const;
std::string getCertificate()const;
protected:
void parse(const std::string &payload);
private:
std::string csr_;
std::string certificateId_;
std::string certificateChain_;
std::string certificate_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_GETCERTIFICATERESULT_H_

51
kms/include/alibabacloud/kms/model/ImportCertificateRequest.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_IMPORTCERTIFICATEREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_IMPORTCERTIFICATEREQUEST_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 ImportCertificateRequest : public RpcServiceRequest
{
public:
ImportCertificateRequest();
~ImportCertificateRequest();
std::string getPKCS12Blob()const;
void setPKCS12Blob(const std::string& pKCS12Blob);
std::string getPassphrase()const;
void setPassphrase(const std::string& passphrase);
private:
std::string pKCS12Blob_;
std::string passphrase_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_IMPORTCERTIFICATEREQUEST_H_

53
kms/include/alibabacloud/kms/model/ImportCertificateResult.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_IMPORTCERTIFICATERESULT_H_
#define ALIBABACLOUD_KMS_MODEL_IMPORTCERTIFICATERESULT_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 ImportCertificateResult : public ServiceResult
{
public:
ImportCertificateResult();
explicit ImportCertificateResult(const std::string &payload);
~ImportCertificateResult();
std::string getCertificateId()const;
std::string getArn()const;
protected:
void parse(const std::string &payload);
private:
std::string certificateId_;
std::string arn_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_IMPORTCERTIFICATERESULT_H_

66
kms/include/alibabacloud/kms/model/ImportEncryptionCertificateRequest.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_IMPORTENCRYPTIONCERTIFICATEREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_IMPORTENCRYPTIONCERTIFICATEREQUEST_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 ImportEncryptionCertificateRequest : public RpcServiceRequest
{
public:
ImportEncryptionCertificateRequest();
~ImportEncryptionCertificateRequest();
std::string getAsymmetricAlgorithm()const;
void setAsymmetricAlgorithm(const std::string& asymmetricAlgorithm);
std::string getSymmetricAlgorithm()const;
void setSymmetricAlgorithm(const std::string& symmetricAlgorithm);
std::string getEncryptedPrivateKey()const;
void setEncryptedPrivateKey(const std::string& encryptedPrivateKey);
std::string getEncryptedSymmetricKey()const;
void setEncryptedSymmetricKey(const std::string& encryptedSymmetricKey);
std::string getCertificateId()const;
void setCertificateId(const std::string& certificateId);
std::string getCertificate()const;
void setCertificate(const std::string& certificate);
std::string getCertificateChain()const;
void setCertificateChain(const std::string& certificateChain);
private:
std::string asymmetricAlgorithm_;
std::string symmetricAlgorithm_;
std::string encryptedPrivateKey_;
std::string encryptedSymmetricKey_;
std::string certificateId_;
std::string certificate_;
std::string certificateChain_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_IMPORTENCRYPTIONCERTIFICATEREQUEST_H_

53
kms/include/alibabacloud/kms/model/ImportEncryptionCertificateResult.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_IMPORTENCRYPTIONCERTIFICATERESULT_H_
#define ALIBABACLOUD_KMS_MODEL_IMPORTENCRYPTIONCERTIFICATERESULT_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 ImportEncryptionCertificateResult : public ServiceResult
{
public:
ImportEncryptionCertificateResult();
explicit ImportEncryptionCertificateResult(const std::string &payload);
~ImportEncryptionCertificateResult();
std::string getCertificateId()const;
std::string getArn()const;
protected:
void parse(const std::string &payload);
private:
std::string certificateId_;
std::string arn_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_IMPORTENCRYPTIONCERTIFICATERESULT_H_

60
kms/include/alibabacloud/kms/model/ListCertificatesRequest.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_LISTCERTIFICATESREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_LISTCERTIFICATESREQUEST_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 ListCertificatesRequest : public RpcServiceRequest
{
public:
ListCertificatesRequest();
~ListCertificatesRequest();
std::string getSubject()const;
void setSubject(const std::string& subject);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getIssuer()const;
void setIssuer(const std::string& issuer);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getStatus()const;
void setStatus(const std::string& status);
private:
std::string subject_;
int pageSize_;
std::string issuer_;
int pageNumber_;
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_LISTCERTIFICATESREQUEST_H_

68
kms/include/alibabacloud/kms/model/ListCertificatesResult.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* 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_LISTCERTIFICATESRESULT_H_
#define ALIBABACLOUD_KMS_MODEL_LISTCERTIFICATESRESULT_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 ListCertificatesResult : public ServiceResult
{
public:
struct CertificateSummary
{
std::string status;
std::string protectionLevel;
std::string issuer;
std::string certificateId;
std::string keySpec;
std::string notBefore;
std::string notAfter;
std::string subject;
};
ListCertificatesResult();
explicit ListCertificatesResult(const std::string &payload);
~ListCertificatesResult();
int getPageSize()const;
int getPageNumber()const;
std::vector<CertificateSummary> getCertificateSummaryList()const;
int getTotalSize()const;
protected:
void parse(const std::string &payload);
private:
int pageSize_;
int pageNumber_;
std::vector<CertificateSummary> certificateSummaryList_;
int totalSize_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_LISTCERTIFICATESRESULT_H_

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

@@ -35,6 +35,8 @@ namespace AlibabaCloud
TagResourceRequest();
~TagResourceRequest();
std::string getCertificateId()const;
void setCertificateId(const std::string& certificateId);
std::string getKeyId()const;
void setKeyId(const std::string& keyId);
std::string getSecretName()const;
@@ -43,6 +45,7 @@ namespace AlibabaCloud
void setTags(const std::string& tags);
private:
std::string certificateId_;
std::string keyId_;
std::string secretName_;
std::string tags_;

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

@@ -35,6 +35,8 @@ namespace AlibabaCloud
UntagResourceRequest();
~UntagResourceRequest();
std::string getCertificateId()const;
void setCertificateId(const std::string& certificateId);
std::string getTagKeys()const;
void setTagKeys(const std::string& tagKeys);
std::string getKeyId()const;
@@ -43,6 +45,7 @@ namespace AlibabaCloud
void setSecretName(const std::string& secretName);
private:
std::string certificateId_;
std::string tagKeys_;
std::string keyId_;
std::string secretName_;

51
kms/include/alibabacloud/kms/model/UpdateCertificateStatusRequest.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_UPDATECERTIFICATESTATUSREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_UPDATECERTIFICATESTATUSREQUEST_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 UpdateCertificateStatusRequest : public RpcServiceRequest
{
public:
UpdateCertificateStatusRequest();
~UpdateCertificateStatusRequest();
std::string getCertificateId()const;
void setCertificateId(const std::string& certificateId);
std::string getStatus()const;
void setStatus(const std::string& status);
private:
std::string certificateId_;
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_UPDATECERTIFICATESTATUSREQUEST_H_

49
kms/include/alibabacloud/kms/model/UpdateCertificateStatusResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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_UPDATECERTIFICATESTATUSRESULT_H_
#define ALIBABACLOUD_KMS_MODEL_UPDATECERTIFICATESTATUSRESULT_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 UpdateCertificateStatusResult : public ServiceResult
{
public:
UpdateCertificateStatusResult();
explicit UpdateCertificateStatusResult(const std::string &payload);
~UpdateCertificateStatusResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_UPDATECERTIFICATESTATUSRESULT_H_

54
kms/include/alibabacloud/kms/model/UploadCertificateRequest.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_UPLOADCERTIFICATEREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_UPLOADCERTIFICATEREQUEST_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 UploadCertificateRequest : public RpcServiceRequest
{
public:
UploadCertificateRequest();
~UploadCertificateRequest();
std::string getCertificateId()const;
void setCertificateId(const std::string& certificateId);
std::string getCertificate()const;
void setCertificate(const std::string& certificate);
std::string getCertificateChain()const;
void setCertificateChain(const std::string& certificateChain);
private:
std::string certificateId_;
std::string certificate_;
std::string certificateChain_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_UPLOADCERTIFICATEREQUEST_H_

49
kms/include/alibabacloud/kms/model/UploadCertificateResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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_UPLOADCERTIFICATERESULT_H_
#define ALIBABACLOUD_KMS_MODEL_UPLOADCERTIFICATERESULT_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 UploadCertificateResult : public ServiceResult
{
public:
UploadCertificateResult();
explicit UploadCertificateResult(const std::string &payload);
~UploadCertificateResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_UPLOADCERTIFICATERESULT_H_

510
kms/src/KmsClient.cc
View File

@@ -31,21 +31,21 @@ KmsClient::KmsClient(const Credentials &credentials, const ClientConfiguration &
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "kms");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "kms-service");
}
KmsClient::KmsClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "kms");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "kms-service");
}
KmsClient::KmsClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "kms");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "kms-service");
}
KmsClient::~KmsClient()
@@ -231,6 +231,150 @@ KmsClient::CancelKeyDeletionOutcomeCallable KmsClient::cancelKeyDeletionCallable
return task->get_future();
}
KmsClient::CertificatePrivateKeyDecryptOutcome KmsClient::certificatePrivateKeyDecrypt(const CertificatePrivateKeyDecryptRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CertificatePrivateKeyDecryptOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CertificatePrivateKeyDecryptOutcome(CertificatePrivateKeyDecryptResult(outcome.result()));
else
return CertificatePrivateKeyDecryptOutcome(outcome.error());
}
void KmsClient::certificatePrivateKeyDecryptAsync(const CertificatePrivateKeyDecryptRequest& request, const CertificatePrivateKeyDecryptAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, certificatePrivateKeyDecrypt(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::CertificatePrivateKeyDecryptOutcomeCallable KmsClient::certificatePrivateKeyDecryptCallable(const CertificatePrivateKeyDecryptRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CertificatePrivateKeyDecryptOutcome()>>(
[this, request]()
{
return this->certificatePrivateKeyDecrypt(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::CertificatePrivateKeySignOutcome KmsClient::certificatePrivateKeySign(const CertificatePrivateKeySignRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CertificatePrivateKeySignOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CertificatePrivateKeySignOutcome(CertificatePrivateKeySignResult(outcome.result()));
else
return CertificatePrivateKeySignOutcome(outcome.error());
}
void KmsClient::certificatePrivateKeySignAsync(const CertificatePrivateKeySignRequest& request, const CertificatePrivateKeySignAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, certificatePrivateKeySign(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::CertificatePrivateKeySignOutcomeCallable KmsClient::certificatePrivateKeySignCallable(const CertificatePrivateKeySignRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CertificatePrivateKeySignOutcome()>>(
[this, request]()
{
return this->certificatePrivateKeySign(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::CertificatePublicKeyEncryptOutcome KmsClient::certificatePublicKeyEncrypt(const CertificatePublicKeyEncryptRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CertificatePublicKeyEncryptOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CertificatePublicKeyEncryptOutcome(CertificatePublicKeyEncryptResult(outcome.result()));
else
return CertificatePublicKeyEncryptOutcome(outcome.error());
}
void KmsClient::certificatePublicKeyEncryptAsync(const CertificatePublicKeyEncryptRequest& request, const CertificatePublicKeyEncryptAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, certificatePublicKeyEncrypt(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::CertificatePublicKeyEncryptOutcomeCallable KmsClient::certificatePublicKeyEncryptCallable(const CertificatePublicKeyEncryptRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CertificatePublicKeyEncryptOutcome()>>(
[this, request]()
{
return this->certificatePublicKeyEncrypt(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::CertificatePublicKeyVerifyOutcome KmsClient::certificatePublicKeyVerify(const CertificatePublicKeyVerifyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CertificatePublicKeyVerifyOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CertificatePublicKeyVerifyOutcome(CertificatePublicKeyVerifyResult(outcome.result()));
else
return CertificatePublicKeyVerifyOutcome(outcome.error());
}
void KmsClient::certificatePublicKeyVerifyAsync(const CertificatePublicKeyVerifyRequest& request, const CertificatePublicKeyVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, certificatePublicKeyVerify(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::CertificatePublicKeyVerifyOutcomeCallable KmsClient::certificatePublicKeyVerifyCallable(const CertificatePublicKeyVerifyRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CertificatePublicKeyVerifyOutcome()>>(
[this, request]()
{
return this->certificatePublicKeyVerify(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::CreateAliasOutcome KmsClient::createAlias(const CreateAliasRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -267,6 +411,42 @@ KmsClient::CreateAliasOutcomeCallable KmsClient::createAliasCallable(const Creat
return task->get_future();
}
KmsClient::CreateCertificateOutcome KmsClient::createCertificate(const CreateCertificateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateCertificateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateCertificateOutcome(CreateCertificateResult(outcome.result()));
else
return CreateCertificateOutcome(outcome.error());
}
void KmsClient::createCertificateAsync(const CreateCertificateRequest& request, const CreateCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createCertificate(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::CreateCertificateOutcomeCallable KmsClient::createCertificateCallable(const CreateCertificateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateCertificateOutcome()>>(
[this, request]()
{
return this->createCertificate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::CreateKeyOutcome KmsClient::createKey(const CreateKeyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -447,6 +627,42 @@ KmsClient::DeleteAliasOutcomeCallable KmsClient::deleteAliasCallable(const Delet
return task->get_future();
}
KmsClient::DeleteCertificateOutcome KmsClient::deleteCertificate(const DeleteCertificateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteCertificateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteCertificateOutcome(DeleteCertificateResult(outcome.result()));
else
return DeleteCertificateOutcome(outcome.error());
}
void KmsClient::deleteCertificateAsync(const DeleteCertificateRequest& request, const DeleteCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteCertificate(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::DeleteCertificateOutcomeCallable KmsClient::deleteCertificateCallable(const DeleteCertificateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteCertificateOutcome()>>(
[this, request]()
{
return this->deleteCertificate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::DeleteKeyMaterialOutcome KmsClient::deleteKeyMaterial(const DeleteKeyMaterialRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -555,6 +771,42 @@ KmsClient::DescribeAccountKmsStatusOutcomeCallable KmsClient::describeAccountKms
return task->get_future();
}
KmsClient::DescribeCertificateOutcome KmsClient::describeCertificate(const DescribeCertificateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeCertificateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeCertificateOutcome(DescribeCertificateResult(outcome.result()));
else
return DescribeCertificateOutcome(outcome.error());
}
void KmsClient::describeCertificateAsync(const DescribeCertificateRequest& request, const DescribeCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeCertificate(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::DescribeCertificateOutcomeCallable KmsClient::describeCertificateCallable(const DescribeCertificateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeCertificateOutcome()>>(
[this, request]()
{
return this->describeCertificate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::DescribeKeyOutcome KmsClient::describeKey(const DescribeKeyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -843,6 +1095,42 @@ KmsClient::EncryptOutcomeCallable KmsClient::encryptCallable(const EncryptReques
return task->get_future();
}
KmsClient::ExportCertificateOutcome KmsClient::exportCertificate(const ExportCertificateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ExportCertificateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ExportCertificateOutcome(ExportCertificateResult(outcome.result()));
else
return ExportCertificateOutcome(outcome.error());
}
void KmsClient::exportCertificateAsync(const ExportCertificateRequest& request, const ExportCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, exportCertificate(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::ExportCertificateOutcomeCallable KmsClient::exportCertificateCallable(const ExportCertificateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ExportCertificateOutcome()>>(
[this, request]()
{
return this->exportCertificate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::ExportDataKeyOutcome KmsClient::exportDataKey(const ExportDataKeyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -987,6 +1275,42 @@ KmsClient::GenerateDataKeyWithoutPlaintextOutcomeCallable KmsClient::generateDat
return task->get_future();
}
KmsClient::GetCertificateOutcome KmsClient::getCertificate(const GetCertificateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetCertificateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetCertificateOutcome(GetCertificateResult(outcome.result()));
else
return GetCertificateOutcome(outcome.error());
}
void KmsClient::getCertificateAsync(const GetCertificateRequest& request, const GetCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getCertificate(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::GetCertificateOutcomeCallable KmsClient::getCertificateCallable(const GetCertificateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetCertificateOutcome()>>(
[this, request]()
{
return this->getCertificate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::GetParametersForImportOutcome KmsClient::getParametersForImport(const GetParametersForImportRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1131,6 +1455,78 @@ KmsClient::GetSecretValueOutcomeCallable KmsClient::getSecretValueCallable(const
return task->get_future();
}
KmsClient::ImportCertificateOutcome KmsClient::importCertificate(const ImportCertificateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ImportCertificateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ImportCertificateOutcome(ImportCertificateResult(outcome.result()));
else
return ImportCertificateOutcome(outcome.error());
}
void KmsClient::importCertificateAsync(const ImportCertificateRequest& request, const ImportCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, importCertificate(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::ImportCertificateOutcomeCallable KmsClient::importCertificateCallable(const ImportCertificateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ImportCertificateOutcome()>>(
[this, request]()
{
return this->importCertificate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::ImportEncryptionCertificateOutcome KmsClient::importEncryptionCertificate(const ImportEncryptionCertificateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ImportEncryptionCertificateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ImportEncryptionCertificateOutcome(ImportEncryptionCertificateResult(outcome.result()));
else
return ImportEncryptionCertificateOutcome(outcome.error());
}
void KmsClient::importEncryptionCertificateAsync(const ImportEncryptionCertificateRequest& request, const ImportEncryptionCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, importEncryptionCertificate(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::ImportEncryptionCertificateOutcomeCallable KmsClient::importEncryptionCertificateCallable(const ImportEncryptionCertificateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ImportEncryptionCertificateOutcome()>>(
[this, request]()
{
return this->importEncryptionCertificate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::ImportKeyMaterialOutcome KmsClient::importKeyMaterial(const ImportKeyMaterialRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1239,6 +1635,42 @@ KmsClient::ListAliasesByKeyIdOutcomeCallable KmsClient::listAliasesByKeyIdCallab
return task->get_future();
}
KmsClient::ListCertificatesOutcome KmsClient::listCertificates(const ListCertificatesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListCertificatesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListCertificatesOutcome(ListCertificatesResult(outcome.result()));
else
return ListCertificatesOutcome(outcome.error());
}
void KmsClient::listCertificatesAsync(const ListCertificatesRequest& request, const ListCertificatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listCertificates(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::ListCertificatesOutcomeCallable KmsClient::listCertificatesCallable(const ListCertificatesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListCertificatesOutcome()>>(
[this, request]()
{
return this->listCertificates(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::ListKeyVersionsOutcome KmsClient::listKeyVersions(const ListKeyVersionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1707,6 +2139,42 @@ KmsClient::UpdateAliasOutcomeCallable KmsClient::updateAliasCallable(const Updat
return task->get_future();
}
KmsClient::UpdateCertificateStatusOutcome KmsClient::updateCertificateStatus(const UpdateCertificateStatusRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateCertificateStatusOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateCertificateStatusOutcome(UpdateCertificateStatusResult(outcome.result()));
else
return UpdateCertificateStatusOutcome(outcome.error());
}
void KmsClient::updateCertificateStatusAsync(const UpdateCertificateStatusRequest& request, const UpdateCertificateStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateCertificateStatus(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::UpdateCertificateStatusOutcomeCallable KmsClient::updateCertificateStatusCallable(const UpdateCertificateStatusRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateCertificateStatusOutcome()>>(
[this, request]()
{
return this->updateCertificateStatus(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
KmsClient::UpdateKeyDescriptionOutcome KmsClient::updateKeyDescription(const UpdateKeyDescriptionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1851,3 +2319,39 @@ KmsClient::UpdateSecretVersionStageOutcomeCallable KmsClient::updateSecretVersio
return task->get_future();
}
KmsClient::UploadCertificateOutcome KmsClient::uploadCertificate(const UploadCertificateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UploadCertificateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UploadCertificateOutcome(UploadCertificateResult(outcome.result()));
else
return UploadCertificateOutcome(outcome.error());
}
void KmsClient::uploadCertificateAsync(const UploadCertificateRequest& request, const UploadCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, uploadCertificate(request), context);
};
asyncExecute(new Runnable(fn));
}
KmsClient::UploadCertificateOutcomeCallable KmsClient::uploadCertificateCallable(const UploadCertificateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UploadCertificateOutcome()>>(
[this, request]()
{
return this->uploadCertificate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

62
kms/src/model/CertificatePrivateKeyDecryptRequest.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/CertificatePrivateKeyDecryptRequest.h>
using AlibabaCloud::Kms::Model::CertificatePrivateKeyDecryptRequest;
CertificatePrivateKeyDecryptRequest::CertificatePrivateKeyDecryptRequest() :
RpcServiceRequest("kms", "2016-01-20", "CertificatePrivateKeyDecrypt")
{
setMethod(HttpRequest::Method::Post);
}
CertificatePrivateKeyDecryptRequest::~CertificatePrivateKeyDecryptRequest()
{}
std::string CertificatePrivateKeyDecryptRequest::getCertificateId()const
{
return certificateId_;
}
void CertificatePrivateKeyDecryptRequest::setCertificateId(const std::string& certificateId)
{
certificateId_ = certificateId;
setParameter("CertificateId", certificateId);
}
std::string CertificatePrivateKeyDecryptRequest::getAlgorithm()const
{
return algorithm_;
}
void CertificatePrivateKeyDecryptRequest::setAlgorithm(const std::string& algorithm)
{
algorithm_ = algorithm;
setParameter("Algorithm", algorithm);
}
std::string CertificatePrivateKeyDecryptRequest::getCiphertextBlob()const
{
return ciphertextBlob_;
}
void CertificatePrivateKeyDecryptRequest::setCiphertextBlob(const std::string& ciphertextBlob)
{
ciphertextBlob_ = ciphertextBlob;
setParameter("CiphertextBlob", ciphertextBlob);
}

58
kms/src/model/CertificatePrivateKeyDecryptResult.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/CertificatePrivateKeyDecryptResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
CertificatePrivateKeyDecryptResult::CertificatePrivateKeyDecryptResult() :
ServiceResult()
{}
CertificatePrivateKeyDecryptResult::CertificatePrivateKeyDecryptResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CertificatePrivateKeyDecryptResult::~CertificatePrivateKeyDecryptResult()
{}
void CertificatePrivateKeyDecryptResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["CertificateId"].isNull())
certificateId_ = value["CertificateId"].asString();
if(!value["Plaintext"].isNull())
plaintext_ = value["Plaintext"].asString();
}
std::string CertificatePrivateKeyDecryptResult::getCertificateId()const
{
return certificateId_;
}
std::string CertificatePrivateKeyDecryptResult::getPlaintext()const
{
return plaintext_;
}

73
kms/src/model/CertificatePrivateKeySignRequest.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/CertificatePrivateKeySignRequest.h>
using AlibabaCloud::Kms::Model::CertificatePrivateKeySignRequest;
CertificatePrivateKeySignRequest::CertificatePrivateKeySignRequest() :
RpcServiceRequest("kms", "2016-01-20", "CertificatePrivateKeySign")
{
setMethod(HttpRequest::Method::Post);
}
CertificatePrivateKeySignRequest::~CertificatePrivateKeySignRequest()
{}
std::string CertificatePrivateKeySignRequest::getMessageType()const
{
return messageType_;
}
void CertificatePrivateKeySignRequest::setMessageType(const std::string& messageType)
{
messageType_ = messageType;
setParameter("MessageType", messageType);
}
std::string CertificatePrivateKeySignRequest::getCertificateId()const
{
return certificateId_;
}
void CertificatePrivateKeySignRequest::setCertificateId(const std::string& certificateId)
{
certificateId_ = certificateId;
setParameter("CertificateId", certificateId);
}
std::string CertificatePrivateKeySignRequest::getMessage()const
{
return message_;
}
void CertificatePrivateKeySignRequest::setMessage(const std::string& message)
{
message_ = message;
setParameter("Message", message);
}
std::string CertificatePrivateKeySignRequest::getAlgorithm()const
{
return algorithm_;
}
void CertificatePrivateKeySignRequest::setAlgorithm(const std::string& algorithm)
{
algorithm_ = algorithm;
setParameter("Algorithm", algorithm);
}

58
kms/src/model/CertificatePrivateKeySignResult.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/CertificatePrivateKeySignResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
CertificatePrivateKeySignResult::CertificatePrivateKeySignResult() :
ServiceResult()
{}
CertificatePrivateKeySignResult::CertificatePrivateKeySignResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CertificatePrivateKeySignResult::~CertificatePrivateKeySignResult()
{}
void CertificatePrivateKeySignResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["CertificateId"].isNull())
certificateId_ = value["CertificateId"].asString();
if(!value["SignatureValue"].isNull())
signatureValue_ = value["SignatureValue"].asString();
}
std::string CertificatePrivateKeySignResult::getSignatureValue()const
{
return signatureValue_;
}
std::string CertificatePrivateKeySignResult::getCertificateId()const
{
return certificateId_;
}

62
kms/src/model/CertificatePublicKeyEncryptRequest.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/CertificatePublicKeyEncryptRequest.h>
using AlibabaCloud::Kms::Model::CertificatePublicKeyEncryptRequest;
CertificatePublicKeyEncryptRequest::CertificatePublicKeyEncryptRequest() :
RpcServiceRequest("kms", "2016-01-20", "CertificatePublicKeyEncrypt")
{
setMethod(HttpRequest::Method::Post);
}
CertificatePublicKeyEncryptRequest::~CertificatePublicKeyEncryptRequest()
{}
std::string CertificatePublicKeyEncryptRequest::getCertificateId()const
{
return certificateId_;
}
void CertificatePublicKeyEncryptRequest::setCertificateId(const std::string& certificateId)
{
certificateId_ = certificateId;
setParameter("CertificateId", certificateId);
}
std::string CertificatePublicKeyEncryptRequest::getPlaintext()const
{
return plaintext_;
}
void CertificatePublicKeyEncryptRequest::setPlaintext(const std::string& plaintext)
{
plaintext_ = plaintext;
setParameter("Plaintext", plaintext);
}
std::string CertificatePublicKeyEncryptRequest::getAlgorithm()const
{
return algorithm_;
}
void CertificatePublicKeyEncryptRequest::setAlgorithm(const std::string& algorithm)
{
algorithm_ = algorithm;
setParameter("Algorithm", algorithm);
}

58
kms/src/model/CertificatePublicKeyEncryptResult.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/CertificatePublicKeyEncryptResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
CertificatePublicKeyEncryptResult::CertificatePublicKeyEncryptResult() :
ServiceResult()
{}
CertificatePublicKeyEncryptResult::CertificatePublicKeyEncryptResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CertificatePublicKeyEncryptResult::~CertificatePublicKeyEncryptResult()
{}
void CertificatePublicKeyEncryptResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["CertificateId"].isNull())
certificateId_ = value["CertificateId"].asString();
if(!value["CiphertextBlob"].isNull())
ciphertextBlob_ = value["CiphertextBlob"].asString();
}
std::string CertificatePublicKeyEncryptResult::getCertificateId()const
{
return certificateId_;
}
std::string CertificatePublicKeyEncryptResult::getCiphertextBlob()const
{
return ciphertextBlob_;
}

84
kms/src/model/CertificatePublicKeyVerifyRequest.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/CertificatePublicKeyVerifyRequest.h>
using AlibabaCloud::Kms::Model::CertificatePublicKeyVerifyRequest;
CertificatePublicKeyVerifyRequest::CertificatePublicKeyVerifyRequest() :
RpcServiceRequest("kms", "2016-01-20", "CertificatePublicKeyVerify")
{
setMethod(HttpRequest::Method::Post);
}
CertificatePublicKeyVerifyRequest::~CertificatePublicKeyVerifyRequest()
{}
std::string CertificatePublicKeyVerifyRequest::getSignatureValue()const
{
return signatureValue_;
}
void CertificatePublicKeyVerifyRequest::setSignatureValue(const std::string& signatureValue)
{
signatureValue_ = signatureValue;
setParameter("SignatureValue", signatureValue);
}
std::string CertificatePublicKeyVerifyRequest::getMessageType()const
{
return messageType_;
}
void CertificatePublicKeyVerifyRequest::setMessageType(const std::string& messageType)
{
messageType_ = messageType;
setParameter("MessageType", messageType);
}
std::string CertificatePublicKeyVerifyRequest::getCertificateId()const
{
return certificateId_;
}
void CertificatePublicKeyVerifyRequest::setCertificateId(const std::string& certificateId)
{
certificateId_ = certificateId;
setParameter("CertificateId", certificateId);
}
std::string CertificatePublicKeyVerifyRequest::getMessage()const
{
return message_;
}
void CertificatePublicKeyVerifyRequest::setMessage(const std::string& message)
{
message_ = message;
setParameter("Message", message);
}
std::string CertificatePublicKeyVerifyRequest::getAlgorithm()const
{
return algorithm_;
}
void CertificatePublicKeyVerifyRequest::setAlgorithm(const std::string& algorithm)
{
algorithm_ = algorithm;
setParameter("Algorithm", algorithm);
}

58
kms/src/model/CertificatePublicKeyVerifyResult.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/CertificatePublicKeyVerifyResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
CertificatePublicKeyVerifyResult::CertificatePublicKeyVerifyResult() :
ServiceResult()
{}
CertificatePublicKeyVerifyResult::CertificatePublicKeyVerifyResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CertificatePublicKeyVerifyResult::~CertificatePublicKeyVerifyResult()
{}
void CertificatePublicKeyVerifyResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["CertificateId"].isNull())
certificateId_ = value["CertificateId"].asString();
if(!value["SignatureValid"].isNull())
signatureValid_ = value["SignatureValid"].asString() == "true";
}
std::string CertificatePublicKeyVerifyResult::getCertificateId()const
{
return certificateId_;
}
bool CertificatePublicKeyVerifyResult::getSignatureValid()const
{
return signatureValid_;
}

73
kms/src/model/CreateCertificateRequest.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/CreateCertificateRequest.h>
using AlibabaCloud::Kms::Model::CreateCertificateRequest;
CreateCertificateRequest::CreateCertificateRequest() :
RpcServiceRequest("kms", "2016-01-20", "CreateCertificate")
{
setMethod(HttpRequest::Method::Post);
}
CreateCertificateRequest::~CreateCertificateRequest()
{}
std::string CreateCertificateRequest::getProtectionLevel()const
{
return protectionLevel_;
}
void CreateCertificateRequest::setProtectionLevel(const std::string& protectionLevel)
{
protectionLevel_ = protectionLevel;
setParameter("ProtectionLevel", protectionLevel);
}
std::string CreateCertificateRequest::getSubject()const
{
return subject_;
}
void CreateCertificateRequest::setSubject(const std::string& subject)
{
subject_ = subject;
setParameter("Subject", subject);
}
std::map<std::string, std::string> CreateCertificateRequest::getSubjectAlternativeNames()const
{
return subjectAlternativeNames_;
}
void CreateCertificateRequest::setSubjectAlternativeNames(const std::map<std::string, std::string>& subjectAlternativeNames)
{
subjectAlternativeNames_ = subjectAlternativeNames;
setJsonParameters("SubjectAlternativeNames", subjectAlternativeNames);
}
std::string CreateCertificateRequest::getKeySpec()const
{
return keySpec_;
}
void CreateCertificateRequest::setKeySpec(const std::string& keySpec)
{
keySpec_ = keySpec;
setParameter("KeySpec", keySpec);
}

65
kms/src/model/CreateCertificateResult.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/CreateCertificateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
CreateCertificateResult::CreateCertificateResult() :
ServiceResult()
{}
CreateCertificateResult::CreateCertificateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateCertificateResult::~CreateCertificateResult()
{}
void CreateCertificateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["CertificateId"].isNull())
certificateId_ = value["CertificateId"].asString();
if(!value["Arn"].isNull())
arn_ = value["Arn"].asString();
if(!value["Csr"].isNull())
csr_ = value["Csr"].asString();
}
std::string CreateCertificateResult::getCsr()const
{
return csr_;
}
std::string CreateCertificateResult::getCertificateId()const
{
return certificateId_;
}
std::string CreateCertificateResult::getArn()const
{
return arn_;
}

40
kms/src/model/DeleteCertificateRequest.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/DeleteCertificateRequest.h>
using AlibabaCloud::Kms::Model::DeleteCertificateRequest;
DeleteCertificateRequest::DeleteCertificateRequest() :
RpcServiceRequest("kms", "2016-01-20", "DeleteCertificate")
{
setMethod(HttpRequest::Method::Post);
}
DeleteCertificateRequest::~DeleteCertificateRequest()
{}
std::string DeleteCertificateRequest::getCertificateId()const
{
return certificateId_;
}
void DeleteCertificateRequest::setCertificateId(const std::string& certificateId)
{
certificateId_ = certificateId;
setParameter("CertificateId", certificateId);
}

44
kms/src/model/DeleteCertificateResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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/DeleteCertificateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
DeleteCertificateResult::DeleteCertificateResult() :
ServiceResult()
{}
DeleteCertificateResult::DeleteCertificateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteCertificateResult::~DeleteCertificateResult()
{}
void DeleteCertificateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

40
kms/src/model/DescribeCertificateRequest.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/DescribeCertificateRequest.h>
using AlibabaCloud::Kms::Model::DescribeCertificateRequest;
DescribeCertificateRequest::DescribeCertificateRequest() :
RpcServiceRequest("kms", "2016-01-20", "DescribeCertificate")
{
setMethod(HttpRequest::Method::Post);
}
DescribeCertificateRequest::~DescribeCertificateRequest()
{}
std::string DescribeCertificateRequest::getCertificateId()const
{
return certificateId_;
}
void DescribeCertificateRequest::setCertificateId(const std::string& certificateId)
{
certificateId_ = certificateId;
setParameter("CertificateId", certificateId);
}

164
kms/src/model/DescribeCertificateResult.cc Normal file
View File

@@ -0,0 +1,164 @@
/*
* 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/DescribeCertificateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
DescribeCertificateResult::DescribeCertificateResult() :
ServiceResult()
{}
DescribeCertificateResult::DescribeCertificateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeCertificateResult::~DescribeCertificateResult()
{}
void DescribeCertificateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allSubjectAlternativeNames = value["SubjectAlternativeNames"]["SubjectAlternativeName"];
for (const auto &item : allSubjectAlternativeNames)
subjectAlternativeNames_.push_back(item.asString());
if(!value["CertificateId"].isNull())
certificateId_ = value["CertificateId"].asString();
if(!value["Arn"].isNull())
arn_ = value["Arn"].asString();
if(!value["KeySpec"].isNull())
keySpec_ = value["KeySpec"].asString();
if(!value["ProtectionLevel"].isNull())
protectionLevel_ = value["ProtectionLevel"].asString();
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["CreatedAt"].isNull())
createdAt_ = value["CreatedAt"].asString();
if(!value["UpdatedAt"].isNull())
updatedAt_ = value["UpdatedAt"].asString();
if(!value["Serial"].isNull())
serial_ = value["Serial"].asString();
if(!value["Subject"].isNull())
subject_ = value["Subject"].asString();
if(!value["Issuer"].isNull())
issuer_ = value["Issuer"].asString();
if(!value["NotBefore"].isNull())
notBefore_ = value["NotBefore"].asString();
if(!value["NotAfter"].isNull())
notAfter_ = value["NotAfter"].asString();
if(!value["SignatureAlgorithm"].isNull())
signatureAlgorithm_ = value["SignatureAlgorithm"].asString();
if(!value["SubjectPublicKey"].isNull())
subjectPublicKey_ = value["SubjectPublicKey"].asString();
if(!value["SubjectKeyIdentifier"].isNull())
subjectKeyIdentifier_ = value["SubjectKeyIdentifier"].asString();
if(!value["Tags"].isNull())
tags_ = value["Tags"].asString();
}
std::string DescribeCertificateResult::getStatus()const
{
return status_;
}
std::string DescribeCertificateResult::getProtectionLevel()const
{
return protectionLevel_;
}
std::string DescribeCertificateResult::getIssuer()const
{
return issuer_;
}
std::string DescribeCertificateResult::getCertificateId()const
{
return certificateId_;
}
std::string DescribeCertificateResult::getKeySpec()const
{
return keySpec_;
}
std::string DescribeCertificateResult::getCreatedAt()const
{
return createdAt_;
}
std::vector<std::string> DescribeCertificateResult::getSubjectAlternativeNames()const
{
return subjectAlternativeNames_;
}
std::string DescribeCertificateResult::getSignatureAlgorithm()const
{
return signatureAlgorithm_;
}
std::string DescribeCertificateResult::getSubjectKeyIdentifier()const
{
return subjectKeyIdentifier_;
}
std::string DescribeCertificateResult::getNotAfter()const
{
return notAfter_;
}
std::string DescribeCertificateResult::getUpdatedAt()const
{
return updatedAt_;
}
std::string DescribeCertificateResult::getSubject()const
{
return subject_;
}
std::string DescribeCertificateResult::getSerial()const
{
return serial_;
}
std::string DescribeCertificateResult::getSubjectPublicKey()const
{
return subjectPublicKey_;
}
std::string DescribeCertificateResult::getArn()const
{
return arn_;
}
std::string DescribeCertificateResult::getNotBefore()const
{
return notBefore_;
}
std::string DescribeCertificateResult::getTags()const
{
return tags_;
}

62
kms/src/model/ExportCertificateRequest.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/ExportCertificateRequest.h>
using AlibabaCloud::Kms::Model::ExportCertificateRequest;
ExportCertificateRequest::ExportCertificateRequest() :
RpcServiceRequest("kms", "2016-01-20", "ExportCertificate")
{
setMethod(HttpRequest::Method::Post);
}
ExportCertificateRequest::~ExportCertificateRequest()
{}
std::string ExportCertificateRequest::getCertificateId()const
{
return certificateId_;
}
void ExportCertificateRequest::setCertificateId(const std::string& certificateId)
{
certificateId_ = certificateId;
setParameter("CertificateId", certificateId);
}
std::string ExportCertificateRequest::getPassphrase()const
{
return passphrase_;
}
void ExportCertificateRequest::setPassphrase(const std::string& passphrase)
{
passphrase_ = passphrase;
setParameter("Passphrase", passphrase);
}
std::string ExportCertificateRequest::getExportFormat()const
{
return exportFormat_;
}
void ExportCertificateRequest::setExportFormat(const std::string& exportFormat)
{
exportFormat_ = exportFormat;
setParameter("ExportFormat", exportFormat);
}

79
kms/src/model/ExportCertificateResult.cc Normal file
View File

@@ -0,0 +1,79 @@
/*
* 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/ExportCertificateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
ExportCertificateResult::ExportCertificateResult() :
ServiceResult()
{}
ExportCertificateResult::ExportCertificateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ExportCertificateResult::~ExportCertificateResult()
{}
void ExportCertificateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["CertificateId"].isNull())
certificateId_ = value["CertificateId"].asString();
if(!value["Certificate"].isNull())
certificate_ = value["Certificate"].asString();
if(!value["CertificateChain"].isNull())
certificateChain_ = value["CertificateChain"].asString();
if(!value["PrivateKey"].isNull())
privateKey_ = value["PrivateKey"].asString();
if(!value["PKCS12Blob"].isNull())
pKCS12Blob_ = value["PKCS12Blob"].asString();
}
std::string ExportCertificateResult::getPrivateKey()const
{
return privateKey_;
}
std::string ExportCertificateResult::getCertificateId()const
{
return certificateId_;
}
std::string ExportCertificateResult::getCertificateChain()const
{
return certificateChain_;
}
std::string ExportCertificateResult::getPKCS12Blob()const
{
return pKCS12Blob_;
}
std::string ExportCertificateResult::getCertificate()const
{
return certificate_;
}

40
kms/src/model/GetCertificateRequest.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/GetCertificateRequest.h>
using AlibabaCloud::Kms::Model::GetCertificateRequest;
GetCertificateRequest::GetCertificateRequest() :
RpcServiceRequest("kms", "2016-01-20", "GetCertificate")
{
setMethod(HttpRequest::Method::Post);
}
GetCertificateRequest::~GetCertificateRequest()
{}
std::string GetCertificateRequest::getCertificateId()const
{
return certificateId_;
}
void GetCertificateRequest::setCertificateId(const std::string& certificateId)
{
certificateId_ = certificateId;
setParameter("CertificateId", certificateId);
}

72
kms/src/model/GetCertificateResult.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* 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/GetCertificateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
GetCertificateResult::GetCertificateResult() :
ServiceResult()
{}
GetCertificateResult::GetCertificateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetCertificateResult::~GetCertificateResult()
{}
void GetCertificateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Certificate"].isNull())
certificate_ = value["Certificate"].asString();
if(!value["CertificateChain"].isNull())
certificateChain_ = value["CertificateChain"].asString();
if(!value["Csr"].isNull())
csr_ = value["Csr"].asString();
if(!value["CertificateId"].isNull())
certificateId_ = value["CertificateId"].asString();
}
std::string GetCertificateResult::getCsr()const
{
return csr_;
}
std::string GetCertificateResult::getCertificateId()const
{
return certificateId_;
}
std::string GetCertificateResult::getCertificateChain()const
{
return certificateChain_;
}
std::string GetCertificateResult::getCertificate()const
{
return certificate_;
}

51
kms/src/model/ImportCertificateRequest.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/ImportCertificateRequest.h>
using AlibabaCloud::Kms::Model::ImportCertificateRequest;
ImportCertificateRequest::ImportCertificateRequest() :
RpcServiceRequest("kms", "2016-01-20", "ImportCertificate")
{
setMethod(HttpRequest::Method::Post);
}
ImportCertificateRequest::~ImportCertificateRequest()
{}
std::string ImportCertificateRequest::getPKCS12Blob()const
{
return pKCS12Blob_;
}
void ImportCertificateRequest::setPKCS12Blob(const std::string& pKCS12Blob)
{
pKCS12Blob_ = pKCS12Blob;
setParameter("PKCS12Blob", pKCS12Blob);
}
std::string ImportCertificateRequest::getPassphrase()const
{
return passphrase_;
}
void ImportCertificateRequest::setPassphrase(const std::string& passphrase)
{
passphrase_ = passphrase;
setParameter("Passphrase", passphrase);
}

58
kms/src/model/ImportCertificateResult.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/ImportCertificateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
ImportCertificateResult::ImportCertificateResult() :
ServiceResult()
{}
ImportCertificateResult::ImportCertificateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ImportCertificateResult::~ImportCertificateResult()
{}
void ImportCertificateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["CertificateId"].isNull())
certificateId_ = value["CertificateId"].asString();
if(!value["Arn"].isNull())
arn_ = value["Arn"].asString();
}
std::string ImportCertificateResult::getCertificateId()const
{
return certificateId_;
}
std::string ImportCertificateResult::getArn()const
{
return arn_;
}

106
kms/src/model/ImportEncryptionCertificateRequest.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/ImportEncryptionCertificateRequest.h>
using AlibabaCloud::Kms::Model::ImportEncryptionCertificateRequest;
ImportEncryptionCertificateRequest::ImportEncryptionCertificateRequest() :
RpcServiceRequest("kms", "2016-01-20", "ImportEncryptionCertificate")
{
setMethod(HttpRequest::Method::Post);
}
ImportEncryptionCertificateRequest::~ImportEncryptionCertificateRequest()
{}
std::string ImportEncryptionCertificateRequest::getAsymmetricAlgorithm()const
{
return asymmetricAlgorithm_;
}
void ImportEncryptionCertificateRequest::setAsymmetricAlgorithm(const std::string& asymmetricAlgorithm)
{
asymmetricAlgorithm_ = asymmetricAlgorithm;
setParameter("AsymmetricAlgorithm", asymmetricAlgorithm);
}
std::string ImportEncryptionCertificateRequest::getSymmetricAlgorithm()const
{
return symmetricAlgorithm_;
}
void ImportEncryptionCertificateRequest::setSymmetricAlgorithm(const std::string& symmetricAlgorithm)
{
symmetricAlgorithm_ = symmetricAlgorithm;
setParameter("SymmetricAlgorithm", symmetricAlgorithm);
}
std::string ImportEncryptionCertificateRequest::getEncryptedPrivateKey()const
{
return encryptedPrivateKey_;
}
void ImportEncryptionCertificateRequest::setEncryptedPrivateKey(const std::string& encryptedPrivateKey)
{
encryptedPrivateKey_ = encryptedPrivateKey;
setParameter("EncryptedPrivateKey", encryptedPrivateKey);
}
std::string ImportEncryptionCertificateRequest::getEncryptedSymmetricKey()const
{
return encryptedSymmetricKey_;
}
void ImportEncryptionCertificateRequest::setEncryptedSymmetricKey(const std::string& encryptedSymmetricKey)
{
encryptedSymmetricKey_ = encryptedSymmetricKey;
setParameter("EncryptedSymmetricKey", encryptedSymmetricKey);
}
std::string ImportEncryptionCertificateRequest::getCertificateId()const
{
return certificateId_;
}
void ImportEncryptionCertificateRequest::setCertificateId(const std::string& certificateId)
{
certificateId_ = certificateId;
setParameter("CertificateId", certificateId);
}
std::string ImportEncryptionCertificateRequest::getCertificate()const
{
return certificate_;
}
void ImportEncryptionCertificateRequest::setCertificate(const std::string& certificate)
{
certificate_ = certificate;
setParameter("Certificate", certificate);
}
std::string ImportEncryptionCertificateRequest::getCertificateChain()const
{
return certificateChain_;
}
void ImportEncryptionCertificateRequest::setCertificateChain(const std::string& certificateChain)
{
certificateChain_ = certificateChain;
setParameter("CertificateChain", certificateChain);
}

58
kms/src/model/ImportEncryptionCertificateResult.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/ImportEncryptionCertificateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
ImportEncryptionCertificateResult::ImportEncryptionCertificateResult() :
ServiceResult()
{}
ImportEncryptionCertificateResult::ImportEncryptionCertificateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ImportEncryptionCertificateResult::~ImportEncryptionCertificateResult()
{}
void ImportEncryptionCertificateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["CertificateId"].isNull())
certificateId_ = value["CertificateId"].asString();
if(!value["Arn"].isNull())
arn_ = value["Arn"].asString();
}
std::string ImportEncryptionCertificateResult::getCertificateId()const
{
return certificateId_;
}
std::string ImportEncryptionCertificateResult::getArn()const
{
return arn_;
}

84
kms/src/model/ListCertificatesRequest.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/ListCertificatesRequest.h>
using AlibabaCloud::Kms::Model::ListCertificatesRequest;
ListCertificatesRequest::ListCertificatesRequest() :
RpcServiceRequest("kms", "2016-01-20", "ListCertificates")
{
setMethod(HttpRequest::Method::Post);
}
ListCertificatesRequest::~ListCertificatesRequest()
{}
std::string ListCertificatesRequest::getSubject()const
{
return subject_;
}
void ListCertificatesRequest::setSubject(const std::string& subject)
{
subject_ = subject;
setParameter("Subject", subject);
}
int ListCertificatesRequest::getPageSize()const
{
return pageSize_;
}
void ListCertificatesRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string ListCertificatesRequest::getIssuer()const
{
return issuer_;
}
void ListCertificatesRequest::setIssuer(const std::string& issuer)
{
issuer_ = issuer;
setParameter("Issuer", issuer);
}
int ListCertificatesRequest::getPageNumber()const
{
return pageNumber_;
}
void ListCertificatesRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string ListCertificatesRequest::getStatus()const
{
return status_;
}
void ListCertificatesRequest::setStatus(const std::string& status)
{
status_ = status;
setParameter("Status", status);
}

92
kms/src/model/ListCertificatesResult.cc Normal file
View File

@@ -0,0 +1,92 @@
/*
* 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/ListCertificatesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
ListCertificatesResult::ListCertificatesResult() :
ServiceResult()
{}
ListCertificatesResult::ListCertificatesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListCertificatesResult::~ListCertificatesResult()
{}
void ListCertificatesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allCertificateSummaryListNode = value["CertificateSummaryList"]["CertificateSummary"];
for (auto valueCertificateSummaryListCertificateSummary : allCertificateSummaryListNode)
{
CertificateSummary certificateSummaryListObject;
if(!valueCertificateSummaryListCertificateSummary["CertificateId"].isNull())
certificateSummaryListObject.certificateId = valueCertificateSummaryListCertificateSummary["CertificateId"].asString();
if(!valueCertificateSummaryListCertificateSummary["Subject"].isNull())
certificateSummaryListObject.subject = valueCertificateSummaryListCertificateSummary["Subject"].asString();
if(!valueCertificateSummaryListCertificateSummary["Issuer"].isNull())
certificateSummaryListObject.issuer = valueCertificateSummaryListCertificateSummary["Issuer"].asString();
if(!valueCertificateSummaryListCertificateSummary["KeySpec"].isNull())
certificateSummaryListObject.keySpec = valueCertificateSummaryListCertificateSummary["KeySpec"].asString();
if(!valueCertificateSummaryListCertificateSummary["ProtectionLevel"].isNull())
certificateSummaryListObject.protectionLevel = valueCertificateSummaryListCertificateSummary["ProtectionLevel"].asString();
if(!valueCertificateSummaryListCertificateSummary["NotBefore"].isNull())
certificateSummaryListObject.notBefore = valueCertificateSummaryListCertificateSummary["NotBefore"].asString();
if(!valueCertificateSummaryListCertificateSummary["NotAfter"].isNull())
certificateSummaryListObject.notAfter = valueCertificateSummaryListCertificateSummary["NotAfter"].asString();
if(!valueCertificateSummaryListCertificateSummary["Status"].isNull())
certificateSummaryListObject.status = valueCertificateSummaryListCertificateSummary["Status"].asString();
certificateSummaryList_.push_back(certificateSummaryListObject);
}
if(!value["TotalSize"].isNull())
totalSize_ = std::stoi(value["TotalSize"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
}
int ListCertificatesResult::getPageSize()const
{
return pageSize_;
}
int ListCertificatesResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<ListCertificatesResult::CertificateSummary> ListCertificatesResult::getCertificateSummaryList()const
{
return certificateSummaryList_;
}
int ListCertificatesResult::getTotalSize()const
{
return totalSize_;
}

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

@@ -51,14 +51,14 @@ void ListSecretsResult::parse(const std::string &payload)
secretListObject.secretName = valueSecretListSecret["SecretName"].asString();
if(!valueSecretListSecret["UpdateTime"].isNull())
secretListObject.updateTime = valueSecretListSecret["UpdateTime"].asString();
auto allTagsNode = allSecretListNode["Tags"]["Tag"];
for (auto allSecretListNodeTagsTag : allTagsNode)
auto allTagsNode = valueSecretListSecret["Tags"]["Tag"];
for (auto valueSecretListSecretTagsTag : allTagsNode)
{
Secret::Tag tagsObject;
if(!allSecretListNodeTagsTag["TagKey"].isNull())
tagsObject.tagKey = allSecretListNodeTagsTag["TagKey"].asString();
if(!allSecretListNodeTagsTag["TagValue"].isNull())
tagsObject.tagValue = allSecretListNodeTagsTag["TagValue"].asString();
if(!valueSecretListSecretTagsTag["TagKey"].isNull())
tagsObject.tagKey = valueSecretListSecretTagsTag["TagKey"].asString();
if(!valueSecretListSecretTagsTag["TagValue"].isNull())
tagsObject.tagValue = valueSecretListSecretTagsTag["TagValue"].asString();
secretListObject.tags.push_back(tagsObject);
}
secretList_.push_back(secretListObject);

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

@@ -27,6 +27,17 @@ TagResourceRequest::TagResourceRequest() :
TagResourceRequest::~TagResourceRequest()
{}
std::string TagResourceRequest::getCertificateId()const
{
return certificateId_;
}
void TagResourceRequest::setCertificateId(const std::string& certificateId)
{
certificateId_ = certificateId;
setParameter("CertificateId", certificateId);
}
std::string TagResourceRequest::getKeyId()const
{
return keyId_;

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

@@ -27,6 +27,17 @@ UntagResourceRequest::UntagResourceRequest() :
UntagResourceRequest::~UntagResourceRequest()
{}
std::string UntagResourceRequest::getCertificateId()const
{
return certificateId_;
}
void UntagResourceRequest::setCertificateId(const std::string& certificateId)
{
certificateId_ = certificateId;
setParameter("CertificateId", certificateId);
}
std::string UntagResourceRequest::getTagKeys()const
{
return tagKeys_;

51
kms/src/model/UpdateCertificateStatusRequest.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/UpdateCertificateStatusRequest.h>
using AlibabaCloud::Kms::Model::UpdateCertificateStatusRequest;
UpdateCertificateStatusRequest::UpdateCertificateStatusRequest() :
RpcServiceRequest("kms", "2016-01-20", "UpdateCertificateStatus")
{
setMethod(HttpRequest::Method::Post);
}
UpdateCertificateStatusRequest::~UpdateCertificateStatusRequest()
{}
std::string UpdateCertificateStatusRequest::getCertificateId()const
{
return certificateId_;
}
void UpdateCertificateStatusRequest::setCertificateId(const std::string& certificateId)
{
certificateId_ = certificateId;
setParameter("CertificateId", certificateId);
}
std::string UpdateCertificateStatusRequest::getStatus()const
{
return status_;
}
void UpdateCertificateStatusRequest::setStatus(const std::string& status)
{
status_ = status;
setParameter("Status", status);
}

44
kms/src/model/UpdateCertificateStatusResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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/UpdateCertificateStatusResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
UpdateCertificateStatusResult::UpdateCertificateStatusResult() :
ServiceResult()
{}
UpdateCertificateStatusResult::UpdateCertificateStatusResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateCertificateStatusResult::~UpdateCertificateStatusResult()
{}
void UpdateCertificateStatusResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

62
kms/src/model/UploadCertificateRequest.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/UploadCertificateRequest.h>
using AlibabaCloud::Kms::Model::UploadCertificateRequest;
UploadCertificateRequest::UploadCertificateRequest() :
RpcServiceRequest("kms", "2016-01-20", "UploadCertificate")
{
setMethod(HttpRequest::Method::Post);
}
UploadCertificateRequest::~UploadCertificateRequest()
{}
std::string UploadCertificateRequest::getCertificateId()const
{
return certificateId_;
}
void UploadCertificateRequest::setCertificateId(const std::string& certificateId)
{
certificateId_ = certificateId;
setParameter("CertificateId", certificateId);
}
std::string UploadCertificateRequest::getCertificate()const
{
return certificate_;
}
void UploadCertificateRequest::setCertificate(const std::string& certificate)
{
certificate_ = certificate;
setParameter("Certificate", certificate);
}
std::string UploadCertificateRequest::getCertificateChain()const
{
return certificateChain_;
}
void UploadCertificateRequest::setCertificateChain(const std::string& certificateChain)
{
certificateChain_ = certificateChain;
setParameter("CertificateChain", certificateChain);
}

44
kms/src/model/UploadCertificateResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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/UploadCertificateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Kms;
using namespace AlibabaCloud::Kms::Model;
UploadCertificateResult::UploadCertificateResult() :
ServiceResult()
{}
UploadCertificateResult::UploadCertificateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UploadCertificateResult::~UploadCertificateResult()
{}
void UploadCertificateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}