diff --git a/CHANGELOG b/CHANGELOG index 73d787ac0..a4c34b510 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2019-10-18 Version 1.36.151 +- Generated 2019-09-10 for `DnsKnocker`. + 2019-10-16 Version 1.36.150 - Add ListTagResources OpenApi. - Add TagResources OpenApi. diff --git a/VERSION b/VERSION index 63176d2a3..caadd5bed 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.150 \ No newline at end of file +1.36.151 \ No newline at end of file diff --git a/dnsknocker/CMakeLists.txt b/dnsknocker/CMakeLists.txt new file mode 100644 index 000000000..596ff1fdc --- /dev/null +++ b/dnsknocker/CMakeLists.txt @@ -0,0 +1,122 @@ +# +# 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. +# + +set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include) + +set(dnsknocker_public_header + include/alibabacloud/dnsknocker/DnsKnockerClient.h + include/alibabacloud/dnsknocker/DnsKnockerExport.h ) + +set(dnsknocker_public_header_model + include/alibabacloud/dnsknocker/model/BatchCreateRrRequest.h + include/alibabacloud/dnsknocker/model/BatchCreateRrResult.h + include/alibabacloud/dnsknocker/model/BatchDeleteRrRequest.h + include/alibabacloud/dnsknocker/model/BatchDeleteRrResult.h + include/alibabacloud/dnsknocker/model/ChangeResourceRecordRequest.h + include/alibabacloud/dnsknocker/model/ChangeResourceRecordResult.h + include/alibabacloud/dnsknocker/model/ChangeResourceRecordsRequest.h + include/alibabacloud/dnsknocker/model/ChangeResourceRecordsResult.h + include/alibabacloud/dnsknocker/model/CreateResourceRecordRequest.h + include/alibabacloud/dnsknocker/model/CreateResourceRecordResult.h + include/alibabacloud/dnsknocker/model/DeleteDomainRequest.h + include/alibabacloud/dnsknocker/model/DeleteDomainResult.h + include/alibabacloud/dnsknocker/model/DeleteResourceRecordRequest.h + include/alibabacloud/dnsknocker/model/DeleteResourceRecordResult.h + include/alibabacloud/dnsknocker/model/DeleteResourceRecordsRequest.h + include/alibabacloud/dnsknocker/model/DeleteResourceRecordsResult.h + include/alibabacloud/dnsknocker/model/GetDomainRequest.h + include/alibabacloud/dnsknocker/model/GetDomainResult.h + include/alibabacloud/dnsknocker/model/GetResourceRecordsRequest.h + include/alibabacloud/dnsknocker/model/GetResourceRecordsResult.h ) + +set(dnsknocker_src + src/DnsKnockerClient.cc + src/model/BatchCreateRrRequest.cc + src/model/BatchCreateRrResult.cc + src/model/BatchDeleteRrRequest.cc + src/model/BatchDeleteRrResult.cc + src/model/ChangeResourceRecordRequest.cc + src/model/ChangeResourceRecordResult.cc + src/model/ChangeResourceRecordsRequest.cc + src/model/ChangeResourceRecordsResult.cc + src/model/CreateResourceRecordRequest.cc + src/model/CreateResourceRecordResult.cc + src/model/DeleteDomainRequest.cc + src/model/DeleteDomainResult.cc + src/model/DeleteResourceRecordRequest.cc + src/model/DeleteResourceRecordResult.cc + src/model/DeleteResourceRecordsRequest.cc + src/model/DeleteResourceRecordsResult.cc + src/model/GetDomainRequest.cc + src/model/GetDomainResult.cc + src/model/GetResourceRecordsRequest.cc + src/model/GetResourceRecordsResult.cc ) + +add_library(dnsknocker ${LIB_TYPE} + ${dnsknocker_public_header} + ${dnsknocker_public_header_model} + ${dnsknocker_src}) + +set_target_properties(dnsknocker + PROPERTIES + LINKER_LANGUAGE CXX + ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib + LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib + RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin + OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}dnsknocker + ) + +if(${LIB_TYPE} STREQUAL "SHARED") + set_target_properties(dnsknocker + PROPERTIES + DEFINE_SYMBOL ALIBABACLOUD_DNSKNOCKER_LIBRARY) +endif() + +target_include_directories(dnsknocker + PRIVATE include + ${CMAKE_SOURCE_DIR}/core/include + ) +target_link_libraries(dnsknocker + core) + +if(CMAKE_HOST_WIN32) + ExternalProject_Get_Property(jsoncpp INSTALL_DIR) + set(jsoncpp_install_dir ${INSTALL_DIR}) + add_dependencies(dnsknocker + jsoncpp) + target_include_directories(dnsknocker + PRIVATE ${jsoncpp_install_dir}/include) + target_link_libraries(dnsknocker + ${jsoncpp_install_dir}/lib/jsoncpp.lib) + set_target_properties(dnsknocker + PROPERTIES + COMPILE_OPTIONS "/bigobj") +else() + target_include_directories(dnsknocker + PRIVATE /usr/include/jsoncpp) + target_link_libraries(dnsknocker + jsoncpp) +endif() + +install(FILES ${dnsknocker_public_header} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/dnsknocker) +install(FILES ${dnsknocker_public_header_model} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/dnsknocker/model) +install(TARGETS dnsknocker + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + ) \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/DnsKnockerClient.h b/dnsknocker/include/alibabacloud/dnsknocker/DnsKnockerClient.h new file mode 100644 index 000000000..aeb04abae --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/DnsKnockerClient.h @@ -0,0 +1,126 @@ +/* + * 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_DNSKNOCKER_DNSKNOCKERCLIENT_H_ +#define ALIBABACLOUD_DNSKNOCKER_DNSKNOCKERCLIENT_H_ + +#include +#include +#include +#include +#include "DnsKnockerExport.h" +#include "model/BatchCreateRrRequest.h" +#include "model/BatchCreateRrResult.h" +#include "model/BatchDeleteRrRequest.h" +#include "model/BatchDeleteRrResult.h" +#include "model/ChangeResourceRecordRequest.h" +#include "model/ChangeResourceRecordResult.h" +#include "model/ChangeResourceRecordsRequest.h" +#include "model/ChangeResourceRecordsResult.h" +#include "model/CreateResourceRecordRequest.h" +#include "model/CreateResourceRecordResult.h" +#include "model/DeleteDomainRequest.h" +#include "model/DeleteDomainResult.h" +#include "model/DeleteResourceRecordRequest.h" +#include "model/DeleteResourceRecordResult.h" +#include "model/DeleteResourceRecordsRequest.h" +#include "model/DeleteResourceRecordsResult.h" +#include "model/GetDomainRequest.h" +#include "model/GetDomainResult.h" +#include "model/GetResourceRecordsRequest.h" +#include "model/GetResourceRecordsResult.h" + + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT DnsKnockerClient : public RpcServiceClient + { + public: + typedef Outcome BatchCreateRrOutcome; + typedef std::future BatchCreateRrOutcomeCallable; + typedef std::function&)> BatchCreateRrAsyncHandler; + typedef Outcome BatchDeleteRrOutcome; + typedef std::future BatchDeleteRrOutcomeCallable; + typedef std::function&)> BatchDeleteRrAsyncHandler; + typedef Outcome ChangeResourceRecordOutcome; + typedef std::future ChangeResourceRecordOutcomeCallable; + typedef std::function&)> ChangeResourceRecordAsyncHandler; + typedef Outcome ChangeResourceRecordsOutcome; + typedef std::future ChangeResourceRecordsOutcomeCallable; + typedef std::function&)> ChangeResourceRecordsAsyncHandler; + typedef Outcome CreateResourceRecordOutcome; + typedef std::future CreateResourceRecordOutcomeCallable; + typedef std::function&)> CreateResourceRecordAsyncHandler; + typedef Outcome DeleteDomainOutcome; + typedef std::future DeleteDomainOutcomeCallable; + typedef std::function&)> DeleteDomainAsyncHandler; + typedef Outcome DeleteResourceRecordOutcome; + typedef std::future DeleteResourceRecordOutcomeCallable; + typedef std::function&)> DeleteResourceRecordAsyncHandler; + typedef Outcome DeleteResourceRecordsOutcome; + typedef std::future DeleteResourceRecordsOutcomeCallable; + typedef std::function&)> DeleteResourceRecordsAsyncHandler; + typedef Outcome GetDomainOutcome; + typedef std::future GetDomainOutcomeCallable; + typedef std::function&)> GetDomainAsyncHandler; + typedef Outcome GetResourceRecordsOutcome; + typedef std::future GetResourceRecordsOutcomeCallable; + typedef std::function&)> GetResourceRecordsAsyncHandler; + + DnsKnockerClient(const Credentials &credentials, const ClientConfiguration &configuration); + DnsKnockerClient(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); + DnsKnockerClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration); + ~DnsKnockerClient(); + BatchCreateRrOutcome batchCreateRr(const Model::BatchCreateRrRequest &request)const; + void batchCreateRrAsync(const Model::BatchCreateRrRequest& request, const BatchCreateRrAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + BatchCreateRrOutcomeCallable batchCreateRrCallable(const Model::BatchCreateRrRequest& request) const; + BatchDeleteRrOutcome batchDeleteRr(const Model::BatchDeleteRrRequest &request)const; + void batchDeleteRrAsync(const Model::BatchDeleteRrRequest& request, const BatchDeleteRrAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + BatchDeleteRrOutcomeCallable batchDeleteRrCallable(const Model::BatchDeleteRrRequest& request) const; + ChangeResourceRecordOutcome changeResourceRecord(const Model::ChangeResourceRecordRequest &request)const; + void changeResourceRecordAsync(const Model::ChangeResourceRecordRequest& request, const ChangeResourceRecordAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ChangeResourceRecordOutcomeCallable changeResourceRecordCallable(const Model::ChangeResourceRecordRequest& request) const; + ChangeResourceRecordsOutcome changeResourceRecords(const Model::ChangeResourceRecordsRequest &request)const; + void changeResourceRecordsAsync(const Model::ChangeResourceRecordsRequest& request, const ChangeResourceRecordsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ChangeResourceRecordsOutcomeCallable changeResourceRecordsCallable(const Model::ChangeResourceRecordsRequest& request) const; + CreateResourceRecordOutcome createResourceRecord(const Model::CreateResourceRecordRequest &request)const; + void createResourceRecordAsync(const Model::CreateResourceRecordRequest& request, const CreateResourceRecordAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateResourceRecordOutcomeCallable createResourceRecordCallable(const Model::CreateResourceRecordRequest& 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; + DeleteResourceRecordOutcome deleteResourceRecord(const Model::DeleteResourceRecordRequest &request)const; + void deleteResourceRecordAsync(const Model::DeleteResourceRecordRequest& request, const DeleteResourceRecordAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteResourceRecordOutcomeCallable deleteResourceRecordCallable(const Model::DeleteResourceRecordRequest& request) const; + DeleteResourceRecordsOutcome deleteResourceRecords(const Model::DeleteResourceRecordsRequest &request)const; + void deleteResourceRecordsAsync(const Model::DeleteResourceRecordsRequest& request, const DeleteResourceRecordsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteResourceRecordsOutcomeCallable deleteResourceRecordsCallable(const Model::DeleteResourceRecordsRequest& request) const; + GetDomainOutcome getDomain(const Model::GetDomainRequest &request)const; + void getDomainAsync(const Model::GetDomainRequest& request, const GetDomainAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetDomainOutcomeCallable getDomainCallable(const Model::GetDomainRequest& request) const; + GetResourceRecordsOutcome getResourceRecords(const Model::GetResourceRecordsRequest &request)const; + void getResourceRecordsAsync(const Model::GetResourceRecordsRequest& request, const GetResourceRecordsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetResourceRecordsOutcomeCallable getResourceRecordsCallable(const Model::GetResourceRecordsRequest& request) const; + + private: + std::shared_ptr endpointProvider_; + }; + } +} + +#endif // !ALIBABACLOUD_DNSKNOCKER_DNSKNOCKERCLIENT_H_ diff --git a/dnsknocker/include/alibabacloud/dnsknocker/DnsKnockerExport.h b/dnsknocker/include/alibabacloud/dnsknocker/DnsKnockerExport.h new file mode 100644 index 000000000..061a2bb8e --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/DnsKnockerExport.h @@ -0,0 +1,32 @@ +/* + * 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_DNSKNOCKER_DNSKNOCKEREXPORT_H_ +#define ALIBABACLOUD_DNSKNOCKER_DNSKNOCKEREXPORT_H_ + +#include + +#if defined(ALIBABACLOUD_SHARED) +# if defined(ALIBABACLOUD_DNSKNOCKER_LIBRARY) +# define ALIBABACLOUD_DNSKNOCKER_EXPORT ALIBABACLOUD_DECL_EXPORT +# else +# define ALIBABACLOUD_DNSKNOCKER_EXPORT ALIBABACLOUD_DECL_IMPORT +# endif +#else +# define ALIBABACLOUD_DNSKNOCKER_EXPORT +#endif + +#endif // !ALIBABACLOUD_DNSKNOCKER_DNSKNOCKEREXPORT_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/BatchCreateRrRequest.h b/dnsknocker/include/alibabacloud/dnsknocker/model/BatchCreateRrRequest.h new file mode 100644 index 000000000..f0e749df1 --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/BatchCreateRrRequest.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_DNSKNOCKER_MODEL_BATCHCREATERRREQUEST_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_BATCHCREATERRREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT BatchCreateRrRequest : public RpcServiceRequest + { + + public: + BatchCreateRrRequest(); + ~BatchCreateRrRequest(); + + std::string getAccessID()const; + void setAccessID(const std::string& accessID); + std::string getAccessSecret()const; + void setAccessSecret(const std::string& accessSecret); + std::string getResourceRecords()const; + void setResourceRecords(const std::string& resourceRecords); + std::string getLine()const; + void setLine(const std::string& line); + std::string getZoneName()const; + void setZoneName(const std::string& zoneName); + std::string getTransactionId()const; + void setTransactionId(const std::string& transactionId); + std::string getGroup()const; + void setGroup(const std::string& group); + + private: + std::string accessID_; + std::string accessSecret_; + std::string resourceRecords_; + std::string line_; + std::string zoneName_; + std::string transactionId_; + std::string group_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_BATCHCREATERRREQUEST_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/BatchCreateRrResult.h b/dnsknocker/include/alibabacloud/dnsknocker/model/BatchCreateRrResult.h new file mode 100644 index 000000000..d20e6a2a7 --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/BatchCreateRrResult.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_DNSKNOCKER_MODEL_BATCHCREATERRRESULT_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_BATCHCREATERRRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT BatchCreateRrResult : public ServiceResult + { + public: + + + BatchCreateRrResult(); + explicit BatchCreateRrResult(const std::string &payload); + ~BatchCreateRrResult(); + std::string getResultMessage()const; + std::string getResultCode()const; + bool getSuccess()const; + std::string getTransactionId()const; + + protected: + void parse(const std::string &payload); + private: + std::string resultMessage_; + std::string resultCode_; + bool success_; + std::string transactionId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_BATCHCREATERRRESULT_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/BatchDeleteRrRequest.h b/dnsknocker/include/alibabacloud/dnsknocker/model/BatchDeleteRrRequest.h new file mode 100644 index 000000000..ca313c5c5 --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/BatchDeleteRrRequest.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_DNSKNOCKER_MODEL_BATCHDELETERRREQUEST_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_BATCHDELETERRREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT BatchDeleteRrRequest : public RpcServiceRequest + { + + public: + BatchDeleteRrRequest(); + ~BatchDeleteRrRequest(); + + std::string getAccessID()const; + void setAccessID(const std::string& accessID); + std::string getAccessSecret()const; + void setAccessSecret(const std::string& accessSecret); + std::string getResourceRecords()const; + void setResourceRecords(const std::string& resourceRecords); + std::string getLine()const; + void setLine(const std::string& line); + std::string getZoneName()const; + void setZoneName(const std::string& zoneName); + std::string getTransactionId()const; + void setTransactionId(const std::string& transactionId); + std::string getGroup()const; + void setGroup(const std::string& group); + + private: + std::string accessID_; + std::string accessSecret_; + std::string resourceRecords_; + std::string line_; + std::string zoneName_; + std::string transactionId_; + std::string group_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_BATCHDELETERRREQUEST_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/BatchDeleteRrResult.h b/dnsknocker/include/alibabacloud/dnsknocker/model/BatchDeleteRrResult.h new file mode 100644 index 000000000..fa785bef0 --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/BatchDeleteRrResult.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_DNSKNOCKER_MODEL_BATCHDELETERRRESULT_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_BATCHDELETERRRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT BatchDeleteRrResult : public ServiceResult + { + public: + + + BatchDeleteRrResult(); + explicit BatchDeleteRrResult(const std::string &payload); + ~BatchDeleteRrResult(); + std::string getResultMessage()const; + std::string getResultCode()const; + bool getSuccess()const; + std::string getTransactionId()const; + + protected: + void parse(const std::string &payload); + private: + std::string resultMessage_; + std::string resultCode_; + bool success_; + std::string transactionId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_BATCHDELETERRRESULT_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/ChangeResourceRecordRequest.h b/dnsknocker/include/alibabacloud/dnsknocker/model/ChangeResourceRecordRequest.h new file mode 100644 index 000000000..2ba169d1f --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/ChangeResourceRecordRequest.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_DNSKNOCKER_MODEL_CHANGERESOURCERECORDREQUEST_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_CHANGERESOURCERECORDREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT ChangeResourceRecordRequest : public RpcServiceRequest + { + + public: + ChangeResourceRecordRequest(); + ~ChangeResourceRecordRequest(); + + std::string getAccessID()const; + void setAccessID(const std::string& accessID); + std::string getAccessSecret()const; + void setAccessSecret(const std::string& accessSecret); + std::string getNewRRInfo()const; + void setNewRRInfo(const std::string& newRRInfo); + std::string getZoneName()const; + void setZoneName(const std::string& zoneName); + std::string getTransactionId()const; + void setTransactionId(const std::string& transactionId); + std::string getGroup()const; + void setGroup(const std::string& group); + std::string getOldRRInfo()const; + void setOldRRInfo(const std::string& oldRRInfo); + + private: + std::string accessID_; + std::string accessSecret_; + std::string newRRInfo_; + std::string zoneName_; + std::string transactionId_; + std::string group_; + std::string oldRRInfo_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_CHANGERESOURCERECORDREQUEST_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/ChangeResourceRecordResult.h b/dnsknocker/include/alibabacloud/dnsknocker/model/ChangeResourceRecordResult.h new file mode 100644 index 000000000..5e02b3b33 --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/ChangeResourceRecordResult.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_DNSKNOCKER_MODEL_CHANGERESOURCERECORDRESULT_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_CHANGERESOURCERECORDRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT ChangeResourceRecordResult : public ServiceResult + { + public: + + + ChangeResourceRecordResult(); + explicit ChangeResourceRecordResult(const std::string &payload); + ~ChangeResourceRecordResult(); + std::string getResultMessage()const; + std::string getResultCode()const; + std::string getSuccess()const; + std::string getTransactionId()const; + + protected: + void parse(const std::string &payload); + private: + std::string resultMessage_; + std::string resultCode_; + std::string success_; + std::string transactionId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_CHANGERESOURCERECORDRESULT_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/ChangeResourceRecordsRequest.h b/dnsknocker/include/alibabacloud/dnsknocker/model/ChangeResourceRecordsRequest.h new file mode 100644 index 000000000..4f67360ed --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/ChangeResourceRecordsRequest.h @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_DNSKNOCKER_MODEL_CHANGERESOURCERECORDSREQUEST_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_CHANGERESOURCERECORDSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT ChangeResourceRecordsRequest : public RpcServiceRequest + { + + public: + ChangeResourceRecordsRequest(); + ~ChangeResourceRecordsRequest(); + + std::string getAccessID()const; + void setAccessID(const std::string& accessID); + std::string getAccessSecret()const; + void setAccessSecret(const std::string& accessSecret); + std::string getTypes()const; + void setTypes(const std::string& types); + std::string getResourceRecords()const; + void setResourceRecords(const std::string& resourceRecords); + std::string getLine()const; + void setLine(const std::string& line); + std::string getDomainName()const; + void setDomainName(const std::string& domainName); + std::string getZoneName()const; + void setZoneName(const std::string& zoneName); + std::string getTransactionId()const; + void setTransactionId(const std::string& transactionId); + std::string getGroup()const; + void setGroup(const std::string& group); + + private: + std::string accessID_; + std::string accessSecret_; + std::string types_; + std::string resourceRecords_; + std::string line_; + std::string domainName_; + std::string zoneName_; + std::string transactionId_; + std::string group_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_CHANGERESOURCERECORDSREQUEST_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/ChangeResourceRecordsResult.h b/dnsknocker/include/alibabacloud/dnsknocker/model/ChangeResourceRecordsResult.h new file mode 100644 index 000000000..d376d7d20 --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/ChangeResourceRecordsResult.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_DNSKNOCKER_MODEL_CHANGERESOURCERECORDSRESULT_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_CHANGERESOURCERECORDSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT ChangeResourceRecordsResult : public ServiceResult + { + public: + + + ChangeResourceRecordsResult(); + explicit ChangeResourceRecordsResult(const std::string &payload); + ~ChangeResourceRecordsResult(); + std::string getResultMessage()const; + std::string getResultCode()const; + bool getSuccess()const; + std::string getTransactionId()const; + + protected: + void parse(const std::string &payload); + private: + std::string resultMessage_; + std::string resultCode_; + bool success_; + std::string transactionId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_CHANGERESOURCERECORDSRESULT_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/CreateResourceRecordRequest.h b/dnsknocker/include/alibabacloud/dnsknocker/model/CreateResourceRecordRequest.h new file mode 100644 index 000000000..5027e6e07 --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/CreateResourceRecordRequest.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_DNSKNOCKER_MODEL_CREATERESOURCERECORDREQUEST_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_CREATERESOURCERECORDREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT CreateResourceRecordRequest : public RpcServiceRequest + { + + public: + CreateResourceRecordRequest(); + ~CreateResourceRecordRequest(); + + std::string getAccessID()const; + void setAccessID(const std::string& accessID); + std::string getRrTTL()const; + void setRrTTL(const std::string& rrTTL); + std::string getAccessSecret()const; + void setAccessSecret(const std::string& accessSecret); + std::string getRrLine()const; + void setRrLine(const std::string& rrLine); + std::string getDomainName()const; + void setDomainName(const std::string& domainName); + std::string getRrValue()const; + void setRrValue(const std::string& rrValue); + std::string getZoneName()const; + void setZoneName(const std::string& zoneName); + std::string getTransactionId()const; + void setTransactionId(const std::string& transactionId); + std::string getGroup()const; + void setGroup(const std::string& group); + std::string getRrType()const; + void setRrType(const std::string& rrType); + + private: + std::string accessID_; + std::string rrTTL_; + std::string accessSecret_; + std::string rrLine_; + std::string domainName_; + std::string rrValue_; + std::string zoneName_; + std::string transactionId_; + std::string group_; + std::string rrType_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_CREATERESOURCERECORDREQUEST_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/CreateResourceRecordResult.h b/dnsknocker/include/alibabacloud/dnsknocker/model/CreateResourceRecordResult.h new file mode 100644 index 000000000..0d171ef53 --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/CreateResourceRecordResult.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_DNSKNOCKER_MODEL_CREATERESOURCERECORDRESULT_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_CREATERESOURCERECORDRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT CreateResourceRecordResult : public ServiceResult + { + public: + + + CreateResourceRecordResult(); + explicit CreateResourceRecordResult(const std::string &payload); + ~CreateResourceRecordResult(); + std::string getResultMessage()const; + std::string getResultCode()const; + std::string getSuccess()const; + std::string getTransactionId()const; + + protected: + void parse(const std::string &payload); + private: + std::string resultMessage_; + std::string resultCode_; + std::string success_; + std::string transactionId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_CREATERESOURCERECORDRESULT_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteDomainRequest.h b/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteDomainRequest.h new file mode 100644 index 000000000..d45d81d29 --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteDomainRequest.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_DNSKNOCKER_MODEL_DELETEDOMAINREQUEST_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_DELETEDOMAINREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT DeleteDomainRequest : public RpcServiceRequest + { + + public: + DeleteDomainRequest(); + ~DeleteDomainRequest(); + + std::string getAccessID()const; + void setAccessID(const std::string& accessID); + std::string getAccessSecret()const; + void setAccessSecret(const std::string& accessSecret); + std::string getLine()const; + void setLine(const std::string& line); + std::string getDomainName()const; + void setDomainName(const std::string& domainName); + std::string getZoneName()const; + void setZoneName(const std::string& zoneName); + std::string getTransactionId()const; + void setTransactionId(const std::string& transactionId); + std::string getGroup()const; + void setGroup(const std::string& group); + + private: + std::string accessID_; + std::string accessSecret_; + std::string line_; + std::string domainName_; + std::string zoneName_; + std::string transactionId_; + std::string group_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_DELETEDOMAINREQUEST_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteDomainResult.h b/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteDomainResult.h new file mode 100644 index 000000000..29e45e0ec --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteDomainResult.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_DNSKNOCKER_MODEL_DELETEDOMAINRESULT_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_DELETEDOMAINRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT DeleteDomainResult : public ServiceResult + { + public: + + + DeleteDomainResult(); + explicit DeleteDomainResult(const std::string &payload); + ~DeleteDomainResult(); + std::string getResultMessage()const; + std::string getResultCode()const; + bool getSuccess()const; + std::string getTransactionId()const; + + protected: + void parse(const std::string &payload); + private: + std::string resultMessage_; + std::string resultCode_; + bool success_; + std::string transactionId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_DELETEDOMAINRESULT_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteResourceRecordRequest.h b/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteResourceRecordRequest.h new file mode 100644 index 000000000..6aacaa2be --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteResourceRecordRequest.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_DNSKNOCKER_MODEL_DELETERESOURCERECORDREQUEST_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_DELETERESOURCERECORDREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT DeleteResourceRecordRequest : public RpcServiceRequest + { + + public: + DeleteResourceRecordRequest(); + ~DeleteResourceRecordRequest(); + + std::string getAccessID()const; + void setAccessID(const std::string& accessID); + std::string getRRTTL()const; + void setRRTTL(const std::string& rRTTL); + std::string getAccessSecret()const; + void setAccessSecret(const std::string& accessSecret); + std::string getRRLine()const; + void setRRLine(const std::string& rRLine); + std::string getDomainName()const; + void setDomainName(const std::string& domainName); + std::string getRRValue()const; + void setRRValue(const std::string& rRValue); + std::string getZoneName()const; + void setZoneName(const std::string& zoneName); + std::string getTransactionId()const; + void setTransactionId(const std::string& transactionId); + std::string getGroup()const; + void setGroup(const std::string& group); + std::string getRRType()const; + void setRRType(const std::string& rRType); + + private: + std::string accessID_; + std::string rRTTL_; + std::string accessSecret_; + std::string rRLine_; + std::string domainName_; + std::string rRValue_; + std::string zoneName_; + std::string transactionId_; + std::string group_; + std::string rRType_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_DELETERESOURCERECORDREQUEST_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteResourceRecordResult.h b/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteResourceRecordResult.h new file mode 100644 index 000000000..26b89d3fd --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteResourceRecordResult.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_DNSKNOCKER_MODEL_DELETERESOURCERECORDRESULT_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_DELETERESOURCERECORDRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT DeleteResourceRecordResult : public ServiceResult + { + public: + + + DeleteResourceRecordResult(); + explicit DeleteResourceRecordResult(const std::string &payload); + ~DeleteResourceRecordResult(); + std::string getResultMessage()const; + std::string getResultCode()const; + std::string getSuccess()const; + std::string getTransactionId()const; + + protected: + void parse(const std::string &payload); + private: + std::string resultMessage_; + std::string resultCode_; + std::string success_; + std::string transactionId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_DELETERESOURCERECORDRESULT_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteResourceRecordsRequest.h b/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteResourceRecordsRequest.h new file mode 100644 index 000000000..344aa84f3 --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteResourceRecordsRequest.h @@ -0,0 +1,69 @@ +/* + * 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_DNSKNOCKER_MODEL_DELETERESOURCERECORDSREQUEST_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_DELETERESOURCERECORDSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT DeleteResourceRecordsRequest : public RpcServiceRequest + { + + public: + DeleteResourceRecordsRequest(); + ~DeleteResourceRecordsRequest(); + + std::string getAccessID()const; + void setAccessID(const std::string& accessID); + std::string getAccessSecret()const; + void setAccessSecret(const std::string& accessSecret); + std::string getTypeList()const; + void setTypeList(const std::string& typeList); + std::string getLine()const; + void setLine(const std::string& line); + std::string getDomainName()const; + void setDomainName(const std::string& domainName); + std::string getZoneName()const; + void setZoneName(const std::string& zoneName); + std::string getTransactionId()const; + void setTransactionId(const std::string& transactionId); + std::string getGroup()const; + void setGroup(const std::string& group); + + private: + std::string accessID_; + std::string accessSecret_; + std::string typeList_; + std::string line_; + std::string domainName_; + std::string zoneName_; + std::string transactionId_; + std::string group_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_DELETERESOURCERECORDSREQUEST_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteResourceRecordsResult.h b/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteResourceRecordsResult.h new file mode 100644 index 000000000..77cdc13aa --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/DeleteResourceRecordsResult.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_DNSKNOCKER_MODEL_DELETERESOURCERECORDSRESULT_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_DELETERESOURCERECORDSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT DeleteResourceRecordsResult : public ServiceResult + { + public: + + + DeleteResourceRecordsResult(); + explicit DeleteResourceRecordsResult(const std::string &payload); + ~DeleteResourceRecordsResult(); + std::string getResultMessage()const; + std::string getResultCode()const; + std::string getSuccess()const; + std::string getTransactionId()const; + + protected: + void parse(const std::string &payload); + private: + std::string resultMessage_; + std::string resultCode_; + std::string success_; + std::string transactionId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_DELETERESOURCERECORDSRESULT_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/GetDomainRequest.h b/dnsknocker/include/alibabacloud/dnsknocker/model/GetDomainRequest.h new file mode 100644 index 000000000..692f71996 --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/GetDomainRequest.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_DNSKNOCKER_MODEL_GETDOMAINREQUEST_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_GETDOMAINREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT GetDomainRequest : public RpcServiceRequest + { + + public: + GetDomainRequest(); + ~GetDomainRequest(); + + std::string getAccessID()const; + void setAccessID(const std::string& accessID); + std::string getAccessSecret()const; + void setAccessSecret(const std::string& accessSecret); + std::string getDomainName()const; + void setDomainName(const std::string& domainName); + std::string getDomainLine()const; + void setDomainLine(const std::string& domainLine); + std::string getGroup()const; + void setGroup(const std::string& group); + + private: + std::string accessID_; + std::string accessSecret_; + std::string domainName_; + std::string domainLine_; + std::string group_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_GETDOMAINREQUEST_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/GetDomainResult.h b/dnsknocker/include/alibabacloud/dnsknocker/model/GetDomainResult.h new file mode 100644 index 000000000..13531127d --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/GetDomainResult.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_DNSKNOCKER_MODEL_GETDOMAINRESULT_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_GETDOMAINRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT GetDomainResult : public ServiceResult + { + public: + struct Data + { + std::string message; + std::string domainName; + std::string exists; + }; + + + GetDomainResult(); + explicit GetDomainResult(const std::string &payload); + ~GetDomainResult(); + std::vector getDomain()const; + std::string getResultMessage()const; + std::string getResultCode()const; + std::string getSuccess()const; + std::string getTransactionId()const; + + protected: + void parse(const std::string &payload); + private: + std::vector domain_; + std::string resultMessage_; + std::string resultCode_; + std::string success_; + std::string transactionId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_GETDOMAINRESULT_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/GetResourceRecordsRequest.h b/dnsknocker/include/alibabacloud/dnsknocker/model/GetResourceRecordsRequest.h new file mode 100644 index 000000000..81f955bf8 --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/GetResourceRecordsRequest.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_DNSKNOCKER_MODEL_GETRESOURCERECORDSREQUEST_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_GETRESOURCERECORDSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT GetResourceRecordsRequest : public RpcServiceRequest + { + + public: + GetResourceRecordsRequest(); + ~GetResourceRecordsRequest(); + + std::string getAccessID()const; + void setAccessID(const std::string& accessID); + std::string getAccessSecret()const; + void setAccessSecret(const std::string& accessSecret); + std::string getZone()const; + void setZone(const std::string& zone); + std::string getDomainName()const; + void setDomainName(const std::string& domainName); + std::string getTransactionId()const; + void setTransactionId(const std::string& transactionId); + std::string getDomainLine()const; + void setDomainLine(const std::string& domainLine); + std::string getGroup()const; + void setGroup(const std::string& group); + + private: + std::string accessID_; + std::string accessSecret_; + std::string zone_; + std::string domainName_; + std::string transactionId_; + std::string domainLine_; + std::string group_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_GETRESOURCERECORDSREQUEST_H_ \ No newline at end of file diff --git a/dnsknocker/include/alibabacloud/dnsknocker/model/GetResourceRecordsResult.h b/dnsknocker/include/alibabacloud/dnsknocker/model/GetResourceRecordsResult.h new file mode 100644 index 000000000..bc2a1e63b --- /dev/null +++ b/dnsknocker/include/alibabacloud/dnsknocker/model/GetResourceRecordsResult.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_DNSKNOCKER_MODEL_GETRESOURCERECORDSRESULT_H_ +#define ALIBABACLOUD_DNSKNOCKER_MODEL_GETRESOURCERECORDSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace DnsKnocker + { + namespace Model + { + class ALIBABACLOUD_DNSKNOCKER_EXPORT GetResourceRecordsResult : public ServiceResult + { + public: + + + GetResourceRecordsResult(); + explicit GetResourceRecordsResult(const std::string &payload); + ~GetResourceRecordsResult(); + std::vector getResourceRecordSet()const; + std::string getResultMessage()const; + std::string getResultCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::vector resourceRecordSet_; + std::string resultMessage_; + std::string resultCode_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DNSKNOCKER_MODEL_GETRESOURCERECORDSRESULT_H_ \ No newline at end of file diff --git a/dnsknocker/src/DnsKnockerClient.cc b/dnsknocker/src/DnsKnockerClient.cc new file mode 100644 index 000000000..b59b3115f --- /dev/null +++ b/dnsknocker/src/DnsKnockerClient.cc @@ -0,0 +1,413 @@ +/* + * 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; +using namespace AlibabaCloud::Location; +using namespace AlibabaCloud::DnsKnocker; +using namespace AlibabaCloud::DnsKnocker::Model; + +namespace +{ + const std::string SERVICE_NAME = "DnsKnocker"; +} + +DnsKnockerClient::DnsKnockerClient(const Credentials &credentials, const ClientConfiguration &configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(credentials), configuration) +{ + auto locationClient = std::make_shared(credentials, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "dns_knocker"); +} + +DnsKnockerClient::DnsKnockerClient(const std::shared_ptr& credentialsProvider, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration) +{ + auto locationClient = std::make_shared(credentialsProvider, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "dns_knocker"); +} + +DnsKnockerClient::DnsKnockerClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(accessKeyId, accessKeySecret), configuration) +{ + auto locationClient = std::make_shared(accessKeyId, accessKeySecret, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "dns_knocker"); +} + +DnsKnockerClient::~DnsKnockerClient() +{} + +DnsKnockerClient::BatchCreateRrOutcome DnsKnockerClient::batchCreateRr(const BatchCreateRrRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return BatchCreateRrOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return BatchCreateRrOutcome(BatchCreateRrResult(outcome.result())); + else + return BatchCreateRrOutcome(outcome.error()); +} + +void DnsKnockerClient::batchCreateRrAsync(const BatchCreateRrRequest& request, const BatchCreateRrAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, batchCreateRr(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DnsKnockerClient::BatchCreateRrOutcomeCallable DnsKnockerClient::batchCreateRrCallable(const BatchCreateRrRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->batchCreateRr(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +DnsKnockerClient::BatchDeleteRrOutcome DnsKnockerClient::batchDeleteRr(const BatchDeleteRrRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return BatchDeleteRrOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return BatchDeleteRrOutcome(BatchDeleteRrResult(outcome.result())); + else + return BatchDeleteRrOutcome(outcome.error()); +} + +void DnsKnockerClient::batchDeleteRrAsync(const BatchDeleteRrRequest& request, const BatchDeleteRrAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, batchDeleteRr(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DnsKnockerClient::BatchDeleteRrOutcomeCallable DnsKnockerClient::batchDeleteRrCallable(const BatchDeleteRrRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->batchDeleteRr(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +DnsKnockerClient::ChangeResourceRecordOutcome DnsKnockerClient::changeResourceRecord(const ChangeResourceRecordRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ChangeResourceRecordOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ChangeResourceRecordOutcome(ChangeResourceRecordResult(outcome.result())); + else + return ChangeResourceRecordOutcome(outcome.error()); +} + +void DnsKnockerClient::changeResourceRecordAsync(const ChangeResourceRecordRequest& request, const ChangeResourceRecordAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, changeResourceRecord(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DnsKnockerClient::ChangeResourceRecordOutcomeCallable DnsKnockerClient::changeResourceRecordCallable(const ChangeResourceRecordRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->changeResourceRecord(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +DnsKnockerClient::ChangeResourceRecordsOutcome DnsKnockerClient::changeResourceRecords(const ChangeResourceRecordsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ChangeResourceRecordsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ChangeResourceRecordsOutcome(ChangeResourceRecordsResult(outcome.result())); + else + return ChangeResourceRecordsOutcome(outcome.error()); +} + +void DnsKnockerClient::changeResourceRecordsAsync(const ChangeResourceRecordsRequest& request, const ChangeResourceRecordsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, changeResourceRecords(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DnsKnockerClient::ChangeResourceRecordsOutcomeCallable DnsKnockerClient::changeResourceRecordsCallable(const ChangeResourceRecordsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->changeResourceRecords(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +DnsKnockerClient::CreateResourceRecordOutcome DnsKnockerClient::createResourceRecord(const CreateResourceRecordRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateResourceRecordOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateResourceRecordOutcome(CreateResourceRecordResult(outcome.result())); + else + return CreateResourceRecordOutcome(outcome.error()); +} + +void DnsKnockerClient::createResourceRecordAsync(const CreateResourceRecordRequest& request, const CreateResourceRecordAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createResourceRecord(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DnsKnockerClient::CreateResourceRecordOutcomeCallable DnsKnockerClient::createResourceRecordCallable(const CreateResourceRecordRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createResourceRecord(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +DnsKnockerClient::DeleteDomainOutcome DnsKnockerClient::deleteDomain(const DeleteDomainRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteDomainOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteDomainOutcome(DeleteDomainResult(outcome.result())); + else + return DeleteDomainOutcome(outcome.error()); +} + +void DnsKnockerClient::deleteDomainAsync(const DeleteDomainRequest& request, const DeleteDomainAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteDomain(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DnsKnockerClient::DeleteDomainOutcomeCallable DnsKnockerClient::deleteDomainCallable(const DeleteDomainRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteDomain(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +DnsKnockerClient::DeleteResourceRecordOutcome DnsKnockerClient::deleteResourceRecord(const DeleteResourceRecordRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteResourceRecordOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteResourceRecordOutcome(DeleteResourceRecordResult(outcome.result())); + else + return DeleteResourceRecordOutcome(outcome.error()); +} + +void DnsKnockerClient::deleteResourceRecordAsync(const DeleteResourceRecordRequest& request, const DeleteResourceRecordAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteResourceRecord(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DnsKnockerClient::DeleteResourceRecordOutcomeCallable DnsKnockerClient::deleteResourceRecordCallable(const DeleteResourceRecordRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteResourceRecord(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +DnsKnockerClient::DeleteResourceRecordsOutcome DnsKnockerClient::deleteResourceRecords(const DeleteResourceRecordsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteResourceRecordsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteResourceRecordsOutcome(DeleteResourceRecordsResult(outcome.result())); + else + return DeleteResourceRecordsOutcome(outcome.error()); +} + +void DnsKnockerClient::deleteResourceRecordsAsync(const DeleteResourceRecordsRequest& request, const DeleteResourceRecordsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteResourceRecords(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DnsKnockerClient::DeleteResourceRecordsOutcomeCallable DnsKnockerClient::deleteResourceRecordsCallable(const DeleteResourceRecordsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteResourceRecords(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +DnsKnockerClient::GetDomainOutcome DnsKnockerClient::getDomain(const GetDomainRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetDomainOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetDomainOutcome(GetDomainResult(outcome.result())); + else + return GetDomainOutcome(outcome.error()); +} + +void DnsKnockerClient::getDomainAsync(const GetDomainRequest& request, const GetDomainAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getDomain(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DnsKnockerClient::GetDomainOutcomeCallable DnsKnockerClient::getDomainCallable(const GetDomainRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getDomain(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +DnsKnockerClient::GetResourceRecordsOutcome DnsKnockerClient::getResourceRecords(const GetResourceRecordsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetResourceRecordsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetResourceRecordsOutcome(GetResourceRecordsResult(outcome.result())); + else + return GetResourceRecordsOutcome(outcome.error()); +} + +void DnsKnockerClient::getResourceRecordsAsync(const GetResourceRecordsRequest& request, const GetResourceRecordsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getResourceRecords(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +DnsKnockerClient::GetResourceRecordsOutcomeCallable DnsKnockerClient::getResourceRecordsCallable(const GetResourceRecordsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getResourceRecords(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + diff --git a/dnsknocker/src/model/BatchCreateRrRequest.cc b/dnsknocker/src/model/BatchCreateRrRequest.cc new file mode 100644 index 000000000..79580da47 --- /dev/null +++ b/dnsknocker/src/model/BatchCreateRrRequest.cc @@ -0,0 +1,104 @@ +/* + * 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::DnsKnocker::Model::BatchCreateRrRequest; + +BatchCreateRrRequest::BatchCreateRrRequest() : + RpcServiceRequest("dnsknocker", "2019-09-10", "BatchCreateRr") +{} + +BatchCreateRrRequest::~BatchCreateRrRequest() +{} + +std::string BatchCreateRrRequest::getAccessID()const +{ + return accessID_; +} + +void BatchCreateRrRequest::setAccessID(const std::string& accessID) +{ + accessID_ = accessID; + setCoreParameter("AccessID", accessID); +} + +std::string BatchCreateRrRequest::getAccessSecret()const +{ + return accessSecret_; +} + +void BatchCreateRrRequest::setAccessSecret(const std::string& accessSecret) +{ + accessSecret_ = accessSecret; + setCoreParameter("AccessSecret", accessSecret); +} + +std::string BatchCreateRrRequest::getResourceRecords()const +{ + return resourceRecords_; +} + +void BatchCreateRrRequest::setResourceRecords(const std::string& resourceRecords) +{ + resourceRecords_ = resourceRecords; + setCoreParameter("ResourceRecords", resourceRecords); +} + +std::string BatchCreateRrRequest::getLine()const +{ + return line_; +} + +void BatchCreateRrRequest::setLine(const std::string& line) +{ + line_ = line; + setCoreParameter("Line", line); +} + +std::string BatchCreateRrRequest::getZoneName()const +{ + return zoneName_; +} + +void BatchCreateRrRequest::setZoneName(const std::string& zoneName) +{ + zoneName_ = zoneName; + setCoreParameter("ZoneName", zoneName); +} + +std::string BatchCreateRrRequest::getTransactionId()const +{ + return transactionId_; +} + +void BatchCreateRrRequest::setTransactionId(const std::string& transactionId) +{ + transactionId_ = transactionId; + setCoreParameter("TransactionId", transactionId); +} + +std::string BatchCreateRrRequest::getGroup()const +{ + return group_; +} + +void BatchCreateRrRequest::setGroup(const std::string& group) +{ + group_ = group; + setCoreParameter("Group", group); +} + diff --git a/dnsknocker/src/model/BatchCreateRrResult.cc b/dnsknocker/src/model/BatchCreateRrResult.cc new file mode 100644 index 000000000..ef72d1899 --- /dev/null +++ b/dnsknocker/src/model/BatchCreateRrResult.cc @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::DnsKnocker; +using namespace AlibabaCloud::DnsKnocker::Model; + +BatchCreateRrResult::BatchCreateRrResult() : + ServiceResult() +{} + +BatchCreateRrResult::BatchCreateRrResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +BatchCreateRrResult::~BatchCreateRrResult() +{} + +void BatchCreateRrResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["ResultCode"].isNull()) + resultCode_ = value["ResultCode"].asString(); + if(!value["ResultMessage"].isNull()) + resultMessage_ = value["ResultMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["TransactionId"].isNull()) + transactionId_ = value["TransactionId"].asString(); + +} + +std::string BatchCreateRrResult::getResultMessage()const +{ + return resultMessage_; +} + +std::string BatchCreateRrResult::getResultCode()const +{ + return resultCode_; +} + +bool BatchCreateRrResult::getSuccess()const +{ + return success_; +} + +std::string BatchCreateRrResult::getTransactionId()const +{ + return transactionId_; +} + diff --git a/dnsknocker/src/model/BatchDeleteRrRequest.cc b/dnsknocker/src/model/BatchDeleteRrRequest.cc new file mode 100644 index 000000000..2383c8306 --- /dev/null +++ b/dnsknocker/src/model/BatchDeleteRrRequest.cc @@ -0,0 +1,104 @@ +/* + * 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::DnsKnocker::Model::BatchDeleteRrRequest; + +BatchDeleteRrRequest::BatchDeleteRrRequest() : + RpcServiceRequest("dnsknocker", "2019-09-10", "BatchDeleteRr") +{} + +BatchDeleteRrRequest::~BatchDeleteRrRequest() +{} + +std::string BatchDeleteRrRequest::getAccessID()const +{ + return accessID_; +} + +void BatchDeleteRrRequest::setAccessID(const std::string& accessID) +{ + accessID_ = accessID; + setCoreParameter("AccessID", accessID); +} + +std::string BatchDeleteRrRequest::getAccessSecret()const +{ + return accessSecret_; +} + +void BatchDeleteRrRequest::setAccessSecret(const std::string& accessSecret) +{ + accessSecret_ = accessSecret; + setCoreParameter("AccessSecret", accessSecret); +} + +std::string BatchDeleteRrRequest::getResourceRecords()const +{ + return resourceRecords_; +} + +void BatchDeleteRrRequest::setResourceRecords(const std::string& resourceRecords) +{ + resourceRecords_ = resourceRecords; + setCoreParameter("ResourceRecords", resourceRecords); +} + +std::string BatchDeleteRrRequest::getLine()const +{ + return line_; +} + +void BatchDeleteRrRequest::setLine(const std::string& line) +{ + line_ = line; + setCoreParameter("Line", line); +} + +std::string BatchDeleteRrRequest::getZoneName()const +{ + return zoneName_; +} + +void BatchDeleteRrRequest::setZoneName(const std::string& zoneName) +{ + zoneName_ = zoneName; + setCoreParameter("ZoneName", zoneName); +} + +std::string BatchDeleteRrRequest::getTransactionId()const +{ + return transactionId_; +} + +void BatchDeleteRrRequest::setTransactionId(const std::string& transactionId) +{ + transactionId_ = transactionId; + setCoreParameter("TransactionId", transactionId); +} + +std::string BatchDeleteRrRequest::getGroup()const +{ + return group_; +} + +void BatchDeleteRrRequest::setGroup(const std::string& group) +{ + group_ = group; + setCoreParameter("Group", group); +} + diff --git a/dnsknocker/src/model/BatchDeleteRrResult.cc b/dnsknocker/src/model/BatchDeleteRrResult.cc new file mode 100644 index 000000000..e237daafe --- /dev/null +++ b/dnsknocker/src/model/BatchDeleteRrResult.cc @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::DnsKnocker; +using namespace AlibabaCloud::DnsKnocker::Model; + +BatchDeleteRrResult::BatchDeleteRrResult() : + ServiceResult() +{} + +BatchDeleteRrResult::BatchDeleteRrResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +BatchDeleteRrResult::~BatchDeleteRrResult() +{} + +void BatchDeleteRrResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["ResultCode"].isNull()) + resultCode_ = value["ResultCode"].asString(); + if(!value["ResultMessage"].isNull()) + resultMessage_ = value["ResultMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["TransactionId"].isNull()) + transactionId_ = value["TransactionId"].asString(); + +} + +std::string BatchDeleteRrResult::getResultMessage()const +{ + return resultMessage_; +} + +std::string BatchDeleteRrResult::getResultCode()const +{ + return resultCode_; +} + +bool BatchDeleteRrResult::getSuccess()const +{ + return success_; +} + +std::string BatchDeleteRrResult::getTransactionId()const +{ + return transactionId_; +} + diff --git a/dnsknocker/src/model/ChangeResourceRecordRequest.cc b/dnsknocker/src/model/ChangeResourceRecordRequest.cc new file mode 100644 index 000000000..6da604795 --- /dev/null +++ b/dnsknocker/src/model/ChangeResourceRecordRequest.cc @@ -0,0 +1,104 @@ +/* + * 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::DnsKnocker::Model::ChangeResourceRecordRequest; + +ChangeResourceRecordRequest::ChangeResourceRecordRequest() : + RpcServiceRequest("dnsknocker", "2019-09-10", "ChangeResourceRecord") +{} + +ChangeResourceRecordRequest::~ChangeResourceRecordRequest() +{} + +std::string ChangeResourceRecordRequest::getAccessID()const +{ + return accessID_; +} + +void ChangeResourceRecordRequest::setAccessID(const std::string& accessID) +{ + accessID_ = accessID; + setCoreParameter("AccessID", accessID); +} + +std::string ChangeResourceRecordRequest::getAccessSecret()const +{ + return accessSecret_; +} + +void ChangeResourceRecordRequest::setAccessSecret(const std::string& accessSecret) +{ + accessSecret_ = accessSecret; + setCoreParameter("AccessSecret", accessSecret); +} + +std::string ChangeResourceRecordRequest::getNewRRInfo()const +{ + return newRRInfo_; +} + +void ChangeResourceRecordRequest::setNewRRInfo(const std::string& newRRInfo) +{ + newRRInfo_ = newRRInfo; + setCoreParameter("NewRRInfo", newRRInfo); +} + +std::string ChangeResourceRecordRequest::getZoneName()const +{ + return zoneName_; +} + +void ChangeResourceRecordRequest::setZoneName(const std::string& zoneName) +{ + zoneName_ = zoneName; + setCoreParameter("ZoneName", zoneName); +} + +std::string ChangeResourceRecordRequest::getTransactionId()const +{ + return transactionId_; +} + +void ChangeResourceRecordRequest::setTransactionId(const std::string& transactionId) +{ + transactionId_ = transactionId; + setCoreParameter("TransactionId", transactionId); +} + +std::string ChangeResourceRecordRequest::getGroup()const +{ + return group_; +} + +void ChangeResourceRecordRequest::setGroup(const std::string& group) +{ + group_ = group; + setCoreParameter("Group", group); +} + +std::string ChangeResourceRecordRequest::getOldRRInfo()const +{ + return oldRRInfo_; +} + +void ChangeResourceRecordRequest::setOldRRInfo(const std::string& oldRRInfo) +{ + oldRRInfo_ = oldRRInfo; + setCoreParameter("OldRRInfo", oldRRInfo); +} + diff --git a/dnsknocker/src/model/ChangeResourceRecordResult.cc b/dnsknocker/src/model/ChangeResourceRecordResult.cc new file mode 100644 index 000000000..37d949ac5 --- /dev/null +++ b/dnsknocker/src/model/ChangeResourceRecordResult.cc @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::DnsKnocker; +using namespace AlibabaCloud::DnsKnocker::Model; + +ChangeResourceRecordResult::ChangeResourceRecordResult() : + ServiceResult() +{} + +ChangeResourceRecordResult::ChangeResourceRecordResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ChangeResourceRecordResult::~ChangeResourceRecordResult() +{} + +void ChangeResourceRecordResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["ResultCode"].isNull()) + resultCode_ = value["ResultCode"].asString(); + if(!value["ResultMessage"].isNull()) + resultMessage_ = value["ResultMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString(); + if(!value["TransactionId"].isNull()) + transactionId_ = value["TransactionId"].asString(); + +} + +std::string ChangeResourceRecordResult::getResultMessage()const +{ + return resultMessage_; +} + +std::string ChangeResourceRecordResult::getResultCode()const +{ + return resultCode_; +} + +std::string ChangeResourceRecordResult::getSuccess()const +{ + return success_; +} + +std::string ChangeResourceRecordResult::getTransactionId()const +{ + return transactionId_; +} + diff --git a/dnsknocker/src/model/ChangeResourceRecordsRequest.cc b/dnsknocker/src/model/ChangeResourceRecordsRequest.cc new file mode 100644 index 000000000..3733a241d --- /dev/null +++ b/dnsknocker/src/model/ChangeResourceRecordsRequest.cc @@ -0,0 +1,126 @@ +/* + * 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::DnsKnocker::Model::ChangeResourceRecordsRequest; + +ChangeResourceRecordsRequest::ChangeResourceRecordsRequest() : + RpcServiceRequest("dnsknocker", "2019-09-10", "ChangeResourceRecords") +{} + +ChangeResourceRecordsRequest::~ChangeResourceRecordsRequest() +{} + +std::string ChangeResourceRecordsRequest::getAccessID()const +{ + return accessID_; +} + +void ChangeResourceRecordsRequest::setAccessID(const std::string& accessID) +{ + accessID_ = accessID; + setCoreParameter("AccessID", accessID); +} + +std::string ChangeResourceRecordsRequest::getAccessSecret()const +{ + return accessSecret_; +} + +void ChangeResourceRecordsRequest::setAccessSecret(const std::string& accessSecret) +{ + accessSecret_ = accessSecret; + setCoreParameter("AccessSecret", accessSecret); +} + +std::string ChangeResourceRecordsRequest::getTypes()const +{ + return types_; +} + +void ChangeResourceRecordsRequest::setTypes(const std::string& types) +{ + types_ = types; + setCoreParameter("Types", types); +} + +std::string ChangeResourceRecordsRequest::getResourceRecords()const +{ + return resourceRecords_; +} + +void ChangeResourceRecordsRequest::setResourceRecords(const std::string& resourceRecords) +{ + resourceRecords_ = resourceRecords; + setCoreParameter("ResourceRecords", resourceRecords); +} + +std::string ChangeResourceRecordsRequest::getLine()const +{ + return line_; +} + +void ChangeResourceRecordsRequest::setLine(const std::string& line) +{ + line_ = line; + setCoreParameter("Line", line); +} + +std::string ChangeResourceRecordsRequest::getDomainName()const +{ + return domainName_; +} + +void ChangeResourceRecordsRequest::setDomainName(const std::string& domainName) +{ + domainName_ = domainName; + setCoreParameter("DomainName", domainName); +} + +std::string ChangeResourceRecordsRequest::getZoneName()const +{ + return zoneName_; +} + +void ChangeResourceRecordsRequest::setZoneName(const std::string& zoneName) +{ + zoneName_ = zoneName; + setCoreParameter("ZoneName", zoneName); +} + +std::string ChangeResourceRecordsRequest::getTransactionId()const +{ + return transactionId_; +} + +void ChangeResourceRecordsRequest::setTransactionId(const std::string& transactionId) +{ + transactionId_ = transactionId; + setCoreParameter("TransactionId", transactionId); +} + +std::string ChangeResourceRecordsRequest::getGroup()const +{ + return group_; +} + +void ChangeResourceRecordsRequest::setGroup(const std::string& group) +{ + group_ = group; + setCoreParameter("Group", group); +} + diff --git a/dnsknocker/src/model/ChangeResourceRecordsResult.cc b/dnsknocker/src/model/ChangeResourceRecordsResult.cc new file mode 100644 index 000000000..d9104d30f --- /dev/null +++ b/dnsknocker/src/model/ChangeResourceRecordsResult.cc @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::DnsKnocker; +using namespace AlibabaCloud::DnsKnocker::Model; + +ChangeResourceRecordsResult::ChangeResourceRecordsResult() : + ServiceResult() +{} + +ChangeResourceRecordsResult::ChangeResourceRecordsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ChangeResourceRecordsResult::~ChangeResourceRecordsResult() +{} + +void ChangeResourceRecordsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["ResultCode"].isNull()) + resultCode_ = value["ResultCode"].asString(); + if(!value["ResultMessage"].isNull()) + resultMessage_ = value["ResultMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["TransactionId"].isNull()) + transactionId_ = value["TransactionId"].asString(); + +} + +std::string ChangeResourceRecordsResult::getResultMessage()const +{ + return resultMessage_; +} + +std::string ChangeResourceRecordsResult::getResultCode()const +{ + return resultCode_; +} + +bool ChangeResourceRecordsResult::getSuccess()const +{ + return success_; +} + +std::string ChangeResourceRecordsResult::getTransactionId()const +{ + return transactionId_; +} + diff --git a/dnsknocker/src/model/CreateResourceRecordRequest.cc b/dnsknocker/src/model/CreateResourceRecordRequest.cc new file mode 100644 index 000000000..5009aeaa4 --- /dev/null +++ b/dnsknocker/src/model/CreateResourceRecordRequest.cc @@ -0,0 +1,137 @@ +/* + * 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::DnsKnocker::Model::CreateResourceRecordRequest; + +CreateResourceRecordRequest::CreateResourceRecordRequest() : + RpcServiceRequest("dnsknocker", "2019-09-10", "CreateResourceRecord") +{} + +CreateResourceRecordRequest::~CreateResourceRecordRequest() +{} + +std::string CreateResourceRecordRequest::getAccessID()const +{ + return accessID_; +} + +void CreateResourceRecordRequest::setAccessID(const std::string& accessID) +{ + accessID_ = accessID; + setCoreParameter("AccessID", accessID); +} + +std::string CreateResourceRecordRequest::getRrTTL()const +{ + return rrTTL_; +} + +void CreateResourceRecordRequest::setRrTTL(const std::string& rrTTL) +{ + rrTTL_ = rrTTL; + setCoreParameter("RrTTL", rrTTL); +} + +std::string CreateResourceRecordRequest::getAccessSecret()const +{ + return accessSecret_; +} + +void CreateResourceRecordRequest::setAccessSecret(const std::string& accessSecret) +{ + accessSecret_ = accessSecret; + setCoreParameter("AccessSecret", accessSecret); +} + +std::string CreateResourceRecordRequest::getRrLine()const +{ + return rrLine_; +} + +void CreateResourceRecordRequest::setRrLine(const std::string& rrLine) +{ + rrLine_ = rrLine; + setCoreParameter("RrLine", rrLine); +} + +std::string CreateResourceRecordRequest::getDomainName()const +{ + return domainName_; +} + +void CreateResourceRecordRequest::setDomainName(const std::string& domainName) +{ + domainName_ = domainName; + setCoreParameter("DomainName", domainName); +} + +std::string CreateResourceRecordRequest::getRrValue()const +{ + return rrValue_; +} + +void CreateResourceRecordRequest::setRrValue(const std::string& rrValue) +{ + rrValue_ = rrValue; + setCoreParameter("RrValue", rrValue); +} + +std::string CreateResourceRecordRequest::getZoneName()const +{ + return zoneName_; +} + +void CreateResourceRecordRequest::setZoneName(const std::string& zoneName) +{ + zoneName_ = zoneName; + setCoreParameter("ZoneName", zoneName); +} + +std::string CreateResourceRecordRequest::getTransactionId()const +{ + return transactionId_; +} + +void CreateResourceRecordRequest::setTransactionId(const std::string& transactionId) +{ + transactionId_ = transactionId; + setCoreParameter("TransactionId", transactionId); +} + +std::string CreateResourceRecordRequest::getGroup()const +{ + return group_; +} + +void CreateResourceRecordRequest::setGroup(const std::string& group) +{ + group_ = group; + setCoreParameter("Group", group); +} + +std::string CreateResourceRecordRequest::getRrType()const +{ + return rrType_; +} + +void CreateResourceRecordRequest::setRrType(const std::string& rrType) +{ + rrType_ = rrType; + setCoreParameter("RrType", rrType); +} + diff --git a/dnsknocker/src/model/CreateResourceRecordResult.cc b/dnsknocker/src/model/CreateResourceRecordResult.cc new file mode 100644 index 000000000..c09fd8328 --- /dev/null +++ b/dnsknocker/src/model/CreateResourceRecordResult.cc @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::DnsKnocker; +using namespace AlibabaCloud::DnsKnocker::Model; + +CreateResourceRecordResult::CreateResourceRecordResult() : + ServiceResult() +{} + +CreateResourceRecordResult::CreateResourceRecordResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateResourceRecordResult::~CreateResourceRecordResult() +{} + +void CreateResourceRecordResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["ResultCode"].isNull()) + resultCode_ = value["ResultCode"].asString(); + if(!value["ResultMessage"].isNull()) + resultMessage_ = value["ResultMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString(); + if(!value["TransactionId"].isNull()) + transactionId_ = value["TransactionId"].asString(); + +} + +std::string CreateResourceRecordResult::getResultMessage()const +{ + return resultMessage_; +} + +std::string CreateResourceRecordResult::getResultCode()const +{ + return resultCode_; +} + +std::string CreateResourceRecordResult::getSuccess()const +{ + return success_; +} + +std::string CreateResourceRecordResult::getTransactionId()const +{ + return transactionId_; +} + diff --git a/dnsknocker/src/model/DeleteDomainRequest.cc b/dnsknocker/src/model/DeleteDomainRequest.cc new file mode 100644 index 000000000..6a65c5b7a --- /dev/null +++ b/dnsknocker/src/model/DeleteDomainRequest.cc @@ -0,0 +1,104 @@ +/* + * 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::DnsKnocker::Model::DeleteDomainRequest; + +DeleteDomainRequest::DeleteDomainRequest() : + RpcServiceRequest("dnsknocker", "2019-09-10", "DeleteDomain") +{} + +DeleteDomainRequest::~DeleteDomainRequest() +{} + +std::string DeleteDomainRequest::getAccessID()const +{ + return accessID_; +} + +void DeleteDomainRequest::setAccessID(const std::string& accessID) +{ + accessID_ = accessID; + setCoreParameter("AccessID", accessID); +} + +std::string DeleteDomainRequest::getAccessSecret()const +{ + return accessSecret_; +} + +void DeleteDomainRequest::setAccessSecret(const std::string& accessSecret) +{ + accessSecret_ = accessSecret; + setCoreParameter("AccessSecret", accessSecret); +} + +std::string DeleteDomainRequest::getLine()const +{ + return line_; +} + +void DeleteDomainRequest::setLine(const std::string& line) +{ + line_ = line; + setCoreParameter("Line", line); +} + +std::string DeleteDomainRequest::getDomainName()const +{ + return domainName_; +} + +void DeleteDomainRequest::setDomainName(const std::string& domainName) +{ + domainName_ = domainName; + setCoreParameter("DomainName", domainName); +} + +std::string DeleteDomainRequest::getZoneName()const +{ + return zoneName_; +} + +void DeleteDomainRequest::setZoneName(const std::string& zoneName) +{ + zoneName_ = zoneName; + setCoreParameter("ZoneName", zoneName); +} + +std::string DeleteDomainRequest::getTransactionId()const +{ + return transactionId_; +} + +void DeleteDomainRequest::setTransactionId(const std::string& transactionId) +{ + transactionId_ = transactionId; + setCoreParameter("TransactionId", transactionId); +} + +std::string DeleteDomainRequest::getGroup()const +{ + return group_; +} + +void DeleteDomainRequest::setGroup(const std::string& group) +{ + group_ = group; + setCoreParameter("Group", group); +} + diff --git a/dnsknocker/src/model/DeleteDomainResult.cc b/dnsknocker/src/model/DeleteDomainResult.cc new file mode 100644 index 000000000..95d6e8808 --- /dev/null +++ b/dnsknocker/src/model/DeleteDomainResult.cc @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::DnsKnocker; +using namespace AlibabaCloud::DnsKnocker::Model; + +DeleteDomainResult::DeleteDomainResult() : + ServiceResult() +{} + +DeleteDomainResult::DeleteDomainResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteDomainResult::~DeleteDomainResult() +{} + +void DeleteDomainResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["ResultCode"].isNull()) + resultCode_ = value["ResultCode"].asString(); + if(!value["ResultMessage"].isNull()) + resultMessage_ = value["ResultMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["TransactionId"].isNull()) + transactionId_ = value["TransactionId"].asString(); + +} + +std::string DeleteDomainResult::getResultMessage()const +{ + return resultMessage_; +} + +std::string DeleteDomainResult::getResultCode()const +{ + return resultCode_; +} + +bool DeleteDomainResult::getSuccess()const +{ + return success_; +} + +std::string DeleteDomainResult::getTransactionId()const +{ + return transactionId_; +} + diff --git a/dnsknocker/src/model/DeleteResourceRecordRequest.cc b/dnsknocker/src/model/DeleteResourceRecordRequest.cc new file mode 100644 index 000000000..2e8a08aeb --- /dev/null +++ b/dnsknocker/src/model/DeleteResourceRecordRequest.cc @@ -0,0 +1,137 @@ +/* + * 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::DnsKnocker::Model::DeleteResourceRecordRequest; + +DeleteResourceRecordRequest::DeleteResourceRecordRequest() : + RpcServiceRequest("dnsknocker", "2019-09-10", "DeleteResourceRecord") +{} + +DeleteResourceRecordRequest::~DeleteResourceRecordRequest() +{} + +std::string DeleteResourceRecordRequest::getAccessID()const +{ + return accessID_; +} + +void DeleteResourceRecordRequest::setAccessID(const std::string& accessID) +{ + accessID_ = accessID; + setCoreParameter("AccessID", accessID); +} + +std::string DeleteResourceRecordRequest::getRRTTL()const +{ + return rRTTL_; +} + +void DeleteResourceRecordRequest::setRRTTL(const std::string& rRTTL) +{ + rRTTL_ = rRTTL; + setCoreParameter("RRTTL", rRTTL); +} + +std::string DeleteResourceRecordRequest::getAccessSecret()const +{ + return accessSecret_; +} + +void DeleteResourceRecordRequest::setAccessSecret(const std::string& accessSecret) +{ + accessSecret_ = accessSecret; + setCoreParameter("AccessSecret", accessSecret); +} + +std::string DeleteResourceRecordRequest::getRRLine()const +{ + return rRLine_; +} + +void DeleteResourceRecordRequest::setRRLine(const std::string& rRLine) +{ + rRLine_ = rRLine; + setCoreParameter("RRLine", rRLine); +} + +std::string DeleteResourceRecordRequest::getDomainName()const +{ + return domainName_; +} + +void DeleteResourceRecordRequest::setDomainName(const std::string& domainName) +{ + domainName_ = domainName; + setCoreParameter("DomainName", domainName); +} + +std::string DeleteResourceRecordRequest::getRRValue()const +{ + return rRValue_; +} + +void DeleteResourceRecordRequest::setRRValue(const std::string& rRValue) +{ + rRValue_ = rRValue; + setCoreParameter("RRValue", rRValue); +} + +std::string DeleteResourceRecordRequest::getZoneName()const +{ + return zoneName_; +} + +void DeleteResourceRecordRequest::setZoneName(const std::string& zoneName) +{ + zoneName_ = zoneName; + setCoreParameter("ZoneName", zoneName); +} + +std::string DeleteResourceRecordRequest::getTransactionId()const +{ + return transactionId_; +} + +void DeleteResourceRecordRequest::setTransactionId(const std::string& transactionId) +{ + transactionId_ = transactionId; + setCoreParameter("TransactionId", transactionId); +} + +std::string DeleteResourceRecordRequest::getGroup()const +{ + return group_; +} + +void DeleteResourceRecordRequest::setGroup(const std::string& group) +{ + group_ = group; + setCoreParameter("Group", group); +} + +std::string DeleteResourceRecordRequest::getRRType()const +{ + return rRType_; +} + +void DeleteResourceRecordRequest::setRRType(const std::string& rRType) +{ + rRType_ = rRType; + setCoreParameter("RRType", rRType); +} + diff --git a/dnsknocker/src/model/DeleteResourceRecordResult.cc b/dnsknocker/src/model/DeleteResourceRecordResult.cc new file mode 100644 index 000000000..b514d3dd2 --- /dev/null +++ b/dnsknocker/src/model/DeleteResourceRecordResult.cc @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::DnsKnocker; +using namespace AlibabaCloud::DnsKnocker::Model; + +DeleteResourceRecordResult::DeleteResourceRecordResult() : + ServiceResult() +{} + +DeleteResourceRecordResult::DeleteResourceRecordResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteResourceRecordResult::~DeleteResourceRecordResult() +{} + +void DeleteResourceRecordResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["ResultCode"].isNull()) + resultCode_ = value["ResultCode"].asString(); + if(!value["ResultMessage"].isNull()) + resultMessage_ = value["ResultMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString(); + if(!value["TransactionId"].isNull()) + transactionId_ = value["TransactionId"].asString(); + +} + +std::string DeleteResourceRecordResult::getResultMessage()const +{ + return resultMessage_; +} + +std::string DeleteResourceRecordResult::getResultCode()const +{ + return resultCode_; +} + +std::string DeleteResourceRecordResult::getSuccess()const +{ + return success_; +} + +std::string DeleteResourceRecordResult::getTransactionId()const +{ + return transactionId_; +} + diff --git a/dnsknocker/src/model/DeleteResourceRecordsRequest.cc b/dnsknocker/src/model/DeleteResourceRecordsRequest.cc new file mode 100644 index 000000000..7b520f862 --- /dev/null +++ b/dnsknocker/src/model/DeleteResourceRecordsRequest.cc @@ -0,0 +1,115 @@ +/* + * 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::DnsKnocker::Model::DeleteResourceRecordsRequest; + +DeleteResourceRecordsRequest::DeleteResourceRecordsRequest() : + RpcServiceRequest("dnsknocker", "2019-09-10", "DeleteResourceRecords") +{} + +DeleteResourceRecordsRequest::~DeleteResourceRecordsRequest() +{} + +std::string DeleteResourceRecordsRequest::getAccessID()const +{ + return accessID_; +} + +void DeleteResourceRecordsRequest::setAccessID(const std::string& accessID) +{ + accessID_ = accessID; + setCoreParameter("AccessID", accessID); +} + +std::string DeleteResourceRecordsRequest::getAccessSecret()const +{ + return accessSecret_; +} + +void DeleteResourceRecordsRequest::setAccessSecret(const std::string& accessSecret) +{ + accessSecret_ = accessSecret; + setCoreParameter("AccessSecret", accessSecret); +} + +std::string DeleteResourceRecordsRequest::getTypeList()const +{ + return typeList_; +} + +void DeleteResourceRecordsRequest::setTypeList(const std::string& typeList) +{ + typeList_ = typeList; + setCoreParameter("TypeList", typeList); +} + +std::string DeleteResourceRecordsRequest::getLine()const +{ + return line_; +} + +void DeleteResourceRecordsRequest::setLine(const std::string& line) +{ + line_ = line; + setCoreParameter("Line", line); +} + +std::string DeleteResourceRecordsRequest::getDomainName()const +{ + return domainName_; +} + +void DeleteResourceRecordsRequest::setDomainName(const std::string& domainName) +{ + domainName_ = domainName; + setCoreParameter("DomainName", domainName); +} + +std::string DeleteResourceRecordsRequest::getZoneName()const +{ + return zoneName_; +} + +void DeleteResourceRecordsRequest::setZoneName(const std::string& zoneName) +{ + zoneName_ = zoneName; + setCoreParameter("ZoneName", zoneName); +} + +std::string DeleteResourceRecordsRequest::getTransactionId()const +{ + return transactionId_; +} + +void DeleteResourceRecordsRequest::setTransactionId(const std::string& transactionId) +{ + transactionId_ = transactionId; + setCoreParameter("TransactionId", transactionId); +} + +std::string DeleteResourceRecordsRequest::getGroup()const +{ + return group_; +} + +void DeleteResourceRecordsRequest::setGroup(const std::string& group) +{ + group_ = group; + setCoreParameter("Group", group); +} + diff --git a/dnsknocker/src/model/DeleteResourceRecordsResult.cc b/dnsknocker/src/model/DeleteResourceRecordsResult.cc new file mode 100644 index 000000000..9168f4eef --- /dev/null +++ b/dnsknocker/src/model/DeleteResourceRecordsResult.cc @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::DnsKnocker; +using namespace AlibabaCloud::DnsKnocker::Model; + +DeleteResourceRecordsResult::DeleteResourceRecordsResult() : + ServiceResult() +{} + +DeleteResourceRecordsResult::DeleteResourceRecordsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteResourceRecordsResult::~DeleteResourceRecordsResult() +{} + +void DeleteResourceRecordsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["ResultCode"].isNull()) + resultCode_ = value["ResultCode"].asString(); + if(!value["ResultMessage"].isNull()) + resultMessage_ = value["ResultMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString(); + if(!value["TransactionId"].isNull()) + transactionId_ = value["TransactionId"].asString(); + +} + +std::string DeleteResourceRecordsResult::getResultMessage()const +{ + return resultMessage_; +} + +std::string DeleteResourceRecordsResult::getResultCode()const +{ + return resultCode_; +} + +std::string DeleteResourceRecordsResult::getSuccess()const +{ + return success_; +} + +std::string DeleteResourceRecordsResult::getTransactionId()const +{ + return transactionId_; +} + diff --git a/dnsknocker/src/model/GetDomainRequest.cc b/dnsknocker/src/model/GetDomainRequest.cc new file mode 100644 index 000000000..b5b3716bf --- /dev/null +++ b/dnsknocker/src/model/GetDomainRequest.cc @@ -0,0 +1,82 @@ +/* + * 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::DnsKnocker::Model::GetDomainRequest; + +GetDomainRequest::GetDomainRequest() : + RpcServiceRequest("dnsknocker", "2019-09-10", "GetDomain") +{} + +GetDomainRequest::~GetDomainRequest() +{} + +std::string GetDomainRequest::getAccessID()const +{ + return accessID_; +} + +void GetDomainRequest::setAccessID(const std::string& accessID) +{ + accessID_ = accessID; + setCoreParameter("AccessID", accessID); +} + +std::string GetDomainRequest::getAccessSecret()const +{ + return accessSecret_; +} + +void GetDomainRequest::setAccessSecret(const std::string& accessSecret) +{ + accessSecret_ = accessSecret; + setCoreParameter("AccessSecret", accessSecret); +} + +std::string GetDomainRequest::getDomainName()const +{ + return domainName_; +} + +void GetDomainRequest::setDomainName(const std::string& domainName) +{ + domainName_ = domainName; + setCoreParameter("DomainName", domainName); +} + +std::string GetDomainRequest::getDomainLine()const +{ + return domainLine_; +} + +void GetDomainRequest::setDomainLine(const std::string& domainLine) +{ + domainLine_ = domainLine; + setCoreParameter("DomainLine", domainLine); +} + +std::string GetDomainRequest::getGroup()const +{ + return group_; +} + +void GetDomainRequest::setGroup(const std::string& group) +{ + group_ = group; + setCoreParameter("Group", group); +} + diff --git a/dnsknocker/src/model/GetDomainResult.cc b/dnsknocker/src/model/GetDomainResult.cc new file mode 100644 index 000000000..bdeae864c --- /dev/null +++ b/dnsknocker/src/model/GetDomainResult.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 +#include + +using namespace AlibabaCloud::DnsKnocker; +using namespace AlibabaCloud::DnsKnocker::Model; + +GetDomainResult::GetDomainResult() : + ServiceResult() +{} + +GetDomainResult::GetDomainResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetDomainResult::~GetDomainResult() +{} + +void GetDomainResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allDomainNode = value["Domain"]["Data"]; + for (auto valueDomainData : allDomainNode) + { + Data domainObject; + if(!valueDomainData["DomainName"].isNull()) + domainObject.domainName = valueDomainData["DomainName"].asString(); + if(!valueDomainData["Exists"].isNull()) + domainObject.exists = valueDomainData["Exists"].asString(); + if(!valueDomainData["Message"].isNull()) + domainObject.message = valueDomainData["Message"].asString(); + domain_.push_back(domainObject); + } + if(!value["ResultCode"].isNull()) + resultCode_ = value["ResultCode"].asString(); + if(!value["ResultMessage"].isNull()) + resultMessage_ = value["ResultMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString(); + if(!value["TransactionId"].isNull()) + transactionId_ = value["TransactionId"].asString(); + +} + +std::vector GetDomainResult::getDomain()const +{ + return domain_; +} + +std::string GetDomainResult::getResultMessage()const +{ + return resultMessage_; +} + +std::string GetDomainResult::getResultCode()const +{ + return resultCode_; +} + +std::string GetDomainResult::getSuccess()const +{ + return success_; +} + +std::string GetDomainResult::getTransactionId()const +{ + return transactionId_; +} + diff --git a/dnsknocker/src/model/GetResourceRecordsRequest.cc b/dnsknocker/src/model/GetResourceRecordsRequest.cc new file mode 100644 index 000000000..d7f37d9ce --- /dev/null +++ b/dnsknocker/src/model/GetResourceRecordsRequest.cc @@ -0,0 +1,104 @@ +/* + * 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::DnsKnocker::Model::GetResourceRecordsRequest; + +GetResourceRecordsRequest::GetResourceRecordsRequest() : + RpcServiceRequest("dnsknocker", "2019-09-10", "GetResourceRecords") +{} + +GetResourceRecordsRequest::~GetResourceRecordsRequest() +{} + +std::string GetResourceRecordsRequest::getAccessID()const +{ + return accessID_; +} + +void GetResourceRecordsRequest::setAccessID(const std::string& accessID) +{ + accessID_ = accessID; + setCoreParameter("AccessID", accessID); +} + +std::string GetResourceRecordsRequest::getAccessSecret()const +{ + return accessSecret_; +} + +void GetResourceRecordsRequest::setAccessSecret(const std::string& accessSecret) +{ + accessSecret_ = accessSecret; + setCoreParameter("AccessSecret", accessSecret); +} + +std::string GetResourceRecordsRequest::getZone()const +{ + return zone_; +} + +void GetResourceRecordsRequest::setZone(const std::string& zone) +{ + zone_ = zone; + setCoreParameter("Zone", zone); +} + +std::string GetResourceRecordsRequest::getDomainName()const +{ + return domainName_; +} + +void GetResourceRecordsRequest::setDomainName(const std::string& domainName) +{ + domainName_ = domainName; + setCoreParameter("DomainName", domainName); +} + +std::string GetResourceRecordsRequest::getTransactionId()const +{ + return transactionId_; +} + +void GetResourceRecordsRequest::setTransactionId(const std::string& transactionId) +{ + transactionId_ = transactionId; + setCoreParameter("TransactionId", transactionId); +} + +std::string GetResourceRecordsRequest::getDomainLine()const +{ + return domainLine_; +} + +void GetResourceRecordsRequest::setDomainLine(const std::string& domainLine) +{ + domainLine_ = domainLine; + setCoreParameter("DomainLine", domainLine); +} + +std::string GetResourceRecordsRequest::getGroup()const +{ + return group_; +} + +void GetResourceRecordsRequest::setGroup(const std::string& group) +{ + group_ = group; + setCoreParameter("Group", group); +} + diff --git a/dnsknocker/src/model/GetResourceRecordsResult.cc b/dnsknocker/src/model/GetResourceRecordsResult.cc new file mode 100644 index 000000000..c94a6be40 --- /dev/null +++ b/dnsknocker/src/model/GetResourceRecordsResult.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 +#include + +using namespace AlibabaCloud::DnsKnocker; +using namespace AlibabaCloud::DnsKnocker::Model; + +GetResourceRecordsResult::GetResourceRecordsResult() : + ServiceResult() +{} + +GetResourceRecordsResult::GetResourceRecordsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetResourceRecordsResult::~GetResourceRecordsResult() +{} + +void GetResourceRecordsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allResourceRecordSet = value["ResourceRecordSet"]["Data"]; + for (const auto &item : allResourceRecordSet) + resourceRecordSet_.push_back(item.asString()); + if(!value["ResultCode"].isNull()) + resultCode_ = value["ResultCode"].asString(); + if(!value["ResultMessage"].isNull()) + resultMessage_ = value["ResultMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::vector GetResourceRecordsResult::getResourceRecordSet()const +{ + return resourceRecordSet_; +} + +std::string GetResourceRecordsResult::getResultMessage()const +{ + return resultMessage_; +} + +std::string GetResourceRecordsResult::getResultCode()const +{ + return resultCode_; +} + +bool GetResourceRecordsResult::getSuccess()const +{ + return success_; +} +