From d1a9328f7ee8e46a566f21bb7a9031ba927c9138 Mon Sep 17 00:00:00 2001 From: sdk-team Date: Tue, 26 Nov 2019 15:23:11 +0800 Subject: [PATCH] Supported API BindInstanceDomains. --- CHANGELOG | 9 + VERSION | 2 +- alidns/CMakeLists.txt | 40 ++ .../alibabacloud/alidns/AlidnsClient.h | 80 ++++ .../alidns/model/AddCustomLineRequest.h | 65 ++++ .../alidns/model/AddCustomLineResult.h | 53 +++ .../alidns/model/AddDomainBackupRequest.h | 60 +++ .../alidns/model/AddDomainBackupResult.h | 53 +++ .../alidns/model/BindInstanceDomainsRequest.h | 57 +++ .../alidns/model/BindInstanceDomainsResult.h | 53 +++ .../alidns/model/DeleteCustomLinesRequest.h | 54 +++ .../alidns/model/DeleteCustomLinesResult.h | 49 +++ .../model/DescribeBatchResultDetailRequest.h | 3 + .../alidns/model/DescribeCustomLineRequest.h | 54 +++ .../alidns/model/DescribeCustomLineResult.h | 71 ++++ .../alidns/model/DescribeCustomLinesRequest.h | 60 +++ .../alidns/model/DescribeCustomLinesResult.h | 75 ++++ .../model/DescribeTransferDomainsRequest.h | 60 +++ .../model/DescribeTransferDomainsResult.h | 66 ++++ .../alidns/model/TransferDomainRequest.h | 63 +++ .../alidns/model/TransferDomainResult.h | 51 +++ .../model/UnbindInstanceDomainsRequest.h | 57 +++ .../model/UnbindInstanceDomainsResult.h | 53 +++ .../alidns/model/UpdateCustomLineRequest.h | 65 ++++ .../alidns/model/UpdateCustomLineResult.h | 49 +++ alidns/src/AlidnsClient.cc | 360 ++++++++++++++++++ alidns/src/model/AddCustomLineRequest.cc | 89 +++++ alidns/src/model/AddCustomLineResult.cc | 58 +++ alidns/src/model/AddDomainBackupRequest.cc | 84 ++++ alidns/src/model/AddDomainBackupResult.cc | 58 +++ alidns/src/model/AddGtmAddressPoolRequest.cc | 24 +- alidns/src/model/AddGtmMonitorRequest.cc | 11 +- .../src/model/BindInstanceDomainsRequest.cc | 73 ++++ alidns/src/model/BindInstanceDomainsResult.cc | 58 +++ alidns/src/model/DeleteCustomLinesRequest.cc | 62 +++ alidns/src/model/DeleteCustomLinesResult.cc | 44 +++ .../model/DescribeBatchResultDetailRequest.cc | 11 + alidns/src/model/DescribeCustomLineRequest.cc | 62 +++ alidns/src/model/DescribeCustomLineResult.cc | 110 ++++++ .../src/model/DescribeCustomLinesRequest.cc | 84 ++++ alidns/src/model/DescribeCustomLinesResult.cc | 107 ++++++ .../model/DescribeTransferDomainsRequest.cc | 84 ++++ .../model/DescribeTransferDomainsResult.cc | 88 +++++ alidns/src/model/OperateBatchDomainRequest.cc | 27 +- alidns/src/model/TransferDomainRequest.cc | 95 +++++ alidns/src/model/TransferDomainResult.cc | 51 +++ .../src/model/UnbindInstanceDomainsRequest.cc | 73 ++++ .../src/model/UnbindInstanceDomainsResult.cc | 58 +++ alidns/src/model/UpdateCustomLineRequest.cc | 89 +++++ alidns/src/model/UpdateCustomLineResult.cc | 44 +++ .../src/model/UpdateGtmAddressPoolRequest.cc | 13 +- alidns/src/model/UpdateGtmMonitorRequest.cc | 11 +- 52 files changed, 3183 insertions(+), 47 deletions(-) create mode 100644 alidns/include/alibabacloud/alidns/model/AddCustomLineRequest.h create mode 100644 alidns/include/alibabacloud/alidns/model/AddCustomLineResult.h create mode 100644 alidns/include/alibabacloud/alidns/model/AddDomainBackupRequest.h create mode 100644 alidns/include/alibabacloud/alidns/model/AddDomainBackupResult.h create mode 100644 alidns/include/alibabacloud/alidns/model/BindInstanceDomainsRequest.h create mode 100644 alidns/include/alibabacloud/alidns/model/BindInstanceDomainsResult.h create mode 100644 alidns/include/alibabacloud/alidns/model/DeleteCustomLinesRequest.h create mode 100644 alidns/include/alibabacloud/alidns/model/DeleteCustomLinesResult.h create mode 100644 alidns/include/alibabacloud/alidns/model/DescribeCustomLineRequest.h create mode 100644 alidns/include/alibabacloud/alidns/model/DescribeCustomLineResult.h create mode 100644 alidns/include/alibabacloud/alidns/model/DescribeCustomLinesRequest.h create mode 100644 alidns/include/alibabacloud/alidns/model/DescribeCustomLinesResult.h create mode 100644 alidns/include/alibabacloud/alidns/model/DescribeTransferDomainsRequest.h create mode 100644 alidns/include/alibabacloud/alidns/model/DescribeTransferDomainsResult.h create mode 100644 alidns/include/alibabacloud/alidns/model/TransferDomainRequest.h create mode 100644 alidns/include/alibabacloud/alidns/model/TransferDomainResult.h create mode 100644 alidns/include/alibabacloud/alidns/model/UnbindInstanceDomainsRequest.h create mode 100644 alidns/include/alibabacloud/alidns/model/UnbindInstanceDomainsResult.h create mode 100644 alidns/include/alibabacloud/alidns/model/UpdateCustomLineRequest.h create mode 100644 alidns/include/alibabacloud/alidns/model/UpdateCustomLineResult.h create mode 100644 alidns/src/model/AddCustomLineRequest.cc create mode 100644 alidns/src/model/AddCustomLineResult.cc create mode 100644 alidns/src/model/AddDomainBackupRequest.cc create mode 100644 alidns/src/model/AddDomainBackupResult.cc create mode 100644 alidns/src/model/BindInstanceDomainsRequest.cc create mode 100644 alidns/src/model/BindInstanceDomainsResult.cc create mode 100644 alidns/src/model/DeleteCustomLinesRequest.cc create mode 100644 alidns/src/model/DeleteCustomLinesResult.cc create mode 100644 alidns/src/model/DescribeCustomLineRequest.cc create mode 100644 alidns/src/model/DescribeCustomLineResult.cc create mode 100644 alidns/src/model/DescribeCustomLinesRequest.cc create mode 100644 alidns/src/model/DescribeCustomLinesResult.cc create mode 100644 alidns/src/model/DescribeTransferDomainsRequest.cc create mode 100644 alidns/src/model/DescribeTransferDomainsResult.cc create mode 100644 alidns/src/model/TransferDomainRequest.cc create mode 100644 alidns/src/model/TransferDomainResult.cc create mode 100644 alidns/src/model/UnbindInstanceDomainsRequest.cc create mode 100644 alidns/src/model/UnbindInstanceDomainsResult.cc create mode 100644 alidns/src/model/UpdateCustomLineRequest.cc create mode 100644 alidns/src/model/UpdateCustomLineResult.cc diff --git a/CHANGELOG b/CHANGELOG index d7783eef8..bfb456240 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,12 @@ +2019-11-26 Version 1.36.198 +- Supported API BindInstanceDomains. +- Supported API UnbindInstanceDomains. +- Supported API AddCustomLine. +- Supported API UpdateCustomLine. +- Supported API DeleteCustomLines. +- Supported API DescribeCustomLine. +- Supported API DescribeCustomLines. + 2019-11-25 Version 1.36.197 - Generated 2019-10-30 for `aliyuncvc`. diff --git a/VERSION b/VERSION index 811c608a9..4494c9dc1 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.197 \ No newline at end of file +1.36.198 \ No newline at end of file diff --git a/alidns/CMakeLists.txt b/alidns/CMakeLists.txt index fc7f402de..5f0e11bb1 100644 --- a/alidns/CMakeLists.txt +++ b/alidns/CMakeLists.txt @@ -21,8 +21,12 @@ set(alidns_public_header include/alibabacloud/alidns/AlidnsExport.h ) set(alidns_public_header_model + include/alibabacloud/alidns/model/AddCustomLineRequest.h + include/alibabacloud/alidns/model/AddCustomLineResult.h include/alibabacloud/alidns/model/AddDomainRequest.h include/alibabacloud/alidns/model/AddDomainResult.h + include/alibabacloud/alidns/model/AddDomainBackupRequest.h + include/alibabacloud/alidns/model/AddDomainBackupResult.h include/alibabacloud/alidns/model/AddDomainGroupRequest.h include/alibabacloud/alidns/model/AddDomainGroupResult.h include/alibabacloud/alidns/model/AddDomainRecordRequest.h @@ -35,10 +39,14 @@ set(alidns_public_header_model include/alibabacloud/alidns/model/AddGtmMonitorResult.h include/alibabacloud/alidns/model/AddGtmRecoveryPlanRequest.h include/alibabacloud/alidns/model/AddGtmRecoveryPlanResult.h + include/alibabacloud/alidns/model/BindInstanceDomainsRequest.h + include/alibabacloud/alidns/model/BindInstanceDomainsResult.h include/alibabacloud/alidns/model/ChangeDomainGroupRequest.h include/alibabacloud/alidns/model/ChangeDomainGroupResult.h include/alibabacloud/alidns/model/ChangeDomainOfDnsProductRequest.h include/alibabacloud/alidns/model/ChangeDomainOfDnsProductResult.h + include/alibabacloud/alidns/model/DeleteCustomLinesRequest.h + include/alibabacloud/alidns/model/DeleteCustomLinesResult.h include/alibabacloud/alidns/model/DeleteDomainRequest.h include/alibabacloud/alidns/model/DeleteDomainResult.h include/alibabacloud/alidns/model/DeleteDomainGroupRequest.h @@ -57,6 +65,10 @@ set(alidns_public_header_model include/alibabacloud/alidns/model/DescribeBatchResultCountResult.h include/alibabacloud/alidns/model/DescribeBatchResultDetailRequest.h include/alibabacloud/alidns/model/DescribeBatchResultDetailResult.h + include/alibabacloud/alidns/model/DescribeCustomLineRequest.h + include/alibabacloud/alidns/model/DescribeCustomLineResult.h + include/alibabacloud/alidns/model/DescribeCustomLinesRequest.h + include/alibabacloud/alidns/model/DescribeCustomLinesResult.h include/alibabacloud/alidns/model/DescribeDNSSLBSubDomainsRequest.h include/alibabacloud/alidns/model/DescribeDNSSLBSubDomainsResult.h include/alibabacloud/alidns/model/DescribeDnsProductInstanceRequest.h @@ -123,6 +135,8 @@ set(alidns_public_header_model include/alibabacloud/alidns/model/DescribeSubDomainRecordsResult.h include/alibabacloud/alidns/model/DescribeSupportLinesRequest.h include/alibabacloud/alidns/model/DescribeSupportLinesResult.h + include/alibabacloud/alidns/model/DescribeTransferDomainsRequest.h + include/alibabacloud/alidns/model/DescribeTransferDomainsResult.h include/alibabacloud/alidns/model/ExecuteGtmRecoveryPlanRequest.h include/alibabacloud/alidns/model/ExecuteGtmRecoveryPlanResult.h include/alibabacloud/alidns/model/GetMainDomainNameRequest.h @@ -143,6 +157,12 @@ set(alidns_public_header_model include/alibabacloud/alidns/model/SetGtmAccessModeResult.h include/alibabacloud/alidns/model/SetGtmMonitorStatusRequest.h include/alibabacloud/alidns/model/SetGtmMonitorStatusResult.h + include/alibabacloud/alidns/model/TransferDomainRequest.h + include/alibabacloud/alidns/model/TransferDomainResult.h + include/alibabacloud/alidns/model/UnbindInstanceDomainsRequest.h + include/alibabacloud/alidns/model/UnbindInstanceDomainsResult.h + include/alibabacloud/alidns/model/UpdateCustomLineRequest.h + include/alibabacloud/alidns/model/UpdateCustomLineResult.h include/alibabacloud/alidns/model/UpdateDNSSLBWeightRequest.h include/alibabacloud/alidns/model/UpdateDNSSLBWeightResult.h include/alibabacloud/alidns/model/UpdateDomainGroupRequest.h @@ -166,8 +186,12 @@ set(alidns_public_header_model set(alidns_src src/AlidnsClient.cc + src/model/AddCustomLineRequest.cc + src/model/AddCustomLineResult.cc src/model/AddDomainRequest.cc src/model/AddDomainResult.cc + src/model/AddDomainBackupRequest.cc + src/model/AddDomainBackupResult.cc src/model/AddDomainGroupRequest.cc src/model/AddDomainGroupResult.cc src/model/AddDomainRecordRequest.cc @@ -180,10 +204,14 @@ set(alidns_src src/model/AddGtmMonitorResult.cc src/model/AddGtmRecoveryPlanRequest.cc src/model/AddGtmRecoveryPlanResult.cc + src/model/BindInstanceDomainsRequest.cc + src/model/BindInstanceDomainsResult.cc src/model/ChangeDomainGroupRequest.cc src/model/ChangeDomainGroupResult.cc src/model/ChangeDomainOfDnsProductRequest.cc src/model/ChangeDomainOfDnsProductResult.cc + src/model/DeleteCustomLinesRequest.cc + src/model/DeleteCustomLinesResult.cc src/model/DeleteDomainRequest.cc src/model/DeleteDomainResult.cc src/model/DeleteDomainGroupRequest.cc @@ -202,6 +230,10 @@ set(alidns_src src/model/DescribeBatchResultCountResult.cc src/model/DescribeBatchResultDetailRequest.cc src/model/DescribeBatchResultDetailResult.cc + src/model/DescribeCustomLineRequest.cc + src/model/DescribeCustomLineResult.cc + src/model/DescribeCustomLinesRequest.cc + src/model/DescribeCustomLinesResult.cc src/model/DescribeDNSSLBSubDomainsRequest.cc src/model/DescribeDNSSLBSubDomainsResult.cc src/model/DescribeDnsProductInstanceRequest.cc @@ -268,6 +300,8 @@ set(alidns_src src/model/DescribeSubDomainRecordsResult.cc src/model/DescribeSupportLinesRequest.cc src/model/DescribeSupportLinesResult.cc + src/model/DescribeTransferDomainsRequest.cc + src/model/DescribeTransferDomainsResult.cc src/model/ExecuteGtmRecoveryPlanRequest.cc src/model/ExecuteGtmRecoveryPlanResult.cc src/model/GetMainDomainNameRequest.cc @@ -288,6 +322,12 @@ set(alidns_src src/model/SetGtmAccessModeResult.cc src/model/SetGtmMonitorStatusRequest.cc src/model/SetGtmMonitorStatusResult.cc + src/model/TransferDomainRequest.cc + src/model/TransferDomainResult.cc + src/model/UnbindInstanceDomainsRequest.cc + src/model/UnbindInstanceDomainsResult.cc + src/model/UpdateCustomLineRequest.cc + src/model/UpdateCustomLineResult.cc src/model/UpdateDNSSLBWeightRequest.cc src/model/UpdateDNSSLBWeightResult.cc src/model/UpdateDomainGroupRequest.cc diff --git a/alidns/include/alibabacloud/alidns/AlidnsClient.h b/alidns/include/alibabacloud/alidns/AlidnsClient.h index b21424ddb..9339768df 100644 --- a/alidns/include/alibabacloud/alidns/AlidnsClient.h +++ b/alidns/include/alibabacloud/alidns/AlidnsClient.h @@ -22,8 +22,12 @@ #include #include #include "AlidnsExport.h" +#include "model/AddCustomLineRequest.h" +#include "model/AddCustomLineResult.h" #include "model/AddDomainRequest.h" #include "model/AddDomainResult.h" +#include "model/AddDomainBackupRequest.h" +#include "model/AddDomainBackupResult.h" #include "model/AddDomainGroupRequest.h" #include "model/AddDomainGroupResult.h" #include "model/AddDomainRecordRequest.h" @@ -36,10 +40,14 @@ #include "model/AddGtmMonitorResult.h" #include "model/AddGtmRecoveryPlanRequest.h" #include "model/AddGtmRecoveryPlanResult.h" +#include "model/BindInstanceDomainsRequest.h" +#include "model/BindInstanceDomainsResult.h" #include "model/ChangeDomainGroupRequest.h" #include "model/ChangeDomainGroupResult.h" #include "model/ChangeDomainOfDnsProductRequest.h" #include "model/ChangeDomainOfDnsProductResult.h" +#include "model/DeleteCustomLinesRequest.h" +#include "model/DeleteCustomLinesResult.h" #include "model/DeleteDomainRequest.h" #include "model/DeleteDomainResult.h" #include "model/DeleteDomainGroupRequest.h" @@ -58,6 +66,10 @@ #include "model/DescribeBatchResultCountResult.h" #include "model/DescribeBatchResultDetailRequest.h" #include "model/DescribeBatchResultDetailResult.h" +#include "model/DescribeCustomLineRequest.h" +#include "model/DescribeCustomLineResult.h" +#include "model/DescribeCustomLinesRequest.h" +#include "model/DescribeCustomLinesResult.h" #include "model/DescribeDNSSLBSubDomainsRequest.h" #include "model/DescribeDNSSLBSubDomainsResult.h" #include "model/DescribeDnsProductInstanceRequest.h" @@ -124,6 +136,8 @@ #include "model/DescribeSubDomainRecordsResult.h" #include "model/DescribeSupportLinesRequest.h" #include "model/DescribeSupportLinesResult.h" +#include "model/DescribeTransferDomainsRequest.h" +#include "model/DescribeTransferDomainsResult.h" #include "model/ExecuteGtmRecoveryPlanRequest.h" #include "model/ExecuteGtmRecoveryPlanResult.h" #include "model/GetMainDomainNameRequest.h" @@ -144,6 +158,12 @@ #include "model/SetGtmAccessModeResult.h" #include "model/SetGtmMonitorStatusRequest.h" #include "model/SetGtmMonitorStatusResult.h" +#include "model/TransferDomainRequest.h" +#include "model/TransferDomainResult.h" +#include "model/UnbindInstanceDomainsRequest.h" +#include "model/UnbindInstanceDomainsResult.h" +#include "model/UpdateCustomLineRequest.h" +#include "model/UpdateCustomLineResult.h" #include "model/UpdateDNSSLBWeightRequest.h" #include "model/UpdateDNSSLBWeightResult.h" #include "model/UpdateDomainGroupRequest.h" @@ -173,9 +193,15 @@ namespace AlibabaCloud class ALIBABACLOUD_ALIDNS_EXPORT AlidnsClient : public RpcServiceClient { public: + typedef Outcome AddCustomLineOutcome; + typedef std::future AddCustomLineOutcomeCallable; + typedef std::function&)> AddCustomLineAsyncHandler; typedef Outcome AddDomainOutcome; typedef std::future AddDomainOutcomeCallable; typedef std::function&)> AddDomainAsyncHandler; + typedef Outcome AddDomainBackupOutcome; + typedef std::future AddDomainBackupOutcomeCallable; + typedef std::function&)> AddDomainBackupAsyncHandler; typedef Outcome AddDomainGroupOutcome; typedef std::future AddDomainGroupOutcomeCallable; typedef std::function&)> AddDomainGroupAsyncHandler; @@ -194,12 +220,18 @@ namespace AlibabaCloud typedef Outcome AddGtmRecoveryPlanOutcome; typedef std::future AddGtmRecoveryPlanOutcomeCallable; typedef std::function&)> AddGtmRecoveryPlanAsyncHandler; + typedef Outcome BindInstanceDomainsOutcome; + typedef std::future BindInstanceDomainsOutcomeCallable; + typedef std::function&)> BindInstanceDomainsAsyncHandler; typedef Outcome ChangeDomainGroupOutcome; typedef std::future ChangeDomainGroupOutcomeCallable; typedef std::function&)> ChangeDomainGroupAsyncHandler; typedef Outcome ChangeDomainOfDnsProductOutcome; typedef std::future ChangeDomainOfDnsProductOutcomeCallable; typedef std::function&)> ChangeDomainOfDnsProductAsyncHandler; + typedef Outcome DeleteCustomLinesOutcome; + typedef std::future DeleteCustomLinesOutcomeCallable; + typedef std::function&)> DeleteCustomLinesAsyncHandler; typedef Outcome DeleteDomainOutcome; typedef std::future DeleteDomainOutcomeCallable; typedef std::function&)> DeleteDomainAsyncHandler; @@ -227,6 +259,12 @@ namespace AlibabaCloud typedef Outcome DescribeBatchResultDetailOutcome; typedef std::future DescribeBatchResultDetailOutcomeCallable; typedef std::function&)> DescribeBatchResultDetailAsyncHandler; + typedef Outcome DescribeCustomLineOutcome; + typedef std::future DescribeCustomLineOutcomeCallable; + typedef std::function&)> DescribeCustomLineAsyncHandler; + typedef Outcome DescribeCustomLinesOutcome; + typedef std::future DescribeCustomLinesOutcomeCallable; + typedef std::function&)> DescribeCustomLinesAsyncHandler; typedef Outcome DescribeDNSSLBSubDomainsOutcome; typedef std::future DescribeDNSSLBSubDomainsOutcomeCallable; typedef std::function&)> DescribeDNSSLBSubDomainsAsyncHandler; @@ -326,6 +364,9 @@ namespace AlibabaCloud typedef Outcome DescribeSupportLinesOutcome; typedef std::future DescribeSupportLinesOutcomeCallable; typedef std::function&)> DescribeSupportLinesAsyncHandler; + typedef Outcome DescribeTransferDomainsOutcome; + typedef std::future DescribeTransferDomainsOutcomeCallable; + typedef std::function&)> DescribeTransferDomainsAsyncHandler; typedef Outcome ExecuteGtmRecoveryPlanOutcome; typedef std::future ExecuteGtmRecoveryPlanOutcomeCallable; typedef std::function&)> ExecuteGtmRecoveryPlanAsyncHandler; @@ -356,6 +397,15 @@ namespace AlibabaCloud typedef Outcome SetGtmMonitorStatusOutcome; typedef std::future SetGtmMonitorStatusOutcomeCallable; typedef std::function&)> SetGtmMonitorStatusAsyncHandler; + typedef Outcome TransferDomainOutcome; + typedef std::future TransferDomainOutcomeCallable; + typedef std::function&)> TransferDomainAsyncHandler; + typedef Outcome UnbindInstanceDomainsOutcome; + typedef std::future UnbindInstanceDomainsOutcomeCallable; + typedef std::function&)> UnbindInstanceDomainsAsyncHandler; + typedef Outcome UpdateCustomLineOutcome; + typedef std::future UpdateCustomLineOutcomeCallable; + typedef std::function&)> UpdateCustomLineAsyncHandler; typedef Outcome UpdateDNSSLBWeightOutcome; typedef std::future UpdateDNSSLBWeightOutcomeCallable; typedef std::function&)> UpdateDNSSLBWeightAsyncHandler; @@ -391,9 +441,15 @@ namespace AlibabaCloud AlidnsClient(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); AlidnsClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration); ~AlidnsClient(); + AddCustomLineOutcome addCustomLine(const Model::AddCustomLineRequest &request)const; + void addCustomLineAsync(const Model::AddCustomLineRequest& request, const AddCustomLineAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + AddCustomLineOutcomeCallable addCustomLineCallable(const Model::AddCustomLineRequest& request) const; AddDomainOutcome addDomain(const Model::AddDomainRequest &request)const; void addDomainAsync(const Model::AddDomainRequest& request, const AddDomainAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; AddDomainOutcomeCallable addDomainCallable(const Model::AddDomainRequest& request) const; + AddDomainBackupOutcome addDomainBackup(const Model::AddDomainBackupRequest &request)const; + void addDomainBackupAsync(const Model::AddDomainBackupRequest& request, const AddDomainBackupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + AddDomainBackupOutcomeCallable addDomainBackupCallable(const Model::AddDomainBackupRequest& request) const; AddDomainGroupOutcome addDomainGroup(const Model::AddDomainGroupRequest &request)const; void addDomainGroupAsync(const Model::AddDomainGroupRequest& request, const AddDomainGroupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; AddDomainGroupOutcomeCallable addDomainGroupCallable(const Model::AddDomainGroupRequest& request) const; @@ -412,12 +468,18 @@ namespace AlibabaCloud AddGtmRecoveryPlanOutcome addGtmRecoveryPlan(const Model::AddGtmRecoveryPlanRequest &request)const; void addGtmRecoveryPlanAsync(const Model::AddGtmRecoveryPlanRequest& request, const AddGtmRecoveryPlanAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; AddGtmRecoveryPlanOutcomeCallable addGtmRecoveryPlanCallable(const Model::AddGtmRecoveryPlanRequest& request) const; + BindInstanceDomainsOutcome bindInstanceDomains(const Model::BindInstanceDomainsRequest &request)const; + void bindInstanceDomainsAsync(const Model::BindInstanceDomainsRequest& request, const BindInstanceDomainsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + BindInstanceDomainsOutcomeCallable bindInstanceDomainsCallable(const Model::BindInstanceDomainsRequest& request) const; ChangeDomainGroupOutcome changeDomainGroup(const Model::ChangeDomainGroupRequest &request)const; void changeDomainGroupAsync(const Model::ChangeDomainGroupRequest& request, const ChangeDomainGroupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ChangeDomainGroupOutcomeCallable changeDomainGroupCallable(const Model::ChangeDomainGroupRequest& request) const; ChangeDomainOfDnsProductOutcome changeDomainOfDnsProduct(const Model::ChangeDomainOfDnsProductRequest &request)const; void changeDomainOfDnsProductAsync(const Model::ChangeDomainOfDnsProductRequest& request, const ChangeDomainOfDnsProductAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ChangeDomainOfDnsProductOutcomeCallable changeDomainOfDnsProductCallable(const Model::ChangeDomainOfDnsProductRequest& request) const; + DeleteCustomLinesOutcome deleteCustomLines(const Model::DeleteCustomLinesRequest &request)const; + void deleteCustomLinesAsync(const Model::DeleteCustomLinesRequest& request, const DeleteCustomLinesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteCustomLinesOutcomeCallable deleteCustomLinesCallable(const Model::DeleteCustomLinesRequest& request) const; DeleteDomainOutcome deleteDomain(const Model::DeleteDomainRequest &request)const; void deleteDomainAsync(const Model::DeleteDomainRequest& request, const DeleteDomainAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DeleteDomainOutcomeCallable deleteDomainCallable(const Model::DeleteDomainRequest& request) const; @@ -445,6 +507,12 @@ namespace AlibabaCloud DescribeBatchResultDetailOutcome describeBatchResultDetail(const Model::DescribeBatchResultDetailRequest &request)const; void describeBatchResultDetailAsync(const Model::DescribeBatchResultDetailRequest& request, const DescribeBatchResultDetailAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeBatchResultDetailOutcomeCallable describeBatchResultDetailCallable(const Model::DescribeBatchResultDetailRequest& request) const; + DescribeCustomLineOutcome describeCustomLine(const Model::DescribeCustomLineRequest &request)const; + void describeCustomLineAsync(const Model::DescribeCustomLineRequest& request, const DescribeCustomLineAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeCustomLineOutcomeCallable describeCustomLineCallable(const Model::DescribeCustomLineRequest& request) const; + DescribeCustomLinesOutcome describeCustomLines(const Model::DescribeCustomLinesRequest &request)const; + void describeCustomLinesAsync(const Model::DescribeCustomLinesRequest& request, const DescribeCustomLinesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeCustomLinesOutcomeCallable describeCustomLinesCallable(const Model::DescribeCustomLinesRequest& request) const; DescribeDNSSLBSubDomainsOutcome describeDNSSLBSubDomains(const Model::DescribeDNSSLBSubDomainsRequest &request)const; void describeDNSSLBSubDomainsAsync(const Model::DescribeDNSSLBSubDomainsRequest& request, const DescribeDNSSLBSubDomainsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeDNSSLBSubDomainsOutcomeCallable describeDNSSLBSubDomainsCallable(const Model::DescribeDNSSLBSubDomainsRequest& request) const; @@ -544,6 +612,9 @@ namespace AlibabaCloud DescribeSupportLinesOutcome describeSupportLines(const Model::DescribeSupportLinesRequest &request)const; void describeSupportLinesAsync(const Model::DescribeSupportLinesRequest& request, const DescribeSupportLinesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeSupportLinesOutcomeCallable describeSupportLinesCallable(const Model::DescribeSupportLinesRequest& request) const; + DescribeTransferDomainsOutcome describeTransferDomains(const Model::DescribeTransferDomainsRequest &request)const; + void describeTransferDomainsAsync(const Model::DescribeTransferDomainsRequest& request, const DescribeTransferDomainsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeTransferDomainsOutcomeCallable describeTransferDomainsCallable(const Model::DescribeTransferDomainsRequest& request) const; ExecuteGtmRecoveryPlanOutcome executeGtmRecoveryPlan(const Model::ExecuteGtmRecoveryPlanRequest &request)const; void executeGtmRecoveryPlanAsync(const Model::ExecuteGtmRecoveryPlanRequest& request, const ExecuteGtmRecoveryPlanAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ExecuteGtmRecoveryPlanOutcomeCallable executeGtmRecoveryPlanCallable(const Model::ExecuteGtmRecoveryPlanRequest& request) const; @@ -574,6 +645,15 @@ namespace AlibabaCloud SetGtmMonitorStatusOutcome setGtmMonitorStatus(const Model::SetGtmMonitorStatusRequest &request)const; void setGtmMonitorStatusAsync(const Model::SetGtmMonitorStatusRequest& request, const SetGtmMonitorStatusAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; SetGtmMonitorStatusOutcomeCallable setGtmMonitorStatusCallable(const Model::SetGtmMonitorStatusRequest& request) const; + TransferDomainOutcome transferDomain(const Model::TransferDomainRequest &request)const; + void transferDomainAsync(const Model::TransferDomainRequest& request, const TransferDomainAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + TransferDomainOutcomeCallable transferDomainCallable(const Model::TransferDomainRequest& request) const; + UnbindInstanceDomainsOutcome unbindInstanceDomains(const Model::UnbindInstanceDomainsRequest &request)const; + void unbindInstanceDomainsAsync(const Model::UnbindInstanceDomainsRequest& request, const UnbindInstanceDomainsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UnbindInstanceDomainsOutcomeCallable unbindInstanceDomainsCallable(const Model::UnbindInstanceDomainsRequest& request) const; + UpdateCustomLineOutcome updateCustomLine(const Model::UpdateCustomLineRequest &request)const; + void updateCustomLineAsync(const Model::UpdateCustomLineRequest& request, const UpdateCustomLineAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateCustomLineOutcomeCallable updateCustomLineCallable(const Model::UpdateCustomLineRequest& request) const; UpdateDNSSLBWeightOutcome updateDNSSLBWeight(const Model::UpdateDNSSLBWeightRequest &request)const; void updateDNSSLBWeightAsync(const Model::UpdateDNSSLBWeightRequest& request, const UpdateDNSSLBWeightAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; UpdateDNSSLBWeightOutcomeCallable updateDNSSLBWeightCallable(const Model::UpdateDNSSLBWeightRequest& request) const; diff --git a/alidns/include/alibabacloud/alidns/model/AddCustomLineRequest.h b/alidns/include/alibabacloud/alidns/model/AddCustomLineRequest.h new file mode 100644 index 000000000..28fa0c8a6 --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/AddCustomLineRequest.h @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_ALIDNS_MODEL_ADDCUSTOMLINEREQUEST_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_ADDCUSTOMLINEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT AddCustomLineRequest : public RpcServiceRequest + { + struct IpSegment + { + std::string endIp; + std::string startIp; + }; + + public: + AddCustomLineRequest(); + ~AddCustomLineRequest(); + + std::string getDomainName()const; + void setDomainName(const std::string& domainName); + std::vector getIpSegment()const; + void setIpSegment(const std::vector& ipSegment); + std::string getUserClientIp()const; + void setUserClientIp(const std::string& userClientIp); + std::string getLineName()const; + void setLineName(const std::string& lineName); + std::string getLang()const; + void setLang(const std::string& lang); + + private: + std::string domainName_; + std::vector ipSegment_; + std::string userClientIp_; + std::string lineName_; + std::string lang_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_ADDCUSTOMLINEREQUEST_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/AddCustomLineResult.h b/alidns/include/alibabacloud/alidns/model/AddCustomLineResult.h new file mode 100644 index 000000000..503a4a195 --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/AddCustomLineResult.h @@ -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_ALIDNS_MODEL_ADDCUSTOMLINERESULT_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_ADDCUSTOMLINERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT AddCustomLineResult : public ServiceResult + { + public: + + + AddCustomLineResult(); + explicit AddCustomLineResult(const std::string &payload); + ~AddCustomLineResult(); + long getLineId()const; + std::string getLineCode()const; + + protected: + void parse(const std::string &payload); + private: + long lineId_; + std::string lineCode_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_ADDCUSTOMLINERESULT_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/AddDomainBackupRequest.h b/alidns/include/alibabacloud/alidns/model/AddDomainBackupRequest.h new file mode 100644 index 000000000..4b520e0b7 --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/AddDomainBackupRequest.h @@ -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_ALIDNS_MODEL_ADDDOMAINBACKUPREQUEST_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_ADDDOMAINBACKUPREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT AddDomainBackupRequest : public RpcServiceRequest + { + + public: + AddDomainBackupRequest(); + ~AddDomainBackupRequest(); + + std::string getDomainName()const; + void setDomainName(const std::string& domainName); + std::string getPeriodType()const; + void setPeriodType(const std::string& periodType); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + std::string getUserClientIp()const; + void setUserClientIp(const std::string& userClientIp); + std::string getLang()const; + void setLang(const std::string& lang); + + private: + std::string domainName_; + std::string periodType_; + std::string accessKeyId_; + std::string userClientIp_; + std::string lang_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_ADDDOMAINBACKUPREQUEST_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/AddDomainBackupResult.h b/alidns/include/alibabacloud/alidns/model/AddDomainBackupResult.h new file mode 100644 index 000000000..6d2b0285f --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/AddDomainBackupResult.h @@ -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_ALIDNS_MODEL_ADDDOMAINBACKUPRESULT_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_ADDDOMAINBACKUPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT AddDomainBackupResult : public ServiceResult + { + public: + + + AddDomainBackupResult(); + explicit AddDomainBackupResult(const std::string &payload); + ~AddDomainBackupResult(); + std::string getPeriodType()const; + std::string getDomainName()const; + + protected: + void parse(const std::string &payload); + private: + std::string periodType_; + std::string domainName_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_ADDDOMAINBACKUPRESULT_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/BindInstanceDomainsRequest.h b/alidns/include/alibabacloud/alidns/model/BindInstanceDomainsRequest.h new file mode 100644 index 000000000..bf7e1af2f --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/BindInstanceDomainsRequest.h @@ -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_ALIDNS_MODEL_BINDINSTANCEDOMAINSREQUEST_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_BINDINSTANCEDOMAINSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT BindInstanceDomainsRequest : public RpcServiceRequest + { + + public: + BindInstanceDomainsRequest(); + ~BindInstanceDomainsRequest(); + + std::string getDomainNames()const; + void setDomainNames(const std::string& domainNames); + std::string getInstanceId()const; + void setInstanceId(const std::string& instanceId); + std::string getUserClientIp()const; + void setUserClientIp(const std::string& userClientIp); + std::string getLang()const; + void setLang(const std::string& lang); + + private: + std::string domainNames_; + std::string instanceId_; + std::string userClientIp_; + std::string lang_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_BINDINSTANCEDOMAINSREQUEST_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/BindInstanceDomainsResult.h b/alidns/include/alibabacloud/alidns/model/BindInstanceDomainsResult.h new file mode 100644 index 000000000..fb760cbed --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/BindInstanceDomainsResult.h @@ -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_ALIDNS_MODEL_BINDINSTANCEDOMAINSRESULT_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_BINDINSTANCEDOMAINSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT BindInstanceDomainsResult : public ServiceResult + { + public: + + + BindInstanceDomainsResult(); + explicit BindInstanceDomainsResult(const std::string &payload); + ~BindInstanceDomainsResult(); + int getFailedCount()const; + int getSuccessCount()const; + + protected: + void parse(const std::string &payload); + private: + int failedCount_; + int successCount_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_BINDINSTANCEDOMAINSRESULT_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/DeleteCustomLinesRequest.h b/alidns/include/alibabacloud/alidns/model/DeleteCustomLinesRequest.h new file mode 100644 index 000000000..cfd197484 --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/DeleteCustomLinesRequest.h @@ -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_ALIDNS_MODEL_DELETECUSTOMLINESREQUEST_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_DELETECUSTOMLINESREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT DeleteCustomLinesRequest : public RpcServiceRequest + { + + public: + DeleteCustomLinesRequest(); + ~DeleteCustomLinesRequest(); + + std::string getLineIds()const; + void setLineIds(const std::string& lineIds); + std::string getUserClientIp()const; + void setUserClientIp(const std::string& userClientIp); + std::string getLang()const; + void setLang(const std::string& lang); + + private: + std::string lineIds_; + std::string userClientIp_; + std::string lang_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_DELETECUSTOMLINESREQUEST_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/DeleteCustomLinesResult.h b/alidns/include/alibabacloud/alidns/model/DeleteCustomLinesResult.h new file mode 100644 index 000000000..114f70462 --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/DeleteCustomLinesResult.h @@ -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_ALIDNS_MODEL_DELETECUSTOMLINESRESULT_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_DELETECUSTOMLINESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT DeleteCustomLinesResult : public ServiceResult + { + public: + + + DeleteCustomLinesResult(); + explicit DeleteCustomLinesResult(const std::string &payload); + ~DeleteCustomLinesResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_DELETECUSTOMLINESRESULT_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/DescribeBatchResultDetailRequest.h b/alidns/include/alibabacloud/alidns/model/DescribeBatchResultDetailRequest.h index a1a3414cf..3edab0f62 100644 --- a/alidns/include/alibabacloud/alidns/model/DescribeBatchResultDetailRequest.h +++ b/alidns/include/alibabacloud/alidns/model/DescribeBatchResultDetailRequest.h @@ -47,6 +47,8 @@ namespace AlibabaCloud void setLang(const std::string& lang); long getTaskId()const; void setTaskId(long taskId); + std::string getStatus()const; + void setStatus(const std::string& status); private: std::string batchType_; @@ -55,6 +57,7 @@ namespace AlibabaCloud int pageSize_; std::string lang_; long taskId_; + std::string status_; }; } diff --git a/alidns/include/alibabacloud/alidns/model/DescribeCustomLineRequest.h b/alidns/include/alibabacloud/alidns/model/DescribeCustomLineRequest.h new file mode 100644 index 000000000..fc2147b5a --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/DescribeCustomLineRequest.h @@ -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_ALIDNS_MODEL_DESCRIBECUSTOMLINEREQUEST_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBECUSTOMLINEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT DescribeCustomLineRequest : public RpcServiceRequest + { + + public: + DescribeCustomLineRequest(); + ~DescribeCustomLineRequest(); + + long getLineId()const; + void setLineId(long lineId); + std::string getUserClientIp()const; + void setUserClientIp(const std::string& userClientIp); + std::string getLang()const; + void setLang(const std::string& lang); + + private: + long lineId_; + std::string userClientIp_; + std::string lang_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBECUSTOMLINEREQUEST_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/DescribeCustomLineResult.h b/alidns/include/alibabacloud/alidns/model/DescribeCustomLineResult.h new file mode 100644 index 000000000..819d21986 --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/DescribeCustomLineResult.h @@ -0,0 +1,71 @@ +/* + * 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_ALIDNS_MODEL_DESCRIBECUSTOMLINERESULT_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBECUSTOMLINERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT DescribeCustomLineResult : public ServiceResult + { + public: + struct IpSegment + { + std::string startIp; + std::string endIp; + std::string name; + }; + + + DescribeCustomLineResult(); + explicit DescribeCustomLineResult(const std::string &payload); + ~DescribeCustomLineResult(); + std::vector getIpSegmentList()const; + std::string getDomainName()const; + std::string getCreateTime()const; + long getId()const; + std::string getIpSegments()const; + long getCreateTimestamp()const; + std::string getCode()const; + std::string getName()const; + + protected: + void parse(const std::string &payload); + private: + std::vector ipSegmentList_; + std::string domainName_; + std::string createTime_; + long id_; + std::string ipSegments_; + long createTimestamp_; + std::string code_; + std::string name_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBECUSTOMLINERESULT_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/DescribeCustomLinesRequest.h b/alidns/include/alibabacloud/alidns/model/DescribeCustomLinesRequest.h new file mode 100644 index 000000000..81ec950ca --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/DescribeCustomLinesRequest.h @@ -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_ALIDNS_MODEL_DESCRIBECUSTOMLINESREQUEST_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBECUSTOMLINESREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT DescribeCustomLinesRequest : public RpcServiceRequest + { + + public: + DescribeCustomLinesRequest(); + ~DescribeCustomLinesRequest(); + + std::string getDomainName()const; + void setDomainName(const std::string& domainName); + long getPageNumber()const; + void setPageNumber(long pageNumber); + std::string getUserClientIp()const; + void setUserClientIp(const std::string& userClientIp); + long getPageSize()const; + void setPageSize(long pageSize); + std::string getLang()const; + void setLang(const std::string& lang); + + private: + std::string domainName_; + long pageNumber_; + std::string userClientIp_; + long pageSize_; + std::string lang_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBECUSTOMLINESREQUEST_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/DescribeCustomLinesResult.h b/alidns/include/alibabacloud/alidns/model/DescribeCustomLinesResult.h new file mode 100644 index 000000000..0b502161d --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/DescribeCustomLinesResult.h @@ -0,0 +1,75 @@ +/* + * 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_ALIDNS_MODEL_DESCRIBECUSTOMLINESRESULT_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBECUSTOMLINESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT DescribeCustomLinesResult : public ServiceResult + { + public: + struct CustomLine + { + struct IpSegment + { + std::string startIp; + std::string endIp; + std::string name; + }; + std::vector ipSegmentList; + std::string createTime; + long id; + std::string ipSegments; + long createTimestamp; + std::string code; + std::string name; + }; + + + DescribeCustomLinesResult(); + explicit DescribeCustomLinesResult(const std::string &payload); + ~DescribeCustomLinesResult(); + int getPageSize()const; + int getPageNumber()const; + int getTotalPages()const; + std::vector getCustomLines()const; + int getTotalItems()const; + + protected: + void parse(const std::string &payload); + private: + int pageSize_; + int pageNumber_; + int totalPages_; + std::vector customLines_; + int totalItems_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBECUSTOMLINESRESULT_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/DescribeTransferDomainsRequest.h b/alidns/include/alibabacloud/alidns/model/DescribeTransferDomainsRequest.h new file mode 100644 index 000000000..588643304 --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/DescribeTransferDomainsRequest.h @@ -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_ALIDNS_MODEL_DESCRIBETRANSFERDOMAINSREQUEST_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBETRANSFERDOMAINSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT DescribeTransferDomainsRequest : public RpcServiceRequest + { + + public: + DescribeTransferDomainsRequest(); + ~DescribeTransferDomainsRequest(); + + long getPageNumber()const; + void setPageNumber(long pageNumber); + std::string getTransferType()const; + void setTransferType(const std::string& transferType); + std::string getUserClientIp()const; + void setUserClientIp(const std::string& userClientIp); + long getPageSize()const; + void setPageSize(long pageSize); + std::string getLang()const; + void setLang(const std::string& lang); + + private: + long pageNumber_; + std::string transferType_; + std::string userClientIp_; + long pageSize_; + std::string lang_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBETRANSFERDOMAINSREQUEST_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/DescribeTransferDomainsResult.h b/alidns/include/alibabacloud/alidns/model/DescribeTransferDomainsResult.h new file mode 100644 index 000000000..044c84de3 --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/DescribeTransferDomainsResult.h @@ -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_ALIDNS_MODEL_DESCRIBETRANSFERDOMAINSRESULT_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBETRANSFERDOMAINSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT DescribeTransferDomainsResult : public ServiceResult + { + public: + struct DomainTransfer + { + std::string domainName; + std::string createTime; + long fromUserId; + long id; + long createTimestamp; + long targetUserId; + }; + + + DescribeTransferDomainsResult(); + explicit DescribeTransferDomainsResult(const std::string &payload); + ~DescribeTransferDomainsResult(); + long getTotalCount()const; + long getPageSize()const; + long getPageNumber()const; + std::vector getDomainTransfers()const; + + protected: + void parse(const std::string &payload); + private: + long totalCount_; + long pageSize_; + long pageNumber_; + std::vector domainTransfers_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBETRANSFERDOMAINSRESULT_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/TransferDomainRequest.h b/alidns/include/alibabacloud/alidns/model/TransferDomainRequest.h new file mode 100644 index 000000000..eb9de99ad --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/TransferDomainRequest.h @@ -0,0 +1,63 @@ +/* + * 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_ALIDNS_MODEL_TRANSFERDOMAINREQUEST_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_TRANSFERDOMAINREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT TransferDomainRequest : public RpcServiceRequest + { + + public: + TransferDomainRequest(); + ~TransferDomainRequest(); + + std::string getDomainNames()const; + void setDomainNames(const std::string& domainNames); + std::string getRemark()const; + void setRemark(const std::string& remark); + std::string getAccessKeyId()const; + void setAccessKeyId(const std::string& accessKeyId); + long getTargetUserId()const; + void setTargetUserId(long targetUserId); + std::string getUserClientIp()const; + void setUserClientIp(const std::string& userClientIp); + std::string getLang()const; + void setLang(const std::string& lang); + + private: + std::string domainNames_; + std::string remark_; + std::string accessKeyId_; + long targetUserId_; + std::string userClientIp_; + std::string lang_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_TRANSFERDOMAINREQUEST_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/TransferDomainResult.h b/alidns/include/alibabacloud/alidns/model/TransferDomainResult.h new file mode 100644 index 000000000..ce69fc267 --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/TransferDomainResult.h @@ -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_ALIDNS_MODEL_TRANSFERDOMAINRESULT_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_TRANSFERDOMAINRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT TransferDomainResult : public ServiceResult + { + public: + + + TransferDomainResult(); + explicit TransferDomainResult(const std::string &payload); + ~TransferDomainResult(); + long getTaskId()const; + + protected: + void parse(const std::string &payload); + private: + long taskId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_TRANSFERDOMAINRESULT_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/UnbindInstanceDomainsRequest.h b/alidns/include/alibabacloud/alidns/model/UnbindInstanceDomainsRequest.h new file mode 100644 index 000000000..b17a0ffe5 --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/UnbindInstanceDomainsRequest.h @@ -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_ALIDNS_MODEL_UNBINDINSTANCEDOMAINSREQUEST_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_UNBINDINSTANCEDOMAINSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT UnbindInstanceDomainsRequest : public RpcServiceRequest + { + + public: + UnbindInstanceDomainsRequest(); + ~UnbindInstanceDomainsRequest(); + + std::string getDomainNames()const; + void setDomainNames(const std::string& domainNames); + std::string getInstanceId()const; + void setInstanceId(const std::string& instanceId); + std::string getUserClientIp()const; + void setUserClientIp(const std::string& userClientIp); + std::string getLang()const; + void setLang(const std::string& lang); + + private: + std::string domainNames_; + std::string instanceId_; + std::string userClientIp_; + std::string lang_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_UNBINDINSTANCEDOMAINSREQUEST_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/UnbindInstanceDomainsResult.h b/alidns/include/alibabacloud/alidns/model/UnbindInstanceDomainsResult.h new file mode 100644 index 000000000..a45ca917c --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/UnbindInstanceDomainsResult.h @@ -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_ALIDNS_MODEL_UNBINDINSTANCEDOMAINSRESULT_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_UNBINDINSTANCEDOMAINSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT UnbindInstanceDomainsResult : public ServiceResult + { + public: + + + UnbindInstanceDomainsResult(); + explicit UnbindInstanceDomainsResult(const std::string &payload); + ~UnbindInstanceDomainsResult(); + int getFailedCount()const; + int getSuccessCount()const; + + protected: + void parse(const std::string &payload); + private: + int failedCount_; + int successCount_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_UNBINDINSTANCEDOMAINSRESULT_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/UpdateCustomLineRequest.h b/alidns/include/alibabacloud/alidns/model/UpdateCustomLineRequest.h new file mode 100644 index 000000000..5bf49725f --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/UpdateCustomLineRequest.h @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_ALIDNS_MODEL_UPDATECUSTOMLINEREQUEST_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_UPDATECUSTOMLINEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT UpdateCustomLineRequest : public RpcServiceRequest + { + struct IpSegment + { + std::string endIp; + std::string startIp; + }; + + public: + UpdateCustomLineRequest(); + ~UpdateCustomLineRequest(); + + long getLineId()const; + void setLineId(long lineId); + std::vector getIpSegment()const; + void setIpSegment(const std::vector& ipSegment); + std::string getUserClientIp()const; + void setUserClientIp(const std::string& userClientIp); + std::string getLineName()const; + void setLineName(const std::string& lineName); + std::string getLang()const; + void setLang(const std::string& lang); + + private: + long lineId_; + std::vector ipSegment_; + std::string userClientIp_; + std::string lineName_; + std::string lang_; + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_UPDATECUSTOMLINEREQUEST_H_ \ No newline at end of file diff --git a/alidns/include/alibabacloud/alidns/model/UpdateCustomLineResult.h b/alidns/include/alibabacloud/alidns/model/UpdateCustomLineResult.h new file mode 100644 index 000000000..e7ee851ad --- /dev/null +++ b/alidns/include/alibabacloud/alidns/model/UpdateCustomLineResult.h @@ -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_ALIDNS_MODEL_UPDATECUSTOMLINERESULT_H_ +#define ALIBABACLOUD_ALIDNS_MODEL_UPDATECUSTOMLINERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Alidns + { + namespace Model + { + class ALIBABACLOUD_ALIDNS_EXPORT UpdateCustomLineResult : public ServiceResult + { + public: + + + UpdateCustomLineResult(); + explicit UpdateCustomLineResult(const std::string &payload); + ~UpdateCustomLineResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_ALIDNS_MODEL_UPDATECUSTOMLINERESULT_H_ \ No newline at end of file diff --git a/alidns/src/AlidnsClient.cc b/alidns/src/AlidnsClient.cc index 7cb8d1e6e..4db87d06e 100644 --- a/alidns/src/AlidnsClient.cc +++ b/alidns/src/AlidnsClient.cc @@ -51,6 +51,42 @@ AlidnsClient::AlidnsClient(const std::string & accessKeyId, const std::string & AlidnsClient::~AlidnsClient() {} +AlidnsClient::AddCustomLineOutcome AlidnsClient::addCustomLine(const AddCustomLineRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return AddCustomLineOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return AddCustomLineOutcome(AddCustomLineResult(outcome.result())); + else + return AddCustomLineOutcome(outcome.error()); +} + +void AlidnsClient::addCustomLineAsync(const AddCustomLineRequest& request, const AddCustomLineAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, addCustomLine(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AlidnsClient::AddCustomLineOutcomeCallable AlidnsClient::addCustomLineCallable(const AddCustomLineRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->addCustomLine(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + AlidnsClient::AddDomainOutcome AlidnsClient::addDomain(const AddDomainRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -87,6 +123,42 @@ AlidnsClient::AddDomainOutcomeCallable AlidnsClient::addDomainCallable(const Add return task->get_future(); } +AlidnsClient::AddDomainBackupOutcome AlidnsClient::addDomainBackup(const AddDomainBackupRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return AddDomainBackupOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return AddDomainBackupOutcome(AddDomainBackupResult(outcome.result())); + else + return AddDomainBackupOutcome(outcome.error()); +} + +void AlidnsClient::addDomainBackupAsync(const AddDomainBackupRequest& request, const AddDomainBackupAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, addDomainBackup(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AlidnsClient::AddDomainBackupOutcomeCallable AlidnsClient::addDomainBackupCallable(const AddDomainBackupRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->addDomainBackup(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + AlidnsClient::AddDomainGroupOutcome AlidnsClient::addDomainGroup(const AddDomainGroupRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -303,6 +375,42 @@ AlidnsClient::AddGtmRecoveryPlanOutcomeCallable AlidnsClient::addGtmRecoveryPlan return task->get_future(); } +AlidnsClient::BindInstanceDomainsOutcome AlidnsClient::bindInstanceDomains(const BindInstanceDomainsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return BindInstanceDomainsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return BindInstanceDomainsOutcome(BindInstanceDomainsResult(outcome.result())); + else + return BindInstanceDomainsOutcome(outcome.error()); +} + +void AlidnsClient::bindInstanceDomainsAsync(const BindInstanceDomainsRequest& request, const BindInstanceDomainsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, bindInstanceDomains(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AlidnsClient::BindInstanceDomainsOutcomeCallable AlidnsClient::bindInstanceDomainsCallable(const BindInstanceDomainsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->bindInstanceDomains(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + AlidnsClient::ChangeDomainGroupOutcome AlidnsClient::changeDomainGroup(const ChangeDomainGroupRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -375,6 +483,42 @@ AlidnsClient::ChangeDomainOfDnsProductOutcomeCallable AlidnsClient::changeDomain return task->get_future(); } +AlidnsClient::DeleteCustomLinesOutcome AlidnsClient::deleteCustomLines(const DeleteCustomLinesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteCustomLinesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteCustomLinesOutcome(DeleteCustomLinesResult(outcome.result())); + else + return DeleteCustomLinesOutcome(outcome.error()); +} + +void AlidnsClient::deleteCustomLinesAsync(const DeleteCustomLinesRequest& request, const DeleteCustomLinesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteCustomLines(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AlidnsClient::DeleteCustomLinesOutcomeCallable AlidnsClient::deleteCustomLinesCallable(const DeleteCustomLinesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteCustomLines(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + AlidnsClient::DeleteDomainOutcome AlidnsClient::deleteDomain(const DeleteDomainRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -699,6 +843,78 @@ AlidnsClient::DescribeBatchResultDetailOutcomeCallable AlidnsClient::describeBat return task->get_future(); } +AlidnsClient::DescribeCustomLineOutcome AlidnsClient::describeCustomLine(const DescribeCustomLineRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeCustomLineOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeCustomLineOutcome(DescribeCustomLineResult(outcome.result())); + else + return DescribeCustomLineOutcome(outcome.error()); +} + +void AlidnsClient::describeCustomLineAsync(const DescribeCustomLineRequest& request, const DescribeCustomLineAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeCustomLine(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AlidnsClient::DescribeCustomLineOutcomeCallable AlidnsClient::describeCustomLineCallable(const DescribeCustomLineRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeCustomLine(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AlidnsClient::DescribeCustomLinesOutcome AlidnsClient::describeCustomLines(const DescribeCustomLinesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeCustomLinesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeCustomLinesOutcome(DescribeCustomLinesResult(outcome.result())); + else + return DescribeCustomLinesOutcome(outcome.error()); +} + +void AlidnsClient::describeCustomLinesAsync(const DescribeCustomLinesRequest& request, const DescribeCustomLinesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeCustomLines(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AlidnsClient::DescribeCustomLinesOutcomeCallable AlidnsClient::describeCustomLinesCallable(const DescribeCustomLinesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeCustomLines(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + AlidnsClient::DescribeDNSSLBSubDomainsOutcome AlidnsClient::describeDNSSLBSubDomains(const DescribeDNSSLBSubDomainsRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1887,6 +2103,42 @@ AlidnsClient::DescribeSupportLinesOutcomeCallable AlidnsClient::describeSupportL return task->get_future(); } +AlidnsClient::DescribeTransferDomainsOutcome AlidnsClient::describeTransferDomains(const DescribeTransferDomainsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeTransferDomainsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeTransferDomainsOutcome(DescribeTransferDomainsResult(outcome.result())); + else + return DescribeTransferDomainsOutcome(outcome.error()); +} + +void AlidnsClient::describeTransferDomainsAsync(const DescribeTransferDomainsRequest& request, const DescribeTransferDomainsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeTransferDomains(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AlidnsClient::DescribeTransferDomainsOutcomeCallable AlidnsClient::describeTransferDomainsCallable(const DescribeTransferDomainsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeTransferDomains(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + AlidnsClient::ExecuteGtmRecoveryPlanOutcome AlidnsClient::executeGtmRecoveryPlan(const ExecuteGtmRecoveryPlanRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -2247,6 +2499,114 @@ AlidnsClient::SetGtmMonitorStatusOutcomeCallable AlidnsClient::setGtmMonitorStat return task->get_future(); } +AlidnsClient::TransferDomainOutcome AlidnsClient::transferDomain(const TransferDomainRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return TransferDomainOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return TransferDomainOutcome(TransferDomainResult(outcome.result())); + else + return TransferDomainOutcome(outcome.error()); +} + +void AlidnsClient::transferDomainAsync(const TransferDomainRequest& request, const TransferDomainAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, transferDomain(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AlidnsClient::TransferDomainOutcomeCallable AlidnsClient::transferDomainCallable(const TransferDomainRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->transferDomain(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AlidnsClient::UnbindInstanceDomainsOutcome AlidnsClient::unbindInstanceDomains(const UnbindInstanceDomainsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UnbindInstanceDomainsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UnbindInstanceDomainsOutcome(UnbindInstanceDomainsResult(outcome.result())); + else + return UnbindInstanceDomainsOutcome(outcome.error()); +} + +void AlidnsClient::unbindInstanceDomainsAsync(const UnbindInstanceDomainsRequest& request, const UnbindInstanceDomainsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, unbindInstanceDomains(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AlidnsClient::UnbindInstanceDomainsOutcomeCallable AlidnsClient::unbindInstanceDomainsCallable(const UnbindInstanceDomainsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->unbindInstanceDomains(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +AlidnsClient::UpdateCustomLineOutcome AlidnsClient::updateCustomLine(const UpdateCustomLineRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateCustomLineOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateCustomLineOutcome(UpdateCustomLineResult(outcome.result())); + else + return UpdateCustomLineOutcome(outcome.error()); +} + +void AlidnsClient::updateCustomLineAsync(const UpdateCustomLineRequest& request, const UpdateCustomLineAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateCustomLine(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +AlidnsClient::UpdateCustomLineOutcomeCallable AlidnsClient::updateCustomLineCallable(const UpdateCustomLineRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateCustomLine(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + AlidnsClient::UpdateDNSSLBWeightOutcome AlidnsClient::updateDNSSLBWeight(const UpdateDNSSLBWeightRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/alidns/src/model/AddCustomLineRequest.cc b/alidns/src/model/AddCustomLineRequest.cc new file mode 100644 index 000000000..f663e0224 --- /dev/null +++ b/alidns/src/model/AddCustomLineRequest.cc @@ -0,0 +1,89 @@ +/* + * 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 + +using AlibabaCloud::Alidns::Model::AddCustomLineRequest; + +AddCustomLineRequest::AddCustomLineRequest() : + RpcServiceRequest("alidns", "2015-01-09", "AddCustomLine") +{ + setMethod(HttpRequest::Method::Post); +} + +AddCustomLineRequest::~AddCustomLineRequest() +{} + +std::string AddCustomLineRequest::getDomainName()const +{ + return domainName_; +} + +void AddCustomLineRequest::setDomainName(const std::string& domainName) +{ + domainName_ = domainName; + setCoreParameter("DomainName", domainName); +} + +std::vector AddCustomLineRequest::getIpSegment()const +{ + return ipSegment_; +} + +void AddCustomLineRequest::setIpSegment(const std::vector& ipSegment) +{ + ipSegment_ = ipSegment; + for(int dep1 = 0; dep1!= ipSegment.size(); dep1++) { + auto ipSegmentObj = ipSegment.at(dep1); + std::string ipSegmentObjStr = "IpSegment." + std::to_string(dep1); + setCoreParameter(ipSegmentObjStr + ".EndIp", ipSegmentObj.endIp); + setCoreParameter(ipSegmentObjStr + ".StartIp", ipSegmentObj.startIp); + } +} + +std::string AddCustomLineRequest::getUserClientIp()const +{ + return userClientIp_; +} + +void AddCustomLineRequest::setUserClientIp(const std::string& userClientIp) +{ + userClientIp_ = userClientIp; + setCoreParameter("UserClientIp", userClientIp); +} + +std::string AddCustomLineRequest::getLineName()const +{ + return lineName_; +} + +void AddCustomLineRequest::setLineName(const std::string& lineName) +{ + lineName_ = lineName; + setCoreParameter("LineName", lineName); +} + +std::string AddCustomLineRequest::getLang()const +{ + return lang_; +} + +void AddCustomLineRequest::setLang(const std::string& lang) +{ + lang_ = lang; + setCoreParameter("Lang", lang); +} + diff --git a/alidns/src/model/AddCustomLineResult.cc b/alidns/src/model/AddCustomLineResult.cc new file mode 100644 index 000000000..1f6f07838 --- /dev/null +++ b/alidns/src/model/AddCustomLineResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Alidns; +using namespace AlibabaCloud::Alidns::Model; + +AddCustomLineResult::AddCustomLineResult() : + ServiceResult() +{} + +AddCustomLineResult::AddCustomLineResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +AddCustomLineResult::~AddCustomLineResult() +{} + +void AddCustomLineResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["LineId"].isNull()) + lineId_ = std::stol(value["LineId"].asString()); + if(!value["LineCode"].isNull()) + lineCode_ = value["LineCode"].asString(); + +} + +long AddCustomLineResult::getLineId()const +{ + return lineId_; +} + +std::string AddCustomLineResult::getLineCode()const +{ + return lineCode_; +} + diff --git a/alidns/src/model/AddDomainBackupRequest.cc b/alidns/src/model/AddDomainBackupRequest.cc new file mode 100644 index 000000000..bfa5a2f14 --- /dev/null +++ b/alidns/src/model/AddDomainBackupRequest.cc @@ -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 + +using AlibabaCloud::Alidns::Model::AddDomainBackupRequest; + +AddDomainBackupRequest::AddDomainBackupRequest() : + RpcServiceRequest("alidns", "2015-01-09", "AddDomainBackup") +{ + setMethod(HttpRequest::Method::Post); +} + +AddDomainBackupRequest::~AddDomainBackupRequest() +{} + +std::string AddDomainBackupRequest::getDomainName()const +{ + return domainName_; +} + +void AddDomainBackupRequest::setDomainName(const std::string& domainName) +{ + domainName_ = domainName; + setCoreParameter("DomainName", domainName); +} + +std::string AddDomainBackupRequest::getPeriodType()const +{ + return periodType_; +} + +void AddDomainBackupRequest::setPeriodType(const std::string& periodType) +{ + periodType_ = periodType; + setCoreParameter("PeriodType", periodType); +} + +std::string AddDomainBackupRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void AddDomainBackupRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +std::string AddDomainBackupRequest::getUserClientIp()const +{ + return userClientIp_; +} + +void AddDomainBackupRequest::setUserClientIp(const std::string& userClientIp) +{ + userClientIp_ = userClientIp; + setCoreParameter("UserClientIp", userClientIp); +} + +std::string AddDomainBackupRequest::getLang()const +{ + return lang_; +} + +void AddDomainBackupRequest::setLang(const std::string& lang) +{ + lang_ = lang; + setCoreParameter("Lang", lang); +} + diff --git a/alidns/src/model/AddDomainBackupResult.cc b/alidns/src/model/AddDomainBackupResult.cc new file mode 100644 index 000000000..5f4da9100 --- /dev/null +++ b/alidns/src/model/AddDomainBackupResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Alidns; +using namespace AlibabaCloud::Alidns::Model; + +AddDomainBackupResult::AddDomainBackupResult() : + ServiceResult() +{} + +AddDomainBackupResult::AddDomainBackupResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +AddDomainBackupResult::~AddDomainBackupResult() +{} + +void AddDomainBackupResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["DomainName"].isNull()) + domainName_ = value["DomainName"].asString(); + if(!value["PeriodType"].isNull()) + periodType_ = value["PeriodType"].asString(); + +} + +std::string AddDomainBackupResult::getPeriodType()const +{ + return periodType_; +} + +std::string AddDomainBackupResult::getDomainName()const +{ + return domainName_; +} + diff --git a/alidns/src/model/AddGtmAddressPoolRequest.cc b/alidns/src/model/AddGtmAddressPoolRequest.cc index 0834bb859..3103a4150 100644 --- a/alidns/src/model/AddGtmAddressPoolRequest.cc +++ b/alidns/src/model/AddGtmAddressPoolRequest.cc @@ -101,13 +101,12 @@ std::vector AddGtmAddressPoolRequest::getAddr()c void AddGtmAddressPoolRequest::setAddr(const std::vector& addr) { addr_ = addr; - int i = 0; - for(int i = 0; i!= addr.size(); i++) { - auto obj = addr.at(i); - std::string str ="Addr."+ std::to_string(i); - setCoreParameter(str + ".Mode", obj.mode); - setCoreParameter(str + ".LbaWeight", std::to_string(obj.lbaWeight)); - setCoreParameter(str + ".Value", obj.value); + for(int dep1 = 0; dep1!= addr.size(); dep1++) { + auto addrObj = addr.at(dep1); + std::string addrObjStr = "Addr." + std::to_string(dep1); + setCoreParameter(addrObjStr + ".Mode", addrObj.mode); + setCoreParameter(addrObjStr + ".LbaWeight", std::to_string(addrObj.lbaWeight)); + setCoreParameter(addrObjStr + ".Value", addrObj.value); } } @@ -185,12 +184,11 @@ std::vector AddGtmAddressPoolRequest::get void AddGtmAddressPoolRequest::setIspCityNode(const std::vector& ispCityNode) { ispCityNode_ = ispCityNode; - int i = 0; - for(int i = 0; i!= ispCityNode.size(); i++) { - auto obj = ispCityNode.at(i); - std::string str ="IspCityNode."+ std::to_string(i); - setCoreParameter(str + ".CityCode", obj.cityCode); - setCoreParameter(str + ".IspCode", obj.ispCode); + for(int dep1 = 0; dep1!= ispCityNode.size(); dep1++) { + auto ispCityNodeObj = ispCityNode.at(dep1); + std::string ispCityNodeObjStr = "IspCityNode." + std::to_string(dep1); + setCoreParameter(ispCityNodeObjStr + ".CityCode", ispCityNodeObj.cityCode); + setCoreParameter(ispCityNodeObjStr + ".IspCode", ispCityNodeObj.ispCode); } } diff --git a/alidns/src/model/AddGtmMonitorRequest.cc b/alidns/src/model/AddGtmMonitorRequest.cc index 0c4d3e9b7..309b3db2c 100644 --- a/alidns/src/model/AddGtmMonitorRequest.cc +++ b/alidns/src/model/AddGtmMonitorRequest.cc @@ -123,12 +123,11 @@ std::vector AddGtmMonitorRequest::getIspCityN void AddGtmMonitorRequest::setIspCityNode(const std::vector& ispCityNode) { ispCityNode_ = ispCityNode; - int i = 0; - for(int i = 0; i!= ispCityNode.size(); i++) { - auto obj = ispCityNode.at(i); - std::string str ="IspCityNode."+ std::to_string(i); - setCoreParameter(str + ".CityCode", obj.cityCode); - setCoreParameter(str + ".IspCode", obj.ispCode); + for(int dep1 = 0; dep1!= ispCityNode.size(); dep1++) { + auto ispCityNodeObj = ispCityNode.at(dep1); + std::string ispCityNodeObjStr = "IspCityNode." + std::to_string(dep1); + setCoreParameter(ispCityNodeObjStr + ".CityCode", ispCityNodeObj.cityCode); + setCoreParameter(ispCityNodeObjStr + ".IspCode", ispCityNodeObj.ispCode); } } diff --git a/alidns/src/model/BindInstanceDomainsRequest.cc b/alidns/src/model/BindInstanceDomainsRequest.cc new file mode 100644 index 000000000..89b2ba2bc --- /dev/null +++ b/alidns/src/model/BindInstanceDomainsRequest.cc @@ -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 + +using AlibabaCloud::Alidns::Model::BindInstanceDomainsRequest; + +BindInstanceDomainsRequest::BindInstanceDomainsRequest() : + RpcServiceRequest("alidns", "2015-01-09", "BindInstanceDomains") +{ + setMethod(HttpRequest::Method::Post); +} + +BindInstanceDomainsRequest::~BindInstanceDomainsRequest() +{} + +std::string BindInstanceDomainsRequest::getDomainNames()const +{ + return domainNames_; +} + +void BindInstanceDomainsRequest::setDomainNames(const std::string& domainNames) +{ + domainNames_ = domainNames; + setCoreParameter("DomainNames", domainNames); +} + +std::string BindInstanceDomainsRequest::getInstanceId()const +{ + return instanceId_; +} + +void BindInstanceDomainsRequest::setInstanceId(const std::string& instanceId) +{ + instanceId_ = instanceId; + setCoreParameter("InstanceId", instanceId); +} + +std::string BindInstanceDomainsRequest::getUserClientIp()const +{ + return userClientIp_; +} + +void BindInstanceDomainsRequest::setUserClientIp(const std::string& userClientIp) +{ + userClientIp_ = userClientIp; + setCoreParameter("UserClientIp", userClientIp); +} + +std::string BindInstanceDomainsRequest::getLang()const +{ + return lang_; +} + +void BindInstanceDomainsRequest::setLang(const std::string& lang) +{ + lang_ = lang; + setCoreParameter("Lang", lang); +} + diff --git a/alidns/src/model/BindInstanceDomainsResult.cc b/alidns/src/model/BindInstanceDomainsResult.cc new file mode 100644 index 000000000..559b03825 --- /dev/null +++ b/alidns/src/model/BindInstanceDomainsResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Alidns; +using namespace AlibabaCloud::Alidns::Model; + +BindInstanceDomainsResult::BindInstanceDomainsResult() : + ServiceResult() +{} + +BindInstanceDomainsResult::BindInstanceDomainsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +BindInstanceDomainsResult::~BindInstanceDomainsResult() +{} + +void BindInstanceDomainsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["SuccessCount"].isNull()) + successCount_ = std::stoi(value["SuccessCount"].asString()); + if(!value["FailedCount"].isNull()) + failedCount_ = std::stoi(value["FailedCount"].asString()); + +} + +int BindInstanceDomainsResult::getFailedCount()const +{ + return failedCount_; +} + +int BindInstanceDomainsResult::getSuccessCount()const +{ + return successCount_; +} + diff --git a/alidns/src/model/DeleteCustomLinesRequest.cc b/alidns/src/model/DeleteCustomLinesRequest.cc new file mode 100644 index 000000000..37538212e --- /dev/null +++ b/alidns/src/model/DeleteCustomLinesRequest.cc @@ -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 + +using AlibabaCloud::Alidns::Model::DeleteCustomLinesRequest; + +DeleteCustomLinesRequest::DeleteCustomLinesRequest() : + RpcServiceRequest("alidns", "2015-01-09", "DeleteCustomLines") +{ + setMethod(HttpRequest::Method::Post); +} + +DeleteCustomLinesRequest::~DeleteCustomLinesRequest() +{} + +std::string DeleteCustomLinesRequest::getLineIds()const +{ + return lineIds_; +} + +void DeleteCustomLinesRequest::setLineIds(const std::string& lineIds) +{ + lineIds_ = lineIds; + setCoreParameter("LineIds", lineIds); +} + +std::string DeleteCustomLinesRequest::getUserClientIp()const +{ + return userClientIp_; +} + +void DeleteCustomLinesRequest::setUserClientIp(const std::string& userClientIp) +{ + userClientIp_ = userClientIp; + setCoreParameter("UserClientIp", userClientIp); +} + +std::string DeleteCustomLinesRequest::getLang()const +{ + return lang_; +} + +void DeleteCustomLinesRequest::setLang(const std::string& lang) +{ + lang_ = lang; + setCoreParameter("Lang", lang); +} + diff --git a/alidns/src/model/DeleteCustomLinesResult.cc b/alidns/src/model/DeleteCustomLinesResult.cc new file mode 100644 index 000000000..5f63db0db --- /dev/null +++ b/alidns/src/model/DeleteCustomLinesResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Alidns; +using namespace AlibabaCloud::Alidns::Model; + +DeleteCustomLinesResult::DeleteCustomLinesResult() : + ServiceResult() +{} + +DeleteCustomLinesResult::DeleteCustomLinesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteCustomLinesResult::~DeleteCustomLinesResult() +{} + +void DeleteCustomLinesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/alidns/src/model/DescribeBatchResultDetailRequest.cc b/alidns/src/model/DescribeBatchResultDetailRequest.cc index f42b69387..7237d8e25 100644 --- a/alidns/src/model/DescribeBatchResultDetailRequest.cc +++ b/alidns/src/model/DescribeBatchResultDetailRequest.cc @@ -93,3 +93,14 @@ void DescribeBatchResultDetailRequest::setTaskId(long taskId) setCoreParameter("TaskId", std::to_string(taskId)); } +std::string DescribeBatchResultDetailRequest::getStatus()const +{ + return status_; +} + +void DescribeBatchResultDetailRequest::setStatus(const std::string& status) +{ + status_ = status; + setCoreParameter("Status", status); +} + diff --git a/alidns/src/model/DescribeCustomLineRequest.cc b/alidns/src/model/DescribeCustomLineRequest.cc new file mode 100644 index 000000000..0fc44167c --- /dev/null +++ b/alidns/src/model/DescribeCustomLineRequest.cc @@ -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 + +using AlibabaCloud::Alidns::Model::DescribeCustomLineRequest; + +DescribeCustomLineRequest::DescribeCustomLineRequest() : + RpcServiceRequest("alidns", "2015-01-09", "DescribeCustomLine") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeCustomLineRequest::~DescribeCustomLineRequest() +{} + +long DescribeCustomLineRequest::getLineId()const +{ + return lineId_; +} + +void DescribeCustomLineRequest::setLineId(long lineId) +{ + lineId_ = lineId; + setCoreParameter("LineId", std::to_string(lineId)); +} + +std::string DescribeCustomLineRequest::getUserClientIp()const +{ + return userClientIp_; +} + +void DescribeCustomLineRequest::setUserClientIp(const std::string& userClientIp) +{ + userClientIp_ = userClientIp; + setCoreParameter("UserClientIp", userClientIp); +} + +std::string DescribeCustomLineRequest::getLang()const +{ + return lang_; +} + +void DescribeCustomLineRequest::setLang(const std::string& lang) +{ + lang_ = lang; + setCoreParameter("Lang", lang); +} + diff --git a/alidns/src/model/DescribeCustomLineResult.cc b/alidns/src/model/DescribeCustomLineResult.cc new file mode 100644 index 000000000..e1fdecc72 --- /dev/null +++ b/alidns/src/model/DescribeCustomLineResult.cc @@ -0,0 +1,110 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Alidns; +using namespace AlibabaCloud::Alidns::Model; + +DescribeCustomLineResult::DescribeCustomLineResult() : + ServiceResult() +{} + +DescribeCustomLineResult::DescribeCustomLineResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeCustomLineResult::~DescribeCustomLineResult() +{} + +void DescribeCustomLineResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allIpSegmentListNode = value["IpSegmentList"]["IpSegment"]; + for (auto valueIpSegmentListIpSegment : allIpSegmentListNode) + { + IpSegment ipSegmentListObject; + if(!valueIpSegmentListIpSegment["Name"].isNull()) + ipSegmentListObject.name = valueIpSegmentListIpSegment["Name"].asString(); + if(!valueIpSegmentListIpSegment["StartIp"].isNull()) + ipSegmentListObject.startIp = valueIpSegmentListIpSegment["StartIp"].asString(); + if(!valueIpSegmentListIpSegment["EndIp"].isNull()) + ipSegmentListObject.endIp = valueIpSegmentListIpSegment["EndIp"].asString(); + ipSegmentList_.push_back(ipSegmentListObject); + } + if(!value["Id"].isNull()) + id_ = std::stol(value["Id"].asString()); + if(!value["Name"].isNull()) + name_ = value["Name"].asString(); + if(!value["DomainName"].isNull()) + domainName_ = value["DomainName"].asString(); + if(!value["CreateTime"].isNull()) + createTime_ = value["CreateTime"].asString(); + if(!value["CreateTimestamp"].isNull()) + createTimestamp_ = std::stol(value["CreateTimestamp"].asString()); + if(!value["IpSegments"].isNull()) + ipSegments_ = value["IpSegments"].asString(); + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + +} + +std::vector DescribeCustomLineResult::getIpSegmentList()const +{ + return ipSegmentList_; +} + +std::string DescribeCustomLineResult::getDomainName()const +{ + return domainName_; +} + +std::string DescribeCustomLineResult::getCreateTime()const +{ + return createTime_; +} + +long DescribeCustomLineResult::getId()const +{ + return id_; +} + +std::string DescribeCustomLineResult::getIpSegments()const +{ + return ipSegments_; +} + +long DescribeCustomLineResult::getCreateTimestamp()const +{ + return createTimestamp_; +} + +std::string DescribeCustomLineResult::getCode()const +{ + return code_; +} + +std::string DescribeCustomLineResult::getName()const +{ + return name_; +} + diff --git a/alidns/src/model/DescribeCustomLinesRequest.cc b/alidns/src/model/DescribeCustomLinesRequest.cc new file mode 100644 index 000000000..c49b55e21 --- /dev/null +++ b/alidns/src/model/DescribeCustomLinesRequest.cc @@ -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 + +using AlibabaCloud::Alidns::Model::DescribeCustomLinesRequest; + +DescribeCustomLinesRequest::DescribeCustomLinesRequest() : + RpcServiceRequest("alidns", "2015-01-09", "DescribeCustomLines") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeCustomLinesRequest::~DescribeCustomLinesRequest() +{} + +std::string DescribeCustomLinesRequest::getDomainName()const +{ + return domainName_; +} + +void DescribeCustomLinesRequest::setDomainName(const std::string& domainName) +{ + domainName_ = domainName; + setCoreParameter("DomainName", domainName); +} + +long DescribeCustomLinesRequest::getPageNumber()const +{ + return pageNumber_; +} + +void DescribeCustomLinesRequest::setPageNumber(long pageNumber) +{ + pageNumber_ = pageNumber; + setCoreParameter("PageNumber", std::to_string(pageNumber)); +} + +std::string DescribeCustomLinesRequest::getUserClientIp()const +{ + return userClientIp_; +} + +void DescribeCustomLinesRequest::setUserClientIp(const std::string& userClientIp) +{ + userClientIp_ = userClientIp; + setCoreParameter("UserClientIp", userClientIp); +} + +long DescribeCustomLinesRequest::getPageSize()const +{ + return pageSize_; +} + +void DescribeCustomLinesRequest::setPageSize(long pageSize) +{ + pageSize_ = pageSize; + setCoreParameter("PageSize", std::to_string(pageSize)); +} + +std::string DescribeCustomLinesRequest::getLang()const +{ + return lang_; +} + +void DescribeCustomLinesRequest::setLang(const std::string& lang) +{ + lang_ = lang; + setCoreParameter("Lang", lang); +} + diff --git a/alidns/src/model/DescribeCustomLinesResult.cc b/alidns/src/model/DescribeCustomLinesResult.cc new file mode 100644 index 000000000..7cb85ed0a --- /dev/null +++ b/alidns/src/model/DescribeCustomLinesResult.cc @@ -0,0 +1,107 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Alidns; +using namespace AlibabaCloud::Alidns::Model; + +DescribeCustomLinesResult::DescribeCustomLinesResult() : + ServiceResult() +{} + +DescribeCustomLinesResult::DescribeCustomLinesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeCustomLinesResult::~DescribeCustomLinesResult() +{} + +void DescribeCustomLinesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allCustomLinesNode = value["CustomLines"]["CustomLine"]; + for (auto valueCustomLinesCustomLine : allCustomLinesNode) + { + CustomLine customLinesObject; + if(!valueCustomLinesCustomLine["Id"].isNull()) + customLinesObject.id = std::stol(valueCustomLinesCustomLine["Id"].asString()); + if(!valueCustomLinesCustomLine["Name"].isNull()) + customLinesObject.name = valueCustomLinesCustomLine["Name"].asString(); + if(!valueCustomLinesCustomLine["CreateTime"].isNull()) + customLinesObject.createTime = valueCustomLinesCustomLine["CreateTime"].asString(); + if(!valueCustomLinesCustomLine["CreateTimestamp"].isNull()) + customLinesObject.createTimestamp = std::stol(valueCustomLinesCustomLine["CreateTimestamp"].asString()); + if(!valueCustomLinesCustomLine["IpSegments"].isNull()) + customLinesObject.ipSegments = valueCustomLinesCustomLine["IpSegments"].asString(); + if(!valueCustomLinesCustomLine["Code"].isNull()) + customLinesObject.code = valueCustomLinesCustomLine["Code"].asString(); + auto allIpSegmentListNode = allCustomLinesNode["IpSegmentList"]["IpSegment"]; + for (auto allCustomLinesNodeIpSegmentListIpSegment : allIpSegmentListNode) + { + CustomLine::IpSegment ipSegmentListObject; + if(!allCustomLinesNodeIpSegmentListIpSegment["Name"].isNull()) + ipSegmentListObject.name = allCustomLinesNodeIpSegmentListIpSegment["Name"].asString(); + if(!allCustomLinesNodeIpSegmentListIpSegment["StartIp"].isNull()) + ipSegmentListObject.startIp = allCustomLinesNodeIpSegmentListIpSegment["StartIp"].asString(); + if(!allCustomLinesNodeIpSegmentListIpSegment["EndIp"].isNull()) + ipSegmentListObject.endIp = allCustomLinesNodeIpSegmentListIpSegment["EndIp"].asString(); + customLinesObject.ipSegmentList.push_back(ipSegmentListObject); + } + customLines_.push_back(customLinesObject); + } + if(!value["TotalItems"].isNull()) + totalItems_ = std::stoi(value["TotalItems"].asString()); + if(!value["PageNumber"].isNull()) + pageNumber_ = std::stoi(value["PageNumber"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stoi(value["PageSize"].asString()); + if(!value["TotalPages"].isNull()) + totalPages_ = std::stoi(value["TotalPages"].asString()); + +} + +int DescribeCustomLinesResult::getPageSize()const +{ + return pageSize_; +} + +int DescribeCustomLinesResult::getPageNumber()const +{ + return pageNumber_; +} + +int DescribeCustomLinesResult::getTotalPages()const +{ + return totalPages_; +} + +std::vector DescribeCustomLinesResult::getCustomLines()const +{ + return customLines_; +} + +int DescribeCustomLinesResult::getTotalItems()const +{ + return totalItems_; +} + diff --git a/alidns/src/model/DescribeTransferDomainsRequest.cc b/alidns/src/model/DescribeTransferDomainsRequest.cc new file mode 100644 index 000000000..a58c04a02 --- /dev/null +++ b/alidns/src/model/DescribeTransferDomainsRequest.cc @@ -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 + +using AlibabaCloud::Alidns::Model::DescribeTransferDomainsRequest; + +DescribeTransferDomainsRequest::DescribeTransferDomainsRequest() : + RpcServiceRequest("alidns", "2015-01-09", "DescribeTransferDomains") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeTransferDomainsRequest::~DescribeTransferDomainsRequest() +{} + +long DescribeTransferDomainsRequest::getPageNumber()const +{ + return pageNumber_; +} + +void DescribeTransferDomainsRequest::setPageNumber(long pageNumber) +{ + pageNumber_ = pageNumber; + setCoreParameter("PageNumber", std::to_string(pageNumber)); +} + +std::string DescribeTransferDomainsRequest::getTransferType()const +{ + return transferType_; +} + +void DescribeTransferDomainsRequest::setTransferType(const std::string& transferType) +{ + transferType_ = transferType; + setCoreParameter("TransferType", transferType); +} + +std::string DescribeTransferDomainsRequest::getUserClientIp()const +{ + return userClientIp_; +} + +void DescribeTransferDomainsRequest::setUserClientIp(const std::string& userClientIp) +{ + userClientIp_ = userClientIp; + setCoreParameter("UserClientIp", userClientIp); +} + +long DescribeTransferDomainsRequest::getPageSize()const +{ + return pageSize_; +} + +void DescribeTransferDomainsRequest::setPageSize(long pageSize) +{ + pageSize_ = pageSize; + setCoreParameter("PageSize", std::to_string(pageSize)); +} + +std::string DescribeTransferDomainsRequest::getLang()const +{ + return lang_; +} + +void DescribeTransferDomainsRequest::setLang(const std::string& lang) +{ + lang_ = lang; + setCoreParameter("Lang", lang); +} + diff --git a/alidns/src/model/DescribeTransferDomainsResult.cc b/alidns/src/model/DescribeTransferDomainsResult.cc new file mode 100644 index 000000000..1946d0c33 --- /dev/null +++ b/alidns/src/model/DescribeTransferDomainsResult.cc @@ -0,0 +1,88 @@ +/* + * 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 +#include + +using namespace AlibabaCloud::Alidns; +using namespace AlibabaCloud::Alidns::Model; + +DescribeTransferDomainsResult::DescribeTransferDomainsResult() : + ServiceResult() +{} + +DescribeTransferDomainsResult::DescribeTransferDomainsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeTransferDomainsResult::~DescribeTransferDomainsResult() +{} + +void DescribeTransferDomainsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allDomainTransfersNode = value["DomainTransfers"]["DomainTransfer"]; + for (auto valueDomainTransfersDomainTransfer : allDomainTransfersNode) + { + DomainTransfer domainTransfersObject; + if(!valueDomainTransfersDomainTransfer["DomainName"].isNull()) + domainTransfersObject.domainName = valueDomainTransfersDomainTransfer["DomainName"].asString(); + if(!valueDomainTransfersDomainTransfer["CreateTime"].isNull()) + domainTransfersObject.createTime = valueDomainTransfersDomainTransfer["CreateTime"].asString(); + if(!valueDomainTransfersDomainTransfer["CreateTimestamp"].isNull()) + domainTransfersObject.createTimestamp = std::stol(valueDomainTransfersDomainTransfer["CreateTimestamp"].asString()); + if(!valueDomainTransfersDomainTransfer["FromUserId"].isNull()) + domainTransfersObject.fromUserId = std::stol(valueDomainTransfersDomainTransfer["FromUserId"].asString()); + if(!valueDomainTransfersDomainTransfer["TargetUserId"].isNull()) + domainTransfersObject.targetUserId = std::stol(valueDomainTransfersDomainTransfer["TargetUserId"].asString()); + if(!valueDomainTransfersDomainTransfer["Id"].isNull()) + domainTransfersObject.id = std::stol(valueDomainTransfersDomainTransfer["Id"].asString()); + domainTransfers_.push_back(domainTransfersObject); + } + if(!value["TotalCount"].isNull()) + totalCount_ = std::stol(value["TotalCount"].asString()); + if(!value["PageNumber"].isNull()) + pageNumber_ = std::stol(value["PageNumber"].asString()); + if(!value["PageSize"].isNull()) + pageSize_ = std::stol(value["PageSize"].asString()); + +} + +long DescribeTransferDomainsResult::getTotalCount()const +{ + return totalCount_; +} + +long DescribeTransferDomainsResult::getPageSize()const +{ + return pageSize_; +} + +long DescribeTransferDomainsResult::getPageNumber()const +{ + return pageNumber_; +} + +std::vector DescribeTransferDomainsResult::getDomainTransfers()const +{ + return domainTransfers_; +} + diff --git a/alidns/src/model/OperateBatchDomainRequest.cc b/alidns/src/model/OperateBatchDomainRequest.cc index 7cd5a74fa..d42c1c6c1 100644 --- a/alidns/src/model/OperateBatchDomainRequest.cc +++ b/alidns/src/model/OperateBatchDomainRequest.cc @@ -35,20 +35,19 @@ std::vector OperateBatchDomainReque void OperateBatchDomainRequest::setDomainRecordInfo(const std::vector& domainRecordInfo) { domainRecordInfo_ = domainRecordInfo; - int i = 0; - for(int i = 0; i!= domainRecordInfo.size(); i++) { - auto obj = domainRecordInfo.at(i); - std::string str ="DomainRecordInfo."+ std::to_string(i); - setCoreParameter(str + ".Rr", obj.rr); - setCoreParameter(str + ".NewType", obj.newType); - setCoreParameter(str + ".NewValue", obj.newValue); - setCoreParameter(str + ".Line", obj.line); - setCoreParameter(str + ".Domain", obj.domain); - setCoreParameter(str + ".Type", obj.type); - setCoreParameter(str + ".Priority", std::to_string(obj.priority)); - setCoreParameter(str + ".Value", obj.value); - setCoreParameter(str + ".Ttl", std::to_string(obj.ttl)); - setCoreParameter(str + ".NewRr", obj.newRr); + for(int dep1 = 0; dep1!= domainRecordInfo.size(); dep1++) { + auto domainRecordInfoObj = domainRecordInfo.at(dep1); + std::string domainRecordInfoObjStr = "DomainRecordInfo." + std::to_string(dep1); + setCoreParameter(domainRecordInfoObjStr + ".Rr", domainRecordInfoObj.rr); + setCoreParameter(domainRecordInfoObjStr + ".NewType", domainRecordInfoObj.newType); + setCoreParameter(domainRecordInfoObjStr + ".NewValue", domainRecordInfoObj.newValue); + setCoreParameter(domainRecordInfoObjStr + ".Line", domainRecordInfoObj.line); + setCoreParameter(domainRecordInfoObjStr + ".Domain", domainRecordInfoObj.domain); + setCoreParameter(domainRecordInfoObjStr + ".Type", domainRecordInfoObj.type); + setCoreParameter(domainRecordInfoObjStr + ".Priority", std::to_string(domainRecordInfoObj.priority)); + setCoreParameter(domainRecordInfoObjStr + ".Value", domainRecordInfoObj.value); + setCoreParameter(domainRecordInfoObjStr + ".Ttl", std::to_string(domainRecordInfoObj.ttl)); + setCoreParameter(domainRecordInfoObjStr + ".NewRr", domainRecordInfoObj.newRr); } } diff --git a/alidns/src/model/TransferDomainRequest.cc b/alidns/src/model/TransferDomainRequest.cc new file mode 100644 index 000000000..f28cd427d --- /dev/null +++ b/alidns/src/model/TransferDomainRequest.cc @@ -0,0 +1,95 @@ +/* + * 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 + +using AlibabaCloud::Alidns::Model::TransferDomainRequest; + +TransferDomainRequest::TransferDomainRequest() : + RpcServiceRequest("alidns", "2015-01-09", "TransferDomain") +{ + setMethod(HttpRequest::Method::Post); +} + +TransferDomainRequest::~TransferDomainRequest() +{} + +std::string TransferDomainRequest::getDomainNames()const +{ + return domainNames_; +} + +void TransferDomainRequest::setDomainNames(const std::string& domainNames) +{ + domainNames_ = domainNames; + setCoreParameter("DomainNames", domainNames); +} + +std::string TransferDomainRequest::getRemark()const +{ + return remark_; +} + +void TransferDomainRequest::setRemark(const std::string& remark) +{ + remark_ = remark; + setCoreParameter("Remark", remark); +} + +std::string TransferDomainRequest::getAccessKeyId()const +{ + return accessKeyId_; +} + +void TransferDomainRequest::setAccessKeyId(const std::string& accessKeyId) +{ + accessKeyId_ = accessKeyId; + setCoreParameter("AccessKeyId", accessKeyId); +} + +long TransferDomainRequest::getTargetUserId()const +{ + return targetUserId_; +} + +void TransferDomainRequest::setTargetUserId(long targetUserId) +{ + targetUserId_ = targetUserId; + setCoreParameter("TargetUserId", std::to_string(targetUserId)); +} + +std::string TransferDomainRequest::getUserClientIp()const +{ + return userClientIp_; +} + +void TransferDomainRequest::setUserClientIp(const std::string& userClientIp) +{ + userClientIp_ = userClientIp; + setCoreParameter("UserClientIp", userClientIp); +} + +std::string TransferDomainRequest::getLang()const +{ + return lang_; +} + +void TransferDomainRequest::setLang(const std::string& lang) +{ + lang_ = lang; + setCoreParameter("Lang", lang); +} + diff --git a/alidns/src/model/TransferDomainResult.cc b/alidns/src/model/TransferDomainResult.cc new file mode 100644 index 000000000..d3546aab0 --- /dev/null +++ b/alidns/src/model/TransferDomainResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Alidns; +using namespace AlibabaCloud::Alidns::Model; + +TransferDomainResult::TransferDomainResult() : + ServiceResult() +{} + +TransferDomainResult::TransferDomainResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +TransferDomainResult::~TransferDomainResult() +{} + +void TransferDomainResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["TaskId"].isNull()) + taskId_ = std::stol(value["TaskId"].asString()); + +} + +long TransferDomainResult::getTaskId()const +{ + return taskId_; +} + diff --git a/alidns/src/model/UnbindInstanceDomainsRequest.cc b/alidns/src/model/UnbindInstanceDomainsRequest.cc new file mode 100644 index 000000000..721c3c6bd --- /dev/null +++ b/alidns/src/model/UnbindInstanceDomainsRequest.cc @@ -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 + +using AlibabaCloud::Alidns::Model::UnbindInstanceDomainsRequest; + +UnbindInstanceDomainsRequest::UnbindInstanceDomainsRequest() : + RpcServiceRequest("alidns", "2015-01-09", "UnbindInstanceDomains") +{ + setMethod(HttpRequest::Method::Post); +} + +UnbindInstanceDomainsRequest::~UnbindInstanceDomainsRequest() +{} + +std::string UnbindInstanceDomainsRequest::getDomainNames()const +{ + return domainNames_; +} + +void UnbindInstanceDomainsRequest::setDomainNames(const std::string& domainNames) +{ + domainNames_ = domainNames; + setCoreParameter("DomainNames", domainNames); +} + +std::string UnbindInstanceDomainsRequest::getInstanceId()const +{ + return instanceId_; +} + +void UnbindInstanceDomainsRequest::setInstanceId(const std::string& instanceId) +{ + instanceId_ = instanceId; + setCoreParameter("InstanceId", instanceId); +} + +std::string UnbindInstanceDomainsRequest::getUserClientIp()const +{ + return userClientIp_; +} + +void UnbindInstanceDomainsRequest::setUserClientIp(const std::string& userClientIp) +{ + userClientIp_ = userClientIp; + setCoreParameter("UserClientIp", userClientIp); +} + +std::string UnbindInstanceDomainsRequest::getLang()const +{ + return lang_; +} + +void UnbindInstanceDomainsRequest::setLang(const std::string& lang) +{ + lang_ = lang; + setCoreParameter("Lang", lang); +} + diff --git a/alidns/src/model/UnbindInstanceDomainsResult.cc b/alidns/src/model/UnbindInstanceDomainsResult.cc new file mode 100644 index 000000000..c85a7c9dc --- /dev/null +++ b/alidns/src/model/UnbindInstanceDomainsResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Alidns; +using namespace AlibabaCloud::Alidns::Model; + +UnbindInstanceDomainsResult::UnbindInstanceDomainsResult() : + ServiceResult() +{} + +UnbindInstanceDomainsResult::UnbindInstanceDomainsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UnbindInstanceDomainsResult::~UnbindInstanceDomainsResult() +{} + +void UnbindInstanceDomainsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["SuccessCount"].isNull()) + successCount_ = std::stoi(value["SuccessCount"].asString()); + if(!value["FailedCount"].isNull()) + failedCount_ = std::stoi(value["FailedCount"].asString()); + +} + +int UnbindInstanceDomainsResult::getFailedCount()const +{ + return failedCount_; +} + +int UnbindInstanceDomainsResult::getSuccessCount()const +{ + return successCount_; +} + diff --git a/alidns/src/model/UpdateCustomLineRequest.cc b/alidns/src/model/UpdateCustomLineRequest.cc new file mode 100644 index 000000000..dcd53b6c8 --- /dev/null +++ b/alidns/src/model/UpdateCustomLineRequest.cc @@ -0,0 +1,89 @@ +/* + * 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 + +using AlibabaCloud::Alidns::Model::UpdateCustomLineRequest; + +UpdateCustomLineRequest::UpdateCustomLineRequest() : + RpcServiceRequest("alidns", "2015-01-09", "UpdateCustomLine") +{ + setMethod(HttpRequest::Method::Post); +} + +UpdateCustomLineRequest::~UpdateCustomLineRequest() +{} + +long UpdateCustomLineRequest::getLineId()const +{ + return lineId_; +} + +void UpdateCustomLineRequest::setLineId(long lineId) +{ + lineId_ = lineId; + setCoreParameter("LineId", std::to_string(lineId)); +} + +std::vector UpdateCustomLineRequest::getIpSegment()const +{ + return ipSegment_; +} + +void UpdateCustomLineRequest::setIpSegment(const std::vector& ipSegment) +{ + ipSegment_ = ipSegment; + for(int dep1 = 0; dep1!= ipSegment.size(); dep1++) { + auto ipSegmentObj = ipSegment.at(dep1); + std::string ipSegmentObjStr = "IpSegment." + std::to_string(dep1); + setCoreParameter(ipSegmentObjStr + ".EndIp", ipSegmentObj.endIp); + setCoreParameter(ipSegmentObjStr + ".StartIp", ipSegmentObj.startIp); + } +} + +std::string UpdateCustomLineRequest::getUserClientIp()const +{ + return userClientIp_; +} + +void UpdateCustomLineRequest::setUserClientIp(const std::string& userClientIp) +{ + userClientIp_ = userClientIp; + setCoreParameter("UserClientIp", userClientIp); +} + +std::string UpdateCustomLineRequest::getLineName()const +{ + return lineName_; +} + +void UpdateCustomLineRequest::setLineName(const std::string& lineName) +{ + lineName_ = lineName; + setCoreParameter("LineName", lineName); +} + +std::string UpdateCustomLineRequest::getLang()const +{ + return lang_; +} + +void UpdateCustomLineRequest::setLang(const std::string& lang) +{ + lang_ = lang; + setCoreParameter("Lang", lang); +} + diff --git a/alidns/src/model/UpdateCustomLineResult.cc b/alidns/src/model/UpdateCustomLineResult.cc new file mode 100644 index 000000000..c4257450e --- /dev/null +++ b/alidns/src/model/UpdateCustomLineResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Alidns; +using namespace AlibabaCloud::Alidns::Model; + +UpdateCustomLineResult::UpdateCustomLineResult() : + ServiceResult() +{} + +UpdateCustomLineResult::UpdateCustomLineResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateCustomLineResult::~UpdateCustomLineResult() +{} + +void UpdateCustomLineResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/alidns/src/model/UpdateGtmAddressPoolRequest.cc b/alidns/src/model/UpdateGtmAddressPoolRequest.cc index 8a72743cd..c50671e69 100644 --- a/alidns/src/model/UpdateGtmAddressPoolRequest.cc +++ b/alidns/src/model/UpdateGtmAddressPoolRequest.cc @@ -101,13 +101,12 @@ std::vector UpdateGtmAddressPoolRequest::getA void UpdateGtmAddressPoolRequest::setAddr(const std::vector& addr) { addr_ = addr; - int i = 0; - for(int i = 0; i!= addr.size(); i++) { - auto obj = addr.at(i); - std::string str ="Addr."+ std::to_string(i); - setCoreParameter(str + ".Mode", obj.mode); - setCoreParameter(str + ".LbaWeight", std::to_string(obj.lbaWeight)); - setCoreParameter(str + ".Value", obj.value); + for(int dep1 = 0; dep1!= addr.size(); dep1++) { + auto addrObj = addr.at(dep1); + std::string addrObjStr = "Addr." + std::to_string(dep1); + setCoreParameter(addrObjStr + ".Mode", addrObj.mode); + setCoreParameter(addrObjStr + ".LbaWeight", std::to_string(addrObj.lbaWeight)); + setCoreParameter(addrObjStr + ".Value", addrObj.value); } } diff --git a/alidns/src/model/UpdateGtmMonitorRequest.cc b/alidns/src/model/UpdateGtmMonitorRequest.cc index 7a3780158..80df57799 100644 --- a/alidns/src/model/UpdateGtmMonitorRequest.cc +++ b/alidns/src/model/UpdateGtmMonitorRequest.cc @@ -123,12 +123,11 @@ std::vector UpdateGtmMonitorRequest::getIs void UpdateGtmMonitorRequest::setIspCityNode(const std::vector& ispCityNode) { ispCityNode_ = ispCityNode; - int i = 0; - for(int i = 0; i!= ispCityNode.size(); i++) { - auto obj = ispCityNode.at(i); - std::string str ="IspCityNode."+ std::to_string(i); - setCoreParameter(str + ".CityCode", obj.cityCode); - setCoreParameter(str + ".IspCode", obj.ispCode); + for(int dep1 = 0; dep1!= ispCityNode.size(); dep1++) { + auto ispCityNodeObj = ispCityNode.at(dep1); + std::string ispCityNodeObjStr = "IspCityNode." + std::to_string(dep1); + setCoreParameter(ispCityNodeObjStr + ".CityCode", ispCityNodeObj.cityCode); + setCoreParameter(ispCityNodeObjStr + ".IspCode", ispCityNodeObj.ispCode); } }