diff --git a/VERSION b/VERSION index 38e9c692d..fd65416b1 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1927 \ No newline at end of file +1.36.1928 \ No newline at end of file diff --git a/beian/CMakeLists.txt b/beian/CMakeLists.txt new file mode 100644 index 000000000..688b67717 --- /dev/null +++ b/beian/CMakeLists.txt @@ -0,0 +1,138 @@ +# +# 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(beian_public_header + include/alibabacloud/beian/BeianClient.h + include/alibabacloud/beian/BeianExport.h ) + +set(beian_public_header_model + include/alibabacloud/beian/model/DeleteUnbeianIpCheckTypeRequest.h + include/alibabacloud/beian/model/DeleteUnbeianIpCheckTypeResult.h + include/alibabacloud/beian/model/GetMainDomainRequest.h + include/alibabacloud/beian/model/GetMainDomainResult.h + include/alibabacloud/beian/model/InsertUnbeianIpCheckTypeRequest.h + include/alibabacloud/beian/model/InsertUnbeianIpCheckTypeResult.h + include/alibabacloud/beian/model/ListUnbeianIpCheckTypeRequest.h + include/alibabacloud/beian/model/ListUnbeianIpCheckTypeResult.h + include/alibabacloud/beian/model/ManageAccessorDomainRequest.h + include/alibabacloud/beian/model/ManageAccessorDomainResult.h + include/alibabacloud/beian/model/ManageAccessorDomainWhiteListRequest.h + include/alibabacloud/beian/model/ManageAccessorDomainWhiteListResult.h + include/alibabacloud/beian/model/ManageAccessorIpRequest.h + include/alibabacloud/beian/model/ManageAccessorIpResult.h + include/alibabacloud/beian/model/QueryAccessorDomainRequest.h + include/alibabacloud/beian/model/QueryAccessorDomainResult.h + include/alibabacloud/beian/model/QueryAccessorDomainListRequest.h + include/alibabacloud/beian/model/QueryAccessorDomainListResult.h + include/alibabacloud/beian/model/QueryAccessorDomainStatusRequest.h + include/alibabacloud/beian/model/QueryAccessorDomainStatusResult.h + include/alibabacloud/beian/model/QueryAccessorDomainWhiteListRequest.h + include/alibabacloud/beian/model/QueryAccessorDomainWhiteListResult.h + include/alibabacloud/beian/model/QueryAccessorDomainsStatusRequest.h + include/alibabacloud/beian/model/QueryAccessorDomainsStatusResult.h + include/alibabacloud/beian/model/QueryAccessorIpRequest.h + include/alibabacloud/beian/model/QueryAccessorIpResult.h + include/alibabacloud/beian/model/SubmitAccessorFullDomainsOssListRequest.h + include/alibabacloud/beian/model/SubmitAccessorFullDomainsOssListResult.h ) + +set(beian_src + src/BeianClient.cc + src/model/DeleteUnbeianIpCheckTypeRequest.cc + src/model/DeleteUnbeianIpCheckTypeResult.cc + src/model/GetMainDomainRequest.cc + src/model/GetMainDomainResult.cc + src/model/InsertUnbeianIpCheckTypeRequest.cc + src/model/InsertUnbeianIpCheckTypeResult.cc + src/model/ListUnbeianIpCheckTypeRequest.cc + src/model/ListUnbeianIpCheckTypeResult.cc + src/model/ManageAccessorDomainRequest.cc + src/model/ManageAccessorDomainResult.cc + src/model/ManageAccessorDomainWhiteListRequest.cc + src/model/ManageAccessorDomainWhiteListResult.cc + src/model/ManageAccessorIpRequest.cc + src/model/ManageAccessorIpResult.cc + src/model/QueryAccessorDomainRequest.cc + src/model/QueryAccessorDomainResult.cc + src/model/QueryAccessorDomainListRequest.cc + src/model/QueryAccessorDomainListResult.cc + src/model/QueryAccessorDomainStatusRequest.cc + src/model/QueryAccessorDomainStatusResult.cc + src/model/QueryAccessorDomainWhiteListRequest.cc + src/model/QueryAccessorDomainWhiteListResult.cc + src/model/QueryAccessorDomainsStatusRequest.cc + src/model/QueryAccessorDomainsStatusResult.cc + src/model/QueryAccessorIpRequest.cc + src/model/QueryAccessorIpResult.cc + src/model/SubmitAccessorFullDomainsOssListRequest.cc + src/model/SubmitAccessorFullDomainsOssListResult.cc ) + +add_library(beian ${LIB_TYPE} + ${beian_public_header} + ${beian_public_header_model} + ${beian_src}) + +set_target_properties(beian + 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}beian + ) + +if(${LIB_TYPE} STREQUAL "SHARED") + set_target_properties(beian + PROPERTIES + DEFINE_SYMBOL ALIBABACLOUD_BEIAN_LIBRARY) +endif() + +target_include_directories(beian + PRIVATE include + ${CMAKE_SOURCE_DIR}/core/include + ) +target_link_libraries(beian + core) + +if(CMAKE_HOST_WIN32) + ExternalProject_Get_Property(jsoncpp INSTALL_DIR) + set(jsoncpp_install_dir ${INSTALL_DIR}) + add_dependencies(beian + jsoncpp) + target_include_directories(beian + PRIVATE ${jsoncpp_install_dir}/include) + target_link_libraries(beian + ${jsoncpp_install_dir}/lib/jsoncpp.lib) + set_target_properties(beian + PROPERTIES + COMPILE_OPTIONS "/bigobj") +else() + target_include_directories(beian + PRIVATE /usr/include/jsoncpp) + target_link_libraries(beian + jsoncpp) +endif() + +install(FILES ${beian_public_header} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/beian) +install(FILES ${beian_public_header_model} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/beian/model) +install(TARGETS beian + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + ) \ No newline at end of file diff --git a/beian/include/alibabacloud/beian/BeianClient.h b/beian/include/alibabacloud/beian/BeianClient.h new file mode 100644 index 000000000..823e89296 --- /dev/null +++ b/beian/include/alibabacloud/beian/BeianClient.h @@ -0,0 +1,158 @@ +/* + * 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_BEIAN_BEIANCLIENT_H_ +#define ALIBABACLOUD_BEIAN_BEIANCLIENT_H_ + +#include +#include +#include +#include +#include "BeianExport.h" +#include "model/DeleteUnbeianIpCheckTypeRequest.h" +#include "model/DeleteUnbeianIpCheckTypeResult.h" +#include "model/GetMainDomainRequest.h" +#include "model/GetMainDomainResult.h" +#include "model/InsertUnbeianIpCheckTypeRequest.h" +#include "model/InsertUnbeianIpCheckTypeResult.h" +#include "model/ListUnbeianIpCheckTypeRequest.h" +#include "model/ListUnbeianIpCheckTypeResult.h" +#include "model/ManageAccessorDomainRequest.h" +#include "model/ManageAccessorDomainResult.h" +#include "model/ManageAccessorDomainWhiteListRequest.h" +#include "model/ManageAccessorDomainWhiteListResult.h" +#include "model/ManageAccessorIpRequest.h" +#include "model/ManageAccessorIpResult.h" +#include "model/QueryAccessorDomainRequest.h" +#include "model/QueryAccessorDomainResult.h" +#include "model/QueryAccessorDomainListRequest.h" +#include "model/QueryAccessorDomainListResult.h" +#include "model/QueryAccessorDomainStatusRequest.h" +#include "model/QueryAccessorDomainStatusResult.h" +#include "model/QueryAccessorDomainWhiteListRequest.h" +#include "model/QueryAccessorDomainWhiteListResult.h" +#include "model/QueryAccessorDomainsStatusRequest.h" +#include "model/QueryAccessorDomainsStatusResult.h" +#include "model/QueryAccessorIpRequest.h" +#include "model/QueryAccessorIpResult.h" +#include "model/SubmitAccessorFullDomainsOssListRequest.h" +#include "model/SubmitAccessorFullDomainsOssListResult.h" + + +namespace AlibabaCloud +{ + namespace Beian + { + class ALIBABACLOUD_BEIAN_EXPORT BeianClient : public RpcServiceClient + { + public: + typedef Outcome DeleteUnbeianIpCheckTypeOutcome; + typedef std::future DeleteUnbeianIpCheckTypeOutcomeCallable; + typedef std::function&)> DeleteUnbeianIpCheckTypeAsyncHandler; + typedef Outcome GetMainDomainOutcome; + typedef std::future GetMainDomainOutcomeCallable; + typedef std::function&)> GetMainDomainAsyncHandler; + typedef Outcome InsertUnbeianIpCheckTypeOutcome; + typedef std::future InsertUnbeianIpCheckTypeOutcomeCallable; + typedef std::function&)> InsertUnbeianIpCheckTypeAsyncHandler; + typedef Outcome ListUnbeianIpCheckTypeOutcome; + typedef std::future ListUnbeianIpCheckTypeOutcomeCallable; + typedef std::function&)> ListUnbeianIpCheckTypeAsyncHandler; + typedef Outcome ManageAccessorDomainOutcome; + typedef std::future ManageAccessorDomainOutcomeCallable; + typedef std::function&)> ManageAccessorDomainAsyncHandler; + typedef Outcome ManageAccessorDomainWhiteListOutcome; + typedef std::future ManageAccessorDomainWhiteListOutcomeCallable; + typedef std::function&)> ManageAccessorDomainWhiteListAsyncHandler; + typedef Outcome ManageAccessorIpOutcome; + typedef std::future ManageAccessorIpOutcomeCallable; + typedef std::function&)> ManageAccessorIpAsyncHandler; + typedef Outcome QueryAccessorDomainOutcome; + typedef std::future QueryAccessorDomainOutcomeCallable; + typedef std::function&)> QueryAccessorDomainAsyncHandler; + typedef Outcome QueryAccessorDomainListOutcome; + typedef std::future QueryAccessorDomainListOutcomeCallable; + typedef std::function&)> QueryAccessorDomainListAsyncHandler; + typedef Outcome QueryAccessorDomainStatusOutcome; + typedef std::future QueryAccessorDomainStatusOutcomeCallable; + typedef std::function&)> QueryAccessorDomainStatusAsyncHandler; + typedef Outcome QueryAccessorDomainWhiteListOutcome; + typedef std::future QueryAccessorDomainWhiteListOutcomeCallable; + typedef std::function&)> QueryAccessorDomainWhiteListAsyncHandler; + typedef Outcome QueryAccessorDomainsStatusOutcome; + typedef std::future QueryAccessorDomainsStatusOutcomeCallable; + typedef std::function&)> QueryAccessorDomainsStatusAsyncHandler; + typedef Outcome QueryAccessorIpOutcome; + typedef std::future QueryAccessorIpOutcomeCallable; + typedef std::function&)> QueryAccessorIpAsyncHandler; + typedef Outcome SubmitAccessorFullDomainsOssListOutcome; + typedef std::future SubmitAccessorFullDomainsOssListOutcomeCallable; + typedef std::function&)> SubmitAccessorFullDomainsOssListAsyncHandler; + + BeianClient(const Credentials &credentials, const ClientConfiguration &configuration); + BeianClient(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); + BeianClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration); + ~BeianClient(); + DeleteUnbeianIpCheckTypeOutcome deleteUnbeianIpCheckType(const Model::DeleteUnbeianIpCheckTypeRequest &request)const; + void deleteUnbeianIpCheckTypeAsync(const Model::DeleteUnbeianIpCheckTypeRequest& request, const DeleteUnbeianIpCheckTypeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteUnbeianIpCheckTypeOutcomeCallable deleteUnbeianIpCheckTypeCallable(const Model::DeleteUnbeianIpCheckTypeRequest& request) const; + GetMainDomainOutcome getMainDomain(const Model::GetMainDomainRequest &request)const; + void getMainDomainAsync(const Model::GetMainDomainRequest& request, const GetMainDomainAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetMainDomainOutcomeCallable getMainDomainCallable(const Model::GetMainDomainRequest& request) const; + InsertUnbeianIpCheckTypeOutcome insertUnbeianIpCheckType(const Model::InsertUnbeianIpCheckTypeRequest &request)const; + void insertUnbeianIpCheckTypeAsync(const Model::InsertUnbeianIpCheckTypeRequest& request, const InsertUnbeianIpCheckTypeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + InsertUnbeianIpCheckTypeOutcomeCallable insertUnbeianIpCheckTypeCallable(const Model::InsertUnbeianIpCheckTypeRequest& request) const; + ListUnbeianIpCheckTypeOutcome listUnbeianIpCheckType(const Model::ListUnbeianIpCheckTypeRequest &request)const; + void listUnbeianIpCheckTypeAsync(const Model::ListUnbeianIpCheckTypeRequest& request, const ListUnbeianIpCheckTypeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListUnbeianIpCheckTypeOutcomeCallable listUnbeianIpCheckTypeCallable(const Model::ListUnbeianIpCheckTypeRequest& request) const; + ManageAccessorDomainOutcome manageAccessorDomain(const Model::ManageAccessorDomainRequest &request)const; + void manageAccessorDomainAsync(const Model::ManageAccessorDomainRequest& request, const ManageAccessorDomainAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ManageAccessorDomainOutcomeCallable manageAccessorDomainCallable(const Model::ManageAccessorDomainRequest& request) const; + ManageAccessorDomainWhiteListOutcome manageAccessorDomainWhiteList(const Model::ManageAccessorDomainWhiteListRequest &request)const; + void manageAccessorDomainWhiteListAsync(const Model::ManageAccessorDomainWhiteListRequest& request, const ManageAccessorDomainWhiteListAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ManageAccessorDomainWhiteListOutcomeCallable manageAccessorDomainWhiteListCallable(const Model::ManageAccessorDomainWhiteListRequest& request) const; + ManageAccessorIpOutcome manageAccessorIp(const Model::ManageAccessorIpRequest &request)const; + void manageAccessorIpAsync(const Model::ManageAccessorIpRequest& request, const ManageAccessorIpAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ManageAccessorIpOutcomeCallable manageAccessorIpCallable(const Model::ManageAccessorIpRequest& request) const; + QueryAccessorDomainOutcome queryAccessorDomain(const Model::QueryAccessorDomainRequest &request)const; + void queryAccessorDomainAsync(const Model::QueryAccessorDomainRequest& request, const QueryAccessorDomainAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + QueryAccessorDomainOutcomeCallable queryAccessorDomainCallable(const Model::QueryAccessorDomainRequest& request) const; + QueryAccessorDomainListOutcome queryAccessorDomainList(const Model::QueryAccessorDomainListRequest &request)const; + void queryAccessorDomainListAsync(const Model::QueryAccessorDomainListRequest& request, const QueryAccessorDomainListAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + QueryAccessorDomainListOutcomeCallable queryAccessorDomainListCallable(const Model::QueryAccessorDomainListRequest& request) const; + QueryAccessorDomainStatusOutcome queryAccessorDomainStatus(const Model::QueryAccessorDomainStatusRequest &request)const; + void queryAccessorDomainStatusAsync(const Model::QueryAccessorDomainStatusRequest& request, const QueryAccessorDomainStatusAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + QueryAccessorDomainStatusOutcomeCallable queryAccessorDomainStatusCallable(const Model::QueryAccessorDomainStatusRequest& request) const; + QueryAccessorDomainWhiteListOutcome queryAccessorDomainWhiteList(const Model::QueryAccessorDomainWhiteListRequest &request)const; + void queryAccessorDomainWhiteListAsync(const Model::QueryAccessorDomainWhiteListRequest& request, const QueryAccessorDomainWhiteListAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + QueryAccessorDomainWhiteListOutcomeCallable queryAccessorDomainWhiteListCallable(const Model::QueryAccessorDomainWhiteListRequest& request) const; + QueryAccessorDomainsStatusOutcome queryAccessorDomainsStatus(const Model::QueryAccessorDomainsStatusRequest &request)const; + void queryAccessorDomainsStatusAsync(const Model::QueryAccessorDomainsStatusRequest& request, const QueryAccessorDomainsStatusAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + QueryAccessorDomainsStatusOutcomeCallable queryAccessorDomainsStatusCallable(const Model::QueryAccessorDomainsStatusRequest& request) const; + QueryAccessorIpOutcome queryAccessorIp(const Model::QueryAccessorIpRequest &request)const; + void queryAccessorIpAsync(const Model::QueryAccessorIpRequest& request, const QueryAccessorIpAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + QueryAccessorIpOutcomeCallable queryAccessorIpCallable(const Model::QueryAccessorIpRequest& request) const; + SubmitAccessorFullDomainsOssListOutcome submitAccessorFullDomainsOssList(const Model::SubmitAccessorFullDomainsOssListRequest &request)const; + void submitAccessorFullDomainsOssListAsync(const Model::SubmitAccessorFullDomainsOssListRequest& request, const SubmitAccessorFullDomainsOssListAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SubmitAccessorFullDomainsOssListOutcomeCallable submitAccessorFullDomainsOssListCallable(const Model::SubmitAccessorFullDomainsOssListRequest& request) const; + + private: + std::shared_ptr endpointProvider_; + }; + } +} + +#endif // !ALIBABACLOUD_BEIAN_BEIANCLIENT_H_ diff --git a/beian/include/alibabacloud/beian/BeianExport.h b/beian/include/alibabacloud/beian/BeianExport.h new file mode 100644 index 000000000..280d70045 --- /dev/null +++ b/beian/include/alibabacloud/beian/BeianExport.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_BEIAN_BEIANEXPORT_H_ +#define ALIBABACLOUD_BEIAN_BEIANEXPORT_H_ + +#include + +#if defined(ALIBABACLOUD_SHARED) +# if defined(ALIBABACLOUD_BEIAN_LIBRARY) +# define ALIBABACLOUD_BEIAN_EXPORT ALIBABACLOUD_DECL_EXPORT +# else +# define ALIBABACLOUD_BEIAN_EXPORT ALIBABACLOUD_DECL_IMPORT +# endif +#else +# define ALIBABACLOUD_BEIAN_EXPORT +#endif + +#endif // !ALIBABACLOUD_BEIAN_BEIANEXPORT_H_ \ No newline at end of file diff --git a/beian/include/alibabacloud/beian/model/DeleteUnbeianIpCheckTypeRequest.h b/beian/include/alibabacloud/beian/model/DeleteUnbeianIpCheckTypeRequest.h new file mode 100644 index 000000000..86c407aff --- /dev/null +++ b/beian/include/alibabacloud/beian/model/DeleteUnbeianIpCheckTypeRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_DELETEUNBEIANIPCHECKTYPEREQUEST_H_ +#define ALIBABACLOUD_BEIAN_MODEL_DELETEUNBEIANIPCHECKTYPEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Beian { +namespace Model { +class ALIBABACLOUD_BEIAN_EXPORT DeleteUnbeianIpCheckTypeRequest : public RpcServiceRequest { +public: + DeleteUnbeianIpCheckTypeRequest(); + ~DeleteUnbeianIpCheckTypeRequest(); + std::string getIp() const; + void setIp(const std::string &ip); + std::string getRemark() const; + void setRemark(const std::string &remark); + int getCheckType() const; + void setCheckType(int checkType); + std::string getCaller() const; + void setCaller(const std::string &caller); + +private: + std::string ip_; + std::string remark_; + int checkType_; + std::string caller_; +}; +} // namespace Model +} // namespace Beian +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_BEIAN_MODEL_DELETEUNBEIANIPCHECKTYPEREQUEST_H_ diff --git a/beian/include/alibabacloud/beian/model/DeleteUnbeianIpCheckTypeResult.h b/beian/include/alibabacloud/beian/model/DeleteUnbeianIpCheckTypeResult.h new file mode 100644 index 000000000..897ee6eef --- /dev/null +++ b/beian/include/alibabacloud/beian/model/DeleteUnbeianIpCheckTypeResult.h @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_DELETEUNBEIANIPCHECKTYPERESULT_H_ +#define ALIBABACLOUD_BEIAN_MODEL_DELETEUNBEIANIPCHECKTYPERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Beian + { + namespace Model + { + class ALIBABACLOUD_BEIAN_EXPORT DeleteUnbeianIpCheckTypeResult : public ServiceResult + { + public: + struct HuntressIpCheckTypeResultDO + { + std::string msg; + bool success; + }; + + + DeleteUnbeianIpCheckTypeResult(); + explicit DeleteUnbeianIpCheckTypeResult(const std::string &payload); + ~DeleteUnbeianIpCheckTypeResult(); + HuntressIpCheckTypeResultDO getHuntressIpCheckTypeResultDO()const; + int getErrorCode()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + HuntressIpCheckTypeResultDO huntressIpCheckTypeResultDO_; + int errorCode_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_BEIAN_MODEL_DELETEUNBEIANIPCHECKTYPERESULT_H_ \ No newline at end of file diff --git a/beian/include/alibabacloud/beian/model/GetMainDomainRequest.h b/beian/include/alibabacloud/beian/model/GetMainDomainRequest.h new file mode 100644 index 000000000..11c3deefb --- /dev/null +++ b/beian/include/alibabacloud/beian/model/GetMainDomainRequest.h @@ -0,0 +1,42 @@ +/* + * 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_BEIAN_MODEL_GETMAINDOMAINREQUEST_H_ +#define ALIBABACLOUD_BEIAN_MODEL_GETMAINDOMAINREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Beian { +namespace Model { +class ALIBABACLOUD_BEIAN_EXPORT GetMainDomainRequest : public RpcServiceRequest { +public: + GetMainDomainRequest(); + ~GetMainDomainRequest(); + std::string getDomain() const; + void setDomain(const std::string &domain); + +private: + std::string domain_; +}; +} // namespace Model +} // namespace Beian +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_BEIAN_MODEL_GETMAINDOMAINREQUEST_H_ diff --git a/beian/include/alibabacloud/beian/model/GetMainDomainResult.h b/beian/include/alibabacloud/beian/model/GetMainDomainResult.h new file mode 100644 index 000000000..307745cc3 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/GetMainDomainResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_GETMAINDOMAINRESULT_H_ +#define ALIBABACLOUD_BEIAN_MODEL_GETMAINDOMAINRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Beian + { + namespace Model + { + class ALIBABACLOUD_BEIAN_EXPORT GetMainDomainResult : public ServiceResult + { + public: + + + GetMainDomainResult(); + explicit GetMainDomainResult(const std::string &payload); + ~GetMainDomainResult(); + std::string getMessage()const; + std::string getData()const; + std::string getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + std::string data_; + std::string code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_BEIAN_MODEL_GETMAINDOMAINRESULT_H_ \ No newline at end of file diff --git a/beian/include/alibabacloud/beian/model/InsertUnbeianIpCheckTypeRequest.h b/beian/include/alibabacloud/beian/model/InsertUnbeianIpCheckTypeRequest.h new file mode 100644 index 000000000..9c9e80824 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/InsertUnbeianIpCheckTypeRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_INSERTUNBEIANIPCHECKTYPEREQUEST_H_ +#define ALIBABACLOUD_BEIAN_MODEL_INSERTUNBEIANIPCHECKTYPEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Beian { +namespace Model { +class ALIBABACLOUD_BEIAN_EXPORT InsertUnbeianIpCheckTypeRequest : public RpcServiceRequest { +public: + InsertUnbeianIpCheckTypeRequest(); + ~InsertUnbeianIpCheckTypeRequest(); + std::string getIp() const; + void setIp(const std::string &ip); + std::string getRemark() const; + void setRemark(const std::string &remark); + int getCheckType() const; + void setCheckType(int checkType); + std::string getCaller() const; + void setCaller(const std::string &caller); + +private: + std::string ip_; + std::string remark_; + int checkType_; + std::string caller_; +}; +} // namespace Model +} // namespace Beian +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_BEIAN_MODEL_INSERTUNBEIANIPCHECKTYPEREQUEST_H_ diff --git a/beian/include/alibabacloud/beian/model/InsertUnbeianIpCheckTypeResult.h b/beian/include/alibabacloud/beian/model/InsertUnbeianIpCheckTypeResult.h new file mode 100644 index 000000000..f9e715583 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/InsertUnbeianIpCheckTypeResult.h @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_INSERTUNBEIANIPCHECKTYPERESULT_H_ +#define ALIBABACLOUD_BEIAN_MODEL_INSERTUNBEIANIPCHECKTYPERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Beian + { + namespace Model + { + class ALIBABACLOUD_BEIAN_EXPORT InsertUnbeianIpCheckTypeResult : public ServiceResult + { + public: + struct HuntressIpCheckTypeResultDO + { + std::string msg; + bool success; + }; + + + InsertUnbeianIpCheckTypeResult(); + explicit InsertUnbeianIpCheckTypeResult(const std::string &payload); + ~InsertUnbeianIpCheckTypeResult(); + HuntressIpCheckTypeResultDO getHuntressIpCheckTypeResultDO()const; + int getErrorCode()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + HuntressIpCheckTypeResultDO huntressIpCheckTypeResultDO_; + int errorCode_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_BEIAN_MODEL_INSERTUNBEIANIPCHECKTYPERESULT_H_ \ No newline at end of file diff --git a/beian/include/alibabacloud/beian/model/ListUnbeianIpCheckTypeRequest.h b/beian/include/alibabacloud/beian/model/ListUnbeianIpCheckTypeRequest.h new file mode 100644 index 000000000..61856e0d0 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/ListUnbeianIpCheckTypeRequest.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_BEIAN_MODEL_LISTUNBEIANIPCHECKTYPEREQUEST_H_ +#define ALIBABACLOUD_BEIAN_MODEL_LISTUNBEIANIPCHECKTYPEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Beian { +namespace Model { +class ALIBABACLOUD_BEIAN_EXPORT ListUnbeianIpCheckTypeRequest : public RpcServiceRequest { +public: + ListUnbeianIpCheckTypeRequest(); + ~ListUnbeianIpCheckTypeRequest(); + std::string getIp() const; + void setIp(const std::string &ip); + std::string getRemark() const; + void setRemark(const std::string &remark); + int getCheckType() const; + void setCheckType(int checkType); + std::string getCaller() const; + void setCaller(const std::string &caller); + int getLimit() const; + void setLimit(int limit); + int getPage() const; + void setPage(int page); + +private: + std::string ip_; + std::string remark_; + int checkType_; + std::string caller_; + int limit_; + int page_; +}; +} // namespace Model +} // namespace Beian +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_BEIAN_MODEL_LISTUNBEIANIPCHECKTYPEREQUEST_H_ diff --git a/beian/include/alibabacloud/beian/model/ListUnbeianIpCheckTypeResult.h b/beian/include/alibabacloud/beian/model/ListUnbeianIpCheckTypeResult.h new file mode 100644 index 000000000..dfa7da58d --- /dev/null +++ b/beian/include/alibabacloud/beian/model/ListUnbeianIpCheckTypeResult.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_LISTUNBEIANIPCHECKTYPERESULT_H_ +#define ALIBABACLOUD_BEIAN_MODEL_LISTUNBEIANIPCHECKTYPERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Beian + { + namespace Model + { + class ALIBABACLOUD_BEIAN_EXPORT ListUnbeianIpCheckTypeResult : public ServiceResult + { + public: + struct HuntressIpCheckTypeResultDO + { + struct ListItem + { + std::string caller; + int checkType; + std::string ip; + long aliuid; + std::string remark; + }; + std::string msg; + std::vector list; + bool success; + }; + + + ListUnbeianIpCheckTypeResult(); + explicit ListUnbeianIpCheckTypeResult(const std::string &payload); + ~ListUnbeianIpCheckTypeResult(); + HuntressIpCheckTypeResultDO getHuntressIpCheckTypeResultDO()const; + int getErrorCode()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + HuntressIpCheckTypeResultDO huntressIpCheckTypeResultDO_; + int errorCode_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_BEIAN_MODEL_LISTUNBEIANIPCHECKTYPERESULT_H_ \ No newline at end of file diff --git a/beian/include/alibabacloud/beian/model/ManageAccessorDomainRequest.h b/beian/include/alibabacloud/beian/model/ManageAccessorDomainRequest.h new file mode 100644 index 000000000..ccc1b79a4 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/ManageAccessorDomainRequest.h @@ -0,0 +1,48 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINREQUEST_H_ +#define ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Beian { +namespace Model { +class ALIBABACLOUD_BEIAN_EXPORT ManageAccessorDomainRequest : public RpcServiceRequest { +public: + ManageAccessorDomainRequest(); + ~ManageAccessorDomainRequest(); + std::string getCaller() const; + void setCaller(const std::string &caller); + std::string getDomain() const; + void setDomain(const std::string &domain); + std::string getOperation() const; + void setOperation(const std::string &operation); + +private: + std::string caller_; + std::string domain_; + std::string operation_; +}; +} // namespace Model +} // namespace Beian +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINREQUEST_H_ diff --git a/beian/include/alibabacloud/beian/model/ManageAccessorDomainResult.h b/beian/include/alibabacloud/beian/model/ManageAccessorDomainResult.h new file mode 100644 index 000000000..d2f6ba869 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/ManageAccessorDomainResult.h @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINRESULT_H_ +#define ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Beian + { + namespace Model + { + class ALIBABACLOUD_BEIAN_EXPORT ManageAccessorDomainResult : public ServiceResult + { + public: + + + ManageAccessorDomainResult(); + explicit ManageAccessorDomainResult(const std::string &payload); + ~ManageAccessorDomainResult(); + std::string getMessage()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINRESULT_H_ \ No newline at end of file diff --git a/beian/include/alibabacloud/beian/model/ManageAccessorDomainWhiteListRequest.h b/beian/include/alibabacloud/beian/model/ManageAccessorDomainWhiteListRequest.h new file mode 100644 index 000000000..0a4e6b0d3 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/ManageAccessorDomainWhiteListRequest.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_BEIAN_MODEL_MANAGEACCESSORDOMAINWHITELISTREQUEST_H_ +#define ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINWHITELISTREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Beian { +namespace Model { +class ALIBABACLOUD_BEIAN_EXPORT ManageAccessorDomainWhiteListRequest : public RpcServiceRequest { +public: + ManageAccessorDomainWhiteListRequest(); + ~ManageAccessorDomainWhiteListRequest(); + std::string getEndTime() const; + void setEndTime(const std::string &endTime); + std::vector getDomains() const; + void setDomains(const std::vector &domains); + std::string getRemark() const; + void setRemark(const std::string &remark); + std::string getStartTime() const; + void setStartTime(const std::string &startTime); + std::string getCaller() const; + void setCaller(const std::string &caller); + std::string getOperation() const; + void setOperation(const std::string &operation); + +private: + std::string endTime_; + std::vector domains_; + std::string remark_; + std::string startTime_; + std::string caller_; + std::string operation_; +}; +} // namespace Model +} // namespace Beian +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINWHITELISTREQUEST_H_ diff --git a/beian/include/alibabacloud/beian/model/ManageAccessorDomainWhiteListResult.h b/beian/include/alibabacloud/beian/model/ManageAccessorDomainWhiteListResult.h new file mode 100644 index 000000000..fb35a7481 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/ManageAccessorDomainWhiteListResult.h @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINWHITELISTRESULT_H_ +#define ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINWHITELISTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Beian + { + namespace Model + { + class ALIBABACLOUD_BEIAN_EXPORT ManageAccessorDomainWhiteListResult : public ServiceResult + { + public: + + + ManageAccessorDomainWhiteListResult(); + explicit ManageAccessorDomainWhiteListResult(const std::string &payload); + ~ManageAccessorDomainWhiteListResult(); + std::string getMessage()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINWHITELISTRESULT_H_ \ No newline at end of file diff --git a/beian/include/alibabacloud/beian/model/ManageAccessorIpRequest.h b/beian/include/alibabacloud/beian/model/ManageAccessorIpRequest.h new file mode 100644 index 000000000..06b2c984f --- /dev/null +++ b/beian/include/alibabacloud/beian/model/ManageAccessorIpRequest.h @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORIPREQUEST_H_ +#define ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORIPREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Beian { +namespace Model { +class ALIBABACLOUD_BEIAN_EXPORT ManageAccessorIpRequest : public RpcServiceRequest { +public: + ManageAccessorIpRequest(); + ~ManageAccessorIpRequest(); + std::string getIp() const; + void setIp(const std::string &ip); + std::string getRemark() const; + void setRemark(const std::string &remark); + std::string getCaller() const; + void setCaller(const std::string &caller); + int getIpVersion() const; + void setIpVersion(int ipVersion); + std::string getOperation() const; + void setOperation(const std::string &operation); + +private: + std::string ip_; + std::string remark_; + std::string caller_; + int ipVersion_; + std::string operation_; +}; +} // namespace Model +} // namespace Beian +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORIPREQUEST_H_ diff --git a/beian/include/alibabacloud/beian/model/ManageAccessorIpResult.h b/beian/include/alibabacloud/beian/model/ManageAccessorIpResult.h new file mode 100644 index 000000000..1ddf14363 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/ManageAccessorIpResult.h @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORIPRESULT_H_ +#define ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORIPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Beian + { + namespace Model + { + class ALIBABACLOUD_BEIAN_EXPORT ManageAccessorIpResult : public ServiceResult + { + public: + + + ManageAccessorIpResult(); + explicit ManageAccessorIpResult(const std::string &payload); + ~ManageAccessorIpResult(); + std::string getMessage()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORIPRESULT_H_ \ No newline at end of file diff --git a/beian/include/alibabacloud/beian/model/QueryAccessorDomainListRequest.h b/beian/include/alibabacloud/beian/model/QueryAccessorDomainListRequest.h new file mode 100644 index 000000000..5889de581 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/QueryAccessorDomainListRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINLISTREQUEST_H_ +#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINLISTREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Beian { +namespace Model { +class ALIBABACLOUD_BEIAN_EXPORT QueryAccessorDomainListRequest : public RpcServiceRequest { +public: + QueryAccessorDomainListRequest(); + ~QueryAccessorDomainListRequest(); + std::string getCaller() const; + void setCaller(const std::string &caller); + int getPageNo() const; + void setPageNo(int pageNo); + std::string getDomain() const; + void setDomain(const std::string &domain); + int getPageSize() const; + void setPageSize(int pageSize); + +private: + std::string caller_; + int pageNo_; + std::string domain_; + int pageSize_; +}; +} // namespace Model +} // namespace Beian +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINLISTREQUEST_H_ diff --git a/beian/include/alibabacloud/beian/model/QueryAccessorDomainListResult.h b/beian/include/alibabacloud/beian/model/QueryAccessorDomainListResult.h new file mode 100644 index 000000000..7dc6f4adc --- /dev/null +++ b/beian/include/alibabacloud/beian/model/QueryAccessorDomainListResult.h @@ -0,0 +1,59 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINLISTRESULT_H_ +#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINLISTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Beian + { + namespace Model + { + class ALIBABACLOUD_BEIAN_EXPORT QueryAccessorDomainListResult : public ServiceResult + { + public: + struct Data + { + std::vector domains; + }; + + + QueryAccessorDomainListResult(); + explicit QueryAccessorDomainListResult(const std::string &payload); + ~QueryAccessorDomainListResult(); + std::string getMessage()const; + Data getData()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINLISTRESULT_H_ \ No newline at end of file diff --git a/beian/include/alibabacloud/beian/model/QueryAccessorDomainRequest.h b/beian/include/alibabacloud/beian/model/QueryAccessorDomainRequest.h new file mode 100644 index 000000000..629db6e59 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/QueryAccessorDomainRequest.h @@ -0,0 +1,45 @@ +/* + * 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_BEIAN_MODEL_QUERYACCESSORDOMAINREQUEST_H_ +#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Beian { +namespace Model { +class ALIBABACLOUD_BEIAN_EXPORT QueryAccessorDomainRequest : public RpcServiceRequest { +public: + QueryAccessorDomainRequest(); + ~QueryAccessorDomainRequest(); + std::string getCaller() const; + void setCaller(const std::string &caller); + std::string getDomain() const; + void setDomain(const std::string &domain); + +private: + std::string caller_; + std::string domain_; +}; +} // namespace Model +} // namespace Beian +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINREQUEST_H_ diff --git a/beian/include/alibabacloud/beian/model/QueryAccessorDomainResult.h b/beian/include/alibabacloud/beian/model/QueryAccessorDomainResult.h new file mode 100644 index 000000000..a754db9c3 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/QueryAccessorDomainResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINRESULT_H_ +#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Beian + { + namespace Model + { + class ALIBABACLOUD_BEIAN_EXPORT QueryAccessorDomainResult : public ServiceResult + { + public: + + + QueryAccessorDomainResult(); + explicit QueryAccessorDomainResult(const std::string &payload); + ~QueryAccessorDomainResult(); + std::string getMessage()const; + bool getData()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + bool data_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINRESULT_H_ \ No newline at end of file diff --git a/beian/include/alibabacloud/beian/model/QueryAccessorDomainStatusRequest.h b/beian/include/alibabacloud/beian/model/QueryAccessorDomainStatusRequest.h new file mode 100644 index 000000000..4d0d02876 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/QueryAccessorDomainStatusRequest.h @@ -0,0 +1,45 @@ +/* + * 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_BEIAN_MODEL_QUERYACCESSORDOMAINSTATUSREQUEST_H_ +#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSTATUSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Beian { +namespace Model { +class ALIBABACLOUD_BEIAN_EXPORT QueryAccessorDomainStatusRequest : public RpcServiceRequest { +public: + QueryAccessorDomainStatusRequest(); + ~QueryAccessorDomainStatusRequest(); + std::string getCaller() const; + void setCaller(const std::string &caller); + std::string getDomain() const; + void setDomain(const std::string &domain); + +private: + std::string caller_; + std::string domain_; +}; +} // namespace Model +} // namespace Beian +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSTATUSREQUEST_H_ diff --git a/beian/include/alibabacloud/beian/model/QueryAccessorDomainStatusResult.h b/beian/include/alibabacloud/beian/model/QueryAccessorDomainStatusResult.h new file mode 100644 index 000000000..2dd943b6c --- /dev/null +++ b/beian/include/alibabacloud/beian/model/QueryAccessorDomainStatusResult.h @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSTATUSRESULT_H_ +#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSTATUSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Beian + { + namespace Model + { + class ALIBABACLOUD_BEIAN_EXPORT QueryAccessorDomainStatusResult : public ServiceResult + { + public: + struct Data + { + std::string status; + std::string domain; + int reasonCode; + std::string reason; + }; + + + QueryAccessorDomainStatusResult(); + explicit QueryAccessorDomainStatusResult(const std::string &payload); + ~QueryAccessorDomainStatusResult(); + std::string getMessage()const; + Data getData()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSTATUSRESULT_H_ \ No newline at end of file diff --git a/beian/include/alibabacloud/beian/model/QueryAccessorDomainWhiteListRequest.h b/beian/include/alibabacloud/beian/model/QueryAccessorDomainWhiteListRequest.h new file mode 100644 index 000000000..51d24eeb1 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/QueryAccessorDomainWhiteListRequest.h @@ -0,0 +1,45 @@ +/* + * 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_BEIAN_MODEL_QUERYACCESSORDOMAINWHITELISTREQUEST_H_ +#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINWHITELISTREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Beian { +namespace Model { +class ALIBABACLOUD_BEIAN_EXPORT QueryAccessorDomainWhiteListRequest : public RpcServiceRequest { +public: + QueryAccessorDomainWhiteListRequest(); + ~QueryAccessorDomainWhiteListRequest(); + std::string getCaller() const; + void setCaller(const std::string &caller); + std::string getDomain() const; + void setDomain(const std::string &domain); + +private: + std::string caller_; + std::string domain_; +}; +} // namespace Model +} // namespace Beian +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINWHITELISTREQUEST_H_ diff --git a/beian/include/alibabacloud/beian/model/QueryAccessorDomainWhiteListResult.h b/beian/include/alibabacloud/beian/model/QueryAccessorDomainWhiteListResult.h new file mode 100644 index 000000000..3e866857e --- /dev/null +++ b/beian/include/alibabacloud/beian/model/QueryAccessorDomainWhiteListResult.h @@ -0,0 +1,68 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINWHITELISTRESULT_H_ +#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINWHITELISTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Beian + { + namespace Model + { + class ALIBABACLOUD_BEIAN_EXPORT QueryAccessorDomainWhiteListResult : public ServiceResult + { + public: + struct Data + { + struct ItemsItem + { + std::string type; + std::string endTime; + bool valid; + std::string createTime; + std::string startTime; + }; + bool white; + std::vector items; + }; + + + QueryAccessorDomainWhiteListResult(); + explicit QueryAccessorDomainWhiteListResult(const std::string &payload); + ~QueryAccessorDomainWhiteListResult(); + std::string getMessage()const; + Data getData()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINWHITELISTRESULT_H_ \ No newline at end of file diff --git a/beian/include/alibabacloud/beian/model/QueryAccessorDomainsStatusRequest.h b/beian/include/alibabacloud/beian/model/QueryAccessorDomainsStatusRequest.h new file mode 100644 index 000000000..276c9f5be --- /dev/null +++ b/beian/include/alibabacloud/beian/model/QueryAccessorDomainsStatusRequest.h @@ -0,0 +1,45 @@ +/* + * 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_BEIAN_MODEL_QUERYACCESSORDOMAINSSTATUSREQUEST_H_ +#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSSTATUSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Beian { +namespace Model { +class ALIBABACLOUD_BEIAN_EXPORT QueryAccessorDomainsStatusRequest : public RpcServiceRequest { +public: + QueryAccessorDomainsStatusRequest(); + ~QueryAccessorDomainsStatusRequest(); + std::vector getDomains() const; + void setDomains(const std::vector &domains); + std::string getCaller() const; + void setCaller(const std::string &caller); + +private: + std::vector domains_; + std::string caller_; +}; +} // namespace Model +} // namespace Beian +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSSTATUSREQUEST_H_ diff --git a/beian/include/alibabacloud/beian/model/QueryAccessorDomainsStatusResult.h b/beian/include/alibabacloud/beian/model/QueryAccessorDomainsStatusResult.h new file mode 100644 index 000000000..a9eae5ad4 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/QueryAccessorDomainsStatusResult.h @@ -0,0 +1,62 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSSTATUSRESULT_H_ +#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSSTATUSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Beian + { + namespace Model + { + class ALIBABACLOUD_BEIAN_EXPORT QueryAccessorDomainsStatusResult : public ServiceResult + { + public: + struct DataItem + { + std::string status; + std::string domain; + int reasonCode; + std::string reason; + }; + + + QueryAccessorDomainsStatusResult(); + explicit QueryAccessorDomainsStatusResult(const std::string &payload); + ~QueryAccessorDomainsStatusResult(); + std::string getMessage()const; + std::vector getData()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + std::vector data_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSSTATUSRESULT_H_ \ No newline at end of file diff --git a/beian/include/alibabacloud/beian/model/QueryAccessorIpRequest.h b/beian/include/alibabacloud/beian/model/QueryAccessorIpRequest.h new file mode 100644 index 000000000..07bd70995 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/QueryAccessorIpRequest.h @@ -0,0 +1,45 @@ +/* + * 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_BEIAN_MODEL_QUERYACCESSORIPREQUEST_H_ +#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORIPREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Beian { +namespace Model { +class ALIBABACLOUD_BEIAN_EXPORT QueryAccessorIpRequest : public RpcServiceRequest { +public: + QueryAccessorIpRequest(); + ~QueryAccessorIpRequest(); + std::string getIp() const; + void setIp(const std::string &ip); + std::string getCaller() const; + void setCaller(const std::string &caller); + +private: + std::string ip_; + std::string caller_; +}; +} // namespace Model +} // namespace Beian +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORIPREQUEST_H_ diff --git a/beian/include/alibabacloud/beian/model/QueryAccessorIpResult.h b/beian/include/alibabacloud/beian/model/QueryAccessorIpResult.h new file mode 100644 index 000000000..e16ca94cf --- /dev/null +++ b/beian/include/alibabacloud/beian/model/QueryAccessorIpResult.h @@ -0,0 +1,55 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORIPRESULT_H_ +#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORIPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Beian + { + namespace Model + { + class ALIBABACLOUD_BEIAN_EXPORT QueryAccessorIpResult : public ServiceResult + { + public: + + + QueryAccessorIpResult(); + explicit QueryAccessorIpResult(const std::string &payload); + ~QueryAccessorIpResult(); + std::string getMessage()const; + bool getData()const; + std::string getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + bool data_; + std::string code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORIPRESULT_H_ \ No newline at end of file diff --git a/beian/include/alibabacloud/beian/model/SubmitAccessorFullDomainsOssListRequest.h b/beian/include/alibabacloud/beian/model/SubmitAccessorFullDomainsOssListRequest.h new file mode 100644 index 000000000..806364f82 --- /dev/null +++ b/beian/include/alibabacloud/beian/model/SubmitAccessorFullDomainsOssListRequest.h @@ -0,0 +1,45 @@ +/* + * 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_BEIAN_MODEL_SUBMITACCESSORFULLDOMAINSOSSLISTREQUEST_H_ +#define ALIBABACLOUD_BEIAN_MODEL_SUBMITACCESSORFULLDOMAINSOSSLISTREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Beian { +namespace Model { +class ALIBABACLOUD_BEIAN_EXPORT SubmitAccessorFullDomainsOssListRequest : public RpcServiceRequest { +public: + SubmitAccessorFullDomainsOssListRequest(); + ~SubmitAccessorFullDomainsOssListRequest(); + std::string getCaller() const; + void setCaller(const std::string &caller); + std::vector getOssList() const; + void setOssList(const std::vector &ossList); + +private: + std::string caller_; + std::vector ossList_; +}; +} // namespace Model +} // namespace Beian +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_BEIAN_MODEL_SUBMITACCESSORFULLDOMAINSOSSLISTREQUEST_H_ diff --git a/beian/include/alibabacloud/beian/model/SubmitAccessorFullDomainsOssListResult.h b/beian/include/alibabacloud/beian/model/SubmitAccessorFullDomainsOssListResult.h new file mode 100644 index 000000000..6e14445fa --- /dev/null +++ b/beian/include/alibabacloud/beian/model/SubmitAccessorFullDomainsOssListResult.h @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_BEIAN_MODEL_SUBMITACCESSORFULLDOMAINSOSSLISTRESULT_H_ +#define ALIBABACLOUD_BEIAN_MODEL_SUBMITACCESSORFULLDOMAINSOSSLISTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Beian + { + namespace Model + { + class ALIBABACLOUD_BEIAN_EXPORT SubmitAccessorFullDomainsOssListResult : public ServiceResult + { + public: + + + SubmitAccessorFullDomainsOssListResult(); + explicit SubmitAccessorFullDomainsOssListResult(const std::string &payload); + ~SubmitAccessorFullDomainsOssListResult(); + std::string getMessage()const; + int getCode()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + + }; + } + } +} +#endif // !ALIBABACLOUD_BEIAN_MODEL_SUBMITACCESSORFULLDOMAINSOSSLISTRESULT_H_ \ No newline at end of file diff --git a/beian/src/BeianClient.cc b/beian/src/BeianClient.cc new file mode 100644 index 000000000..80f65a543 --- /dev/null +++ b/beian/src/BeianClient.cc @@ -0,0 +1,557 @@ +/* + * 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::Beian; +using namespace AlibabaCloud::Beian::Model; + +namespace +{ + const std::string SERVICE_NAME = "Beian"; +} + +BeianClient::BeianClient(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, ""); +} + +BeianClient::BeianClient(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, ""); +} + +BeianClient::BeianClient(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, ""); +} + +BeianClient::~BeianClient() +{} + +BeianClient::DeleteUnbeianIpCheckTypeOutcome BeianClient::deleteUnbeianIpCheckType(const DeleteUnbeianIpCheckTypeRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteUnbeianIpCheckTypeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteUnbeianIpCheckTypeOutcome(DeleteUnbeianIpCheckTypeResult(outcome.result())); + else + return DeleteUnbeianIpCheckTypeOutcome(outcome.error()); +} + +void BeianClient::deleteUnbeianIpCheckTypeAsync(const DeleteUnbeianIpCheckTypeRequest& request, const DeleteUnbeianIpCheckTypeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteUnbeianIpCheckType(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +BeianClient::DeleteUnbeianIpCheckTypeOutcomeCallable BeianClient::deleteUnbeianIpCheckTypeCallable(const DeleteUnbeianIpCheckTypeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteUnbeianIpCheckType(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +BeianClient::GetMainDomainOutcome BeianClient::getMainDomain(const GetMainDomainRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetMainDomainOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetMainDomainOutcome(GetMainDomainResult(outcome.result())); + else + return GetMainDomainOutcome(outcome.error()); +} + +void BeianClient::getMainDomainAsync(const GetMainDomainRequest& request, const GetMainDomainAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getMainDomain(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +BeianClient::GetMainDomainOutcomeCallable BeianClient::getMainDomainCallable(const GetMainDomainRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getMainDomain(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +BeianClient::InsertUnbeianIpCheckTypeOutcome BeianClient::insertUnbeianIpCheckType(const InsertUnbeianIpCheckTypeRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return InsertUnbeianIpCheckTypeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return InsertUnbeianIpCheckTypeOutcome(InsertUnbeianIpCheckTypeResult(outcome.result())); + else + return InsertUnbeianIpCheckTypeOutcome(outcome.error()); +} + +void BeianClient::insertUnbeianIpCheckTypeAsync(const InsertUnbeianIpCheckTypeRequest& request, const InsertUnbeianIpCheckTypeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, insertUnbeianIpCheckType(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +BeianClient::InsertUnbeianIpCheckTypeOutcomeCallable BeianClient::insertUnbeianIpCheckTypeCallable(const InsertUnbeianIpCheckTypeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->insertUnbeianIpCheckType(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +BeianClient::ListUnbeianIpCheckTypeOutcome BeianClient::listUnbeianIpCheckType(const ListUnbeianIpCheckTypeRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListUnbeianIpCheckTypeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListUnbeianIpCheckTypeOutcome(ListUnbeianIpCheckTypeResult(outcome.result())); + else + return ListUnbeianIpCheckTypeOutcome(outcome.error()); +} + +void BeianClient::listUnbeianIpCheckTypeAsync(const ListUnbeianIpCheckTypeRequest& request, const ListUnbeianIpCheckTypeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listUnbeianIpCheckType(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +BeianClient::ListUnbeianIpCheckTypeOutcomeCallable BeianClient::listUnbeianIpCheckTypeCallable(const ListUnbeianIpCheckTypeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listUnbeianIpCheckType(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +BeianClient::ManageAccessorDomainOutcome BeianClient::manageAccessorDomain(const ManageAccessorDomainRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ManageAccessorDomainOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ManageAccessorDomainOutcome(ManageAccessorDomainResult(outcome.result())); + else + return ManageAccessorDomainOutcome(outcome.error()); +} + +void BeianClient::manageAccessorDomainAsync(const ManageAccessorDomainRequest& request, const ManageAccessorDomainAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, manageAccessorDomain(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +BeianClient::ManageAccessorDomainOutcomeCallable BeianClient::manageAccessorDomainCallable(const ManageAccessorDomainRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->manageAccessorDomain(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +BeianClient::ManageAccessorDomainWhiteListOutcome BeianClient::manageAccessorDomainWhiteList(const ManageAccessorDomainWhiteListRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ManageAccessorDomainWhiteListOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ManageAccessorDomainWhiteListOutcome(ManageAccessorDomainWhiteListResult(outcome.result())); + else + return ManageAccessorDomainWhiteListOutcome(outcome.error()); +} + +void BeianClient::manageAccessorDomainWhiteListAsync(const ManageAccessorDomainWhiteListRequest& request, const ManageAccessorDomainWhiteListAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, manageAccessorDomainWhiteList(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +BeianClient::ManageAccessorDomainWhiteListOutcomeCallable BeianClient::manageAccessorDomainWhiteListCallable(const ManageAccessorDomainWhiteListRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->manageAccessorDomainWhiteList(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +BeianClient::ManageAccessorIpOutcome BeianClient::manageAccessorIp(const ManageAccessorIpRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ManageAccessorIpOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ManageAccessorIpOutcome(ManageAccessorIpResult(outcome.result())); + else + return ManageAccessorIpOutcome(outcome.error()); +} + +void BeianClient::manageAccessorIpAsync(const ManageAccessorIpRequest& request, const ManageAccessorIpAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, manageAccessorIp(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +BeianClient::ManageAccessorIpOutcomeCallable BeianClient::manageAccessorIpCallable(const ManageAccessorIpRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->manageAccessorIp(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +BeianClient::QueryAccessorDomainOutcome BeianClient::queryAccessorDomain(const QueryAccessorDomainRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return QueryAccessorDomainOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return QueryAccessorDomainOutcome(QueryAccessorDomainResult(outcome.result())); + else + return QueryAccessorDomainOutcome(outcome.error()); +} + +void BeianClient::queryAccessorDomainAsync(const QueryAccessorDomainRequest& request, const QueryAccessorDomainAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, queryAccessorDomain(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +BeianClient::QueryAccessorDomainOutcomeCallable BeianClient::queryAccessorDomainCallable(const QueryAccessorDomainRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->queryAccessorDomain(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +BeianClient::QueryAccessorDomainListOutcome BeianClient::queryAccessorDomainList(const QueryAccessorDomainListRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return QueryAccessorDomainListOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return QueryAccessorDomainListOutcome(QueryAccessorDomainListResult(outcome.result())); + else + return QueryAccessorDomainListOutcome(outcome.error()); +} + +void BeianClient::queryAccessorDomainListAsync(const QueryAccessorDomainListRequest& request, const QueryAccessorDomainListAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, queryAccessorDomainList(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +BeianClient::QueryAccessorDomainListOutcomeCallable BeianClient::queryAccessorDomainListCallable(const QueryAccessorDomainListRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->queryAccessorDomainList(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +BeianClient::QueryAccessorDomainStatusOutcome BeianClient::queryAccessorDomainStatus(const QueryAccessorDomainStatusRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return QueryAccessorDomainStatusOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return QueryAccessorDomainStatusOutcome(QueryAccessorDomainStatusResult(outcome.result())); + else + return QueryAccessorDomainStatusOutcome(outcome.error()); +} + +void BeianClient::queryAccessorDomainStatusAsync(const QueryAccessorDomainStatusRequest& request, const QueryAccessorDomainStatusAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, queryAccessorDomainStatus(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +BeianClient::QueryAccessorDomainStatusOutcomeCallable BeianClient::queryAccessorDomainStatusCallable(const QueryAccessorDomainStatusRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->queryAccessorDomainStatus(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +BeianClient::QueryAccessorDomainWhiteListOutcome BeianClient::queryAccessorDomainWhiteList(const QueryAccessorDomainWhiteListRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return QueryAccessorDomainWhiteListOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return QueryAccessorDomainWhiteListOutcome(QueryAccessorDomainWhiteListResult(outcome.result())); + else + return QueryAccessorDomainWhiteListOutcome(outcome.error()); +} + +void BeianClient::queryAccessorDomainWhiteListAsync(const QueryAccessorDomainWhiteListRequest& request, const QueryAccessorDomainWhiteListAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, queryAccessorDomainWhiteList(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +BeianClient::QueryAccessorDomainWhiteListOutcomeCallable BeianClient::queryAccessorDomainWhiteListCallable(const QueryAccessorDomainWhiteListRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->queryAccessorDomainWhiteList(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +BeianClient::QueryAccessorDomainsStatusOutcome BeianClient::queryAccessorDomainsStatus(const QueryAccessorDomainsStatusRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return QueryAccessorDomainsStatusOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return QueryAccessorDomainsStatusOutcome(QueryAccessorDomainsStatusResult(outcome.result())); + else + return QueryAccessorDomainsStatusOutcome(outcome.error()); +} + +void BeianClient::queryAccessorDomainsStatusAsync(const QueryAccessorDomainsStatusRequest& request, const QueryAccessorDomainsStatusAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, queryAccessorDomainsStatus(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +BeianClient::QueryAccessorDomainsStatusOutcomeCallable BeianClient::queryAccessorDomainsStatusCallable(const QueryAccessorDomainsStatusRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->queryAccessorDomainsStatus(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +BeianClient::QueryAccessorIpOutcome BeianClient::queryAccessorIp(const QueryAccessorIpRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return QueryAccessorIpOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return QueryAccessorIpOutcome(QueryAccessorIpResult(outcome.result())); + else + return QueryAccessorIpOutcome(outcome.error()); +} + +void BeianClient::queryAccessorIpAsync(const QueryAccessorIpRequest& request, const QueryAccessorIpAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, queryAccessorIp(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +BeianClient::QueryAccessorIpOutcomeCallable BeianClient::queryAccessorIpCallable(const QueryAccessorIpRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->queryAccessorIp(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +BeianClient::SubmitAccessorFullDomainsOssListOutcome BeianClient::submitAccessorFullDomainsOssList(const SubmitAccessorFullDomainsOssListRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return SubmitAccessorFullDomainsOssListOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SubmitAccessorFullDomainsOssListOutcome(SubmitAccessorFullDomainsOssListResult(outcome.result())); + else + return SubmitAccessorFullDomainsOssListOutcome(outcome.error()); +} + +void BeianClient::submitAccessorFullDomainsOssListAsync(const SubmitAccessorFullDomainsOssListRequest& request, const SubmitAccessorFullDomainsOssListAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, submitAccessorFullDomainsOssList(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +BeianClient::SubmitAccessorFullDomainsOssListOutcomeCallable BeianClient::submitAccessorFullDomainsOssListCallable(const SubmitAccessorFullDomainsOssListRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->submitAccessorFullDomainsOssList(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + diff --git a/beian/src/model/DeleteUnbeianIpCheckTypeRequest.cc b/beian/src/model/DeleteUnbeianIpCheckTypeRequest.cc new file mode 100644 index 000000000..e76e7f612 --- /dev/null +++ b/beian/src/model/DeleteUnbeianIpCheckTypeRequest.cc @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Beian::Model::DeleteUnbeianIpCheckTypeRequest; + +DeleteUnbeianIpCheckTypeRequest::DeleteUnbeianIpCheckTypeRequest() + : RpcServiceRequest("beian", "2016-08-10", "DeleteUnbeianIpCheckType") { + setMethod(HttpRequest::Method::Post); +} + +DeleteUnbeianIpCheckTypeRequest::~DeleteUnbeianIpCheckTypeRequest() {} + +std::string DeleteUnbeianIpCheckTypeRequest::getIp() const { + return ip_; +} + +void DeleteUnbeianIpCheckTypeRequest::setIp(const std::string &ip) { + ip_ = ip; + setParameter(std::string("Ip"), ip); +} + +std::string DeleteUnbeianIpCheckTypeRequest::getRemark() const { + return remark_; +} + +void DeleteUnbeianIpCheckTypeRequest::setRemark(const std::string &remark) { + remark_ = remark; + setParameter(std::string("Remark"), remark); +} + +int DeleteUnbeianIpCheckTypeRequest::getCheckType() const { + return checkType_; +} + +void DeleteUnbeianIpCheckTypeRequest::setCheckType(int checkType) { + checkType_ = checkType; + setParameter(std::string("CheckType"), std::to_string(checkType)); +} + +std::string DeleteUnbeianIpCheckTypeRequest::getCaller() const { + return caller_; +} + +void DeleteUnbeianIpCheckTypeRequest::setCaller(const std::string &caller) { + caller_ = caller; + setParameter(std::string("Caller"), caller); +} + diff --git a/beian/src/model/DeleteUnbeianIpCheckTypeResult.cc b/beian/src/model/DeleteUnbeianIpCheckTypeResult.cc new file mode 100644 index 000000000..e6c883130 --- /dev/null +++ b/beian/src/model/DeleteUnbeianIpCheckTypeResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Beian; +using namespace AlibabaCloud::Beian::Model; + +DeleteUnbeianIpCheckTypeResult::DeleteUnbeianIpCheckTypeResult() : + ServiceResult() +{} + +DeleteUnbeianIpCheckTypeResult::DeleteUnbeianIpCheckTypeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteUnbeianIpCheckTypeResult::~DeleteUnbeianIpCheckTypeResult() +{} + +void DeleteUnbeianIpCheckTypeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto huntressIpCheckTypeResultDONode = value["HuntressIpCheckTypeResultDO"]; + if(!huntressIpCheckTypeResultDONode["Msg"].isNull()) + huntressIpCheckTypeResultDO_.msg = huntressIpCheckTypeResultDONode["Msg"].asString(); + if(!huntressIpCheckTypeResultDONode["Success"].isNull()) + huntressIpCheckTypeResultDO_.success = huntressIpCheckTypeResultDONode["Success"].asString() == "true"; + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["ErrorCode"].isNull()) + errorCode_ = std::stoi(value["ErrorCode"].asString()); + +} + +DeleteUnbeianIpCheckTypeResult::HuntressIpCheckTypeResultDO DeleteUnbeianIpCheckTypeResult::getHuntressIpCheckTypeResultDO()const +{ + return huntressIpCheckTypeResultDO_; +} + +int DeleteUnbeianIpCheckTypeResult::getErrorCode()const +{ + return errorCode_; +} + +std::string DeleteUnbeianIpCheckTypeResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool DeleteUnbeianIpCheckTypeResult::getSuccess()const +{ + return success_; +} + diff --git a/beian/src/model/GetMainDomainRequest.cc b/beian/src/model/GetMainDomainRequest.cc new file mode 100644 index 000000000..bd3c7cd87 --- /dev/null +++ b/beian/src/model/GetMainDomainRequest.cc @@ -0,0 +1,36 @@ +/* + * 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::Beian::Model::GetMainDomainRequest; + +GetMainDomainRequest::GetMainDomainRequest() + : RpcServiceRequest("beian", "2016-08-10", "GetMainDomain") { + setMethod(HttpRequest::Method::Post); +} + +GetMainDomainRequest::~GetMainDomainRequest() {} + +std::string GetMainDomainRequest::getDomain() const { + return domain_; +} + +void GetMainDomainRequest::setDomain(const std::string &domain) { + domain_ = domain; + setParameter(std::string("Domain"), domain); +} + diff --git a/beian/src/model/GetMainDomainResult.cc b/beian/src/model/GetMainDomainResult.cc new file mode 100644 index 000000000..f885cb53e --- /dev/null +++ b/beian/src/model/GetMainDomainResult.cc @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Beian; +using namespace AlibabaCloud::Beian::Model; + +GetMainDomainResult::GetMainDomainResult() : + ServiceResult() +{} + +GetMainDomainResult::GetMainDomainResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetMainDomainResult::~GetMainDomainResult() +{} + +void GetMainDomainResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["Data"].isNull()) + data_ = value["Data"].asString(); + +} + +std::string GetMainDomainResult::getMessage()const +{ + return message_; +} + +std::string GetMainDomainResult::getData()const +{ + return data_; +} + +std::string GetMainDomainResult::getCode()const +{ + return code_; +} + diff --git a/beian/src/model/InsertUnbeianIpCheckTypeRequest.cc b/beian/src/model/InsertUnbeianIpCheckTypeRequest.cc new file mode 100644 index 000000000..bf16e224a --- /dev/null +++ b/beian/src/model/InsertUnbeianIpCheckTypeRequest.cc @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Beian::Model::InsertUnbeianIpCheckTypeRequest; + +InsertUnbeianIpCheckTypeRequest::InsertUnbeianIpCheckTypeRequest() + : RpcServiceRequest("beian", "2016-08-10", "InsertUnbeianIpCheckType") { + setMethod(HttpRequest::Method::Post); +} + +InsertUnbeianIpCheckTypeRequest::~InsertUnbeianIpCheckTypeRequest() {} + +std::string InsertUnbeianIpCheckTypeRequest::getIp() const { + return ip_; +} + +void InsertUnbeianIpCheckTypeRequest::setIp(const std::string &ip) { + ip_ = ip; + setParameter(std::string("Ip"), ip); +} + +std::string InsertUnbeianIpCheckTypeRequest::getRemark() const { + return remark_; +} + +void InsertUnbeianIpCheckTypeRequest::setRemark(const std::string &remark) { + remark_ = remark; + setParameter(std::string("Remark"), remark); +} + +int InsertUnbeianIpCheckTypeRequest::getCheckType() const { + return checkType_; +} + +void InsertUnbeianIpCheckTypeRequest::setCheckType(int checkType) { + checkType_ = checkType; + setParameter(std::string("CheckType"), std::to_string(checkType)); +} + +std::string InsertUnbeianIpCheckTypeRequest::getCaller() const { + return caller_; +} + +void InsertUnbeianIpCheckTypeRequest::setCaller(const std::string &caller) { + caller_ = caller; + setParameter(std::string("Caller"), caller); +} + diff --git a/beian/src/model/InsertUnbeianIpCheckTypeResult.cc b/beian/src/model/InsertUnbeianIpCheckTypeResult.cc new file mode 100644 index 000000000..409111a63 --- /dev/null +++ b/beian/src/model/InsertUnbeianIpCheckTypeResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Beian; +using namespace AlibabaCloud::Beian::Model; + +InsertUnbeianIpCheckTypeResult::InsertUnbeianIpCheckTypeResult() : + ServiceResult() +{} + +InsertUnbeianIpCheckTypeResult::InsertUnbeianIpCheckTypeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +InsertUnbeianIpCheckTypeResult::~InsertUnbeianIpCheckTypeResult() +{} + +void InsertUnbeianIpCheckTypeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto huntressIpCheckTypeResultDONode = value["HuntressIpCheckTypeResultDO"]; + if(!huntressIpCheckTypeResultDONode["Msg"].isNull()) + huntressIpCheckTypeResultDO_.msg = huntressIpCheckTypeResultDONode["Msg"].asString(); + if(!huntressIpCheckTypeResultDONode["Success"].isNull()) + huntressIpCheckTypeResultDO_.success = huntressIpCheckTypeResultDONode["Success"].asString() == "true"; + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["ErrorCode"].isNull()) + errorCode_ = std::stoi(value["ErrorCode"].asString()); + +} + +InsertUnbeianIpCheckTypeResult::HuntressIpCheckTypeResultDO InsertUnbeianIpCheckTypeResult::getHuntressIpCheckTypeResultDO()const +{ + return huntressIpCheckTypeResultDO_; +} + +int InsertUnbeianIpCheckTypeResult::getErrorCode()const +{ + return errorCode_; +} + +std::string InsertUnbeianIpCheckTypeResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool InsertUnbeianIpCheckTypeResult::getSuccess()const +{ + return success_; +} + diff --git a/beian/src/model/ListUnbeianIpCheckTypeRequest.cc b/beian/src/model/ListUnbeianIpCheckTypeRequest.cc new file mode 100644 index 000000000..01f6af9e5 --- /dev/null +++ b/beian/src/model/ListUnbeianIpCheckTypeRequest.cc @@ -0,0 +1,81 @@ +/* + * 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::Beian::Model::ListUnbeianIpCheckTypeRequest; + +ListUnbeianIpCheckTypeRequest::ListUnbeianIpCheckTypeRequest() + : RpcServiceRequest("beian", "2016-08-10", "ListUnbeianIpCheckType") { + setMethod(HttpRequest::Method::Post); +} + +ListUnbeianIpCheckTypeRequest::~ListUnbeianIpCheckTypeRequest() {} + +std::string ListUnbeianIpCheckTypeRequest::getIp() const { + return ip_; +} + +void ListUnbeianIpCheckTypeRequest::setIp(const std::string &ip) { + ip_ = ip; + setParameter(std::string("Ip"), ip); +} + +std::string ListUnbeianIpCheckTypeRequest::getRemark() const { + return remark_; +} + +void ListUnbeianIpCheckTypeRequest::setRemark(const std::string &remark) { + remark_ = remark; + setParameter(std::string("Remark"), remark); +} + +int ListUnbeianIpCheckTypeRequest::getCheckType() const { + return checkType_; +} + +void ListUnbeianIpCheckTypeRequest::setCheckType(int checkType) { + checkType_ = checkType; + setParameter(std::string("CheckType"), std::to_string(checkType)); +} + +std::string ListUnbeianIpCheckTypeRequest::getCaller() const { + return caller_; +} + +void ListUnbeianIpCheckTypeRequest::setCaller(const std::string &caller) { + caller_ = caller; + setParameter(std::string("Caller"), caller); +} + +int ListUnbeianIpCheckTypeRequest::getLimit() const { + return limit_; +} + +void ListUnbeianIpCheckTypeRequest::setLimit(int limit) { + limit_ = limit; + setParameter(std::string("Limit"), std::to_string(limit)); +} + +int ListUnbeianIpCheckTypeRequest::getPage() const { + return page_; +} + +void ListUnbeianIpCheckTypeRequest::setPage(int page) { + page_ = page; + setParameter(std::string("Page"), std::to_string(page)); +} + diff --git a/beian/src/model/ListUnbeianIpCheckTypeResult.cc b/beian/src/model/ListUnbeianIpCheckTypeResult.cc new file mode 100644 index 000000000..902ec0cfa --- /dev/null +++ b/beian/src/model/ListUnbeianIpCheckTypeResult.cc @@ -0,0 +1,91 @@ +/* + * 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::Beian; +using namespace AlibabaCloud::Beian::Model; + +ListUnbeianIpCheckTypeResult::ListUnbeianIpCheckTypeResult() : + ServiceResult() +{} + +ListUnbeianIpCheckTypeResult::ListUnbeianIpCheckTypeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListUnbeianIpCheckTypeResult::~ListUnbeianIpCheckTypeResult() +{} + +void ListUnbeianIpCheckTypeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto huntressIpCheckTypeResultDONode = value["HuntressIpCheckTypeResultDO"]; + if(!huntressIpCheckTypeResultDONode["Msg"].isNull()) + huntressIpCheckTypeResultDO_.msg = huntressIpCheckTypeResultDONode["Msg"].asString(); + if(!huntressIpCheckTypeResultDONode["Success"].isNull()) + huntressIpCheckTypeResultDO_.success = huntressIpCheckTypeResultDONode["Success"].asString() == "true"; + auto allListNode = huntressIpCheckTypeResultDONode["List"]["ListItem"]; + for (auto huntressIpCheckTypeResultDONodeListListItem : allListNode) + { + HuntressIpCheckTypeResultDO::ListItem listItemObject; + if(!huntressIpCheckTypeResultDONodeListListItem["Ip"].isNull()) + listItemObject.ip = huntressIpCheckTypeResultDONodeListListItem["Ip"].asString(); + if(!huntressIpCheckTypeResultDONodeListListItem["Aliuid"].isNull()) + listItemObject.aliuid = std::stol(huntressIpCheckTypeResultDONodeListListItem["Aliuid"].asString()); + if(!huntressIpCheckTypeResultDONodeListListItem["CheckType"].isNull()) + listItemObject.checkType = std::stoi(huntressIpCheckTypeResultDONodeListListItem["CheckType"].asString()); + if(!huntressIpCheckTypeResultDONodeListListItem["Caller"].isNull()) + listItemObject.caller = huntressIpCheckTypeResultDONodeListListItem["Caller"].asString(); + if(!huntressIpCheckTypeResultDONodeListListItem["Remark"].isNull()) + listItemObject.remark = huntressIpCheckTypeResultDONodeListListItem["Remark"].asString(); + huntressIpCheckTypeResultDO_.list.push_back(listItemObject); + } + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["ErrorCode"].isNull()) + errorCode_ = std::stoi(value["ErrorCode"].asString()); + +} + +ListUnbeianIpCheckTypeResult::HuntressIpCheckTypeResultDO ListUnbeianIpCheckTypeResult::getHuntressIpCheckTypeResultDO()const +{ + return huntressIpCheckTypeResultDO_; +} + +int ListUnbeianIpCheckTypeResult::getErrorCode()const +{ + return errorCode_; +} + +std::string ListUnbeianIpCheckTypeResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool ListUnbeianIpCheckTypeResult::getSuccess()const +{ + return success_; +} + diff --git a/beian/src/model/ManageAccessorDomainRequest.cc b/beian/src/model/ManageAccessorDomainRequest.cc new file mode 100644 index 000000000..0edb4d48a --- /dev/null +++ b/beian/src/model/ManageAccessorDomainRequest.cc @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Beian::Model::ManageAccessorDomainRequest; + +ManageAccessorDomainRequest::ManageAccessorDomainRequest() + : RpcServiceRequest("beian", "2016-08-10", "ManageAccessorDomain") { + setMethod(HttpRequest::Method::Post); +} + +ManageAccessorDomainRequest::~ManageAccessorDomainRequest() {} + +std::string ManageAccessorDomainRequest::getCaller() const { + return caller_; +} + +void ManageAccessorDomainRequest::setCaller(const std::string &caller) { + caller_ = caller; + setParameter(std::string("Caller"), caller); +} + +std::string ManageAccessorDomainRequest::getDomain() const { + return domain_; +} + +void ManageAccessorDomainRequest::setDomain(const std::string &domain) { + domain_ = domain; + setParameter(std::string("Domain"), domain); +} + +std::string ManageAccessorDomainRequest::getOperation() const { + return operation_; +} + +void ManageAccessorDomainRequest::setOperation(const std::string &operation) { + operation_ = operation; + setParameter(std::string("Operation"), operation); +} + diff --git a/beian/src/model/ManageAccessorDomainResult.cc b/beian/src/model/ManageAccessorDomainResult.cc new file mode 100644 index 000000000..8c1d9fd68 --- /dev/null +++ b/beian/src/model/ManageAccessorDomainResult.cc @@ -0,0 +1,58 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Beian; +using namespace AlibabaCloud::Beian::Model; + +ManageAccessorDomainResult::ManageAccessorDomainResult() : + ServiceResult() +{} + +ManageAccessorDomainResult::ManageAccessorDomainResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ManageAccessorDomainResult::~ManageAccessorDomainResult() +{} + +void ManageAccessorDomainResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string ManageAccessorDomainResult::getMessage()const +{ + return message_; +} + +int ManageAccessorDomainResult::getCode()const +{ + return code_; +} + diff --git a/beian/src/model/ManageAccessorDomainWhiteListRequest.cc b/beian/src/model/ManageAccessorDomainWhiteListRequest.cc new file mode 100644 index 000000000..868bebbfe --- /dev/null +++ b/beian/src/model/ManageAccessorDomainWhiteListRequest.cc @@ -0,0 +1,80 @@ +/* + * 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::Beian::Model::ManageAccessorDomainWhiteListRequest; + +ManageAccessorDomainWhiteListRequest::ManageAccessorDomainWhiteListRequest() + : RpcServiceRequest("beian", "2016-08-10", "ManageAccessorDomainWhiteList") { + setMethod(HttpRequest::Method::Post); +} + +ManageAccessorDomainWhiteListRequest::~ManageAccessorDomainWhiteListRequest() {} + +std::string ManageAccessorDomainWhiteListRequest::getEndTime() const { + return endTime_; +} + +void ManageAccessorDomainWhiteListRequest::setEndTime(const std::string &endTime) { + endTime_ = endTime; + setParameter(std::string("EndTime"), endTime); +} + +std::vector ManageAccessorDomainWhiteListRequest::getDomains() const { + return domains_; +} + +void ManageAccessorDomainWhiteListRequest::setDomains(const std::vector &domains) { + domains_ = domains; +} + +std::string ManageAccessorDomainWhiteListRequest::getRemark() const { + return remark_; +} + +void ManageAccessorDomainWhiteListRequest::setRemark(const std::string &remark) { + remark_ = remark; + setParameter(std::string("Remark"), remark); +} + +std::string ManageAccessorDomainWhiteListRequest::getStartTime() const { + return startTime_; +} + +void ManageAccessorDomainWhiteListRequest::setStartTime(const std::string &startTime) { + startTime_ = startTime; + setParameter(std::string("StartTime"), startTime); +} + +std::string ManageAccessorDomainWhiteListRequest::getCaller() const { + return caller_; +} + +void ManageAccessorDomainWhiteListRequest::setCaller(const std::string &caller) { + caller_ = caller; + setParameter(std::string("Caller"), caller); +} + +std::string ManageAccessorDomainWhiteListRequest::getOperation() const { + return operation_; +} + +void ManageAccessorDomainWhiteListRequest::setOperation(const std::string &operation) { + operation_ = operation; + setParameter(std::string("Operation"), operation); +} + diff --git a/beian/src/model/ManageAccessorDomainWhiteListResult.cc b/beian/src/model/ManageAccessorDomainWhiteListResult.cc new file mode 100644 index 000000000..14cb82691 --- /dev/null +++ b/beian/src/model/ManageAccessorDomainWhiteListResult.cc @@ -0,0 +1,58 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Beian; +using namespace AlibabaCloud::Beian::Model; + +ManageAccessorDomainWhiteListResult::ManageAccessorDomainWhiteListResult() : + ServiceResult() +{} + +ManageAccessorDomainWhiteListResult::ManageAccessorDomainWhiteListResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ManageAccessorDomainWhiteListResult::~ManageAccessorDomainWhiteListResult() +{} + +void ManageAccessorDomainWhiteListResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string ManageAccessorDomainWhiteListResult::getMessage()const +{ + return message_; +} + +int ManageAccessorDomainWhiteListResult::getCode()const +{ + return code_; +} + diff --git a/beian/src/model/ManageAccessorIpRequest.cc b/beian/src/model/ManageAccessorIpRequest.cc new file mode 100644 index 000000000..97a812199 --- /dev/null +++ b/beian/src/model/ManageAccessorIpRequest.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 + +using AlibabaCloud::Beian::Model::ManageAccessorIpRequest; + +ManageAccessorIpRequest::ManageAccessorIpRequest() + : RpcServiceRequest("beian", "2016-08-10", "ManageAccessorIp") { + setMethod(HttpRequest::Method::Post); +} + +ManageAccessorIpRequest::~ManageAccessorIpRequest() {} + +std::string ManageAccessorIpRequest::getIp() const { + return ip_; +} + +void ManageAccessorIpRequest::setIp(const std::string &ip) { + ip_ = ip; + setParameter(std::string("Ip"), ip); +} + +std::string ManageAccessorIpRequest::getRemark() const { + return remark_; +} + +void ManageAccessorIpRequest::setRemark(const std::string &remark) { + remark_ = remark; + setParameter(std::string("Remark"), remark); +} + +std::string ManageAccessorIpRequest::getCaller() const { + return caller_; +} + +void ManageAccessorIpRequest::setCaller(const std::string &caller) { + caller_ = caller; + setParameter(std::string("Caller"), caller); +} + +int ManageAccessorIpRequest::getIpVersion() const { + return ipVersion_; +} + +void ManageAccessorIpRequest::setIpVersion(int ipVersion) { + ipVersion_ = ipVersion; + setParameter(std::string("IpVersion"), std::to_string(ipVersion)); +} + +std::string ManageAccessorIpRequest::getOperation() const { + return operation_; +} + +void ManageAccessorIpRequest::setOperation(const std::string &operation) { + operation_ = operation; + setParameter(std::string("Operation"), operation); +} + diff --git a/beian/src/model/ManageAccessorIpResult.cc b/beian/src/model/ManageAccessorIpResult.cc new file mode 100644 index 000000000..ede4d1f36 --- /dev/null +++ b/beian/src/model/ManageAccessorIpResult.cc @@ -0,0 +1,58 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Beian; +using namespace AlibabaCloud::Beian::Model; + +ManageAccessorIpResult::ManageAccessorIpResult() : + ServiceResult() +{} + +ManageAccessorIpResult::ManageAccessorIpResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ManageAccessorIpResult::~ManageAccessorIpResult() +{} + +void ManageAccessorIpResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string ManageAccessorIpResult::getMessage()const +{ + return message_; +} + +int ManageAccessorIpResult::getCode()const +{ + return code_; +} + diff --git a/beian/src/model/QueryAccessorDomainListRequest.cc b/beian/src/model/QueryAccessorDomainListRequest.cc new file mode 100644 index 000000000..635ec797c --- /dev/null +++ b/beian/src/model/QueryAccessorDomainListRequest.cc @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Beian::Model::QueryAccessorDomainListRequest; + +QueryAccessorDomainListRequest::QueryAccessorDomainListRequest() + : RpcServiceRequest("beian", "2016-08-10", "QueryAccessorDomainList") { + setMethod(HttpRequest::Method::Post); +} + +QueryAccessorDomainListRequest::~QueryAccessorDomainListRequest() {} + +std::string QueryAccessorDomainListRequest::getCaller() const { + return caller_; +} + +void QueryAccessorDomainListRequest::setCaller(const std::string &caller) { + caller_ = caller; + setParameter(std::string("Caller"), caller); +} + +int QueryAccessorDomainListRequest::getPageNo() const { + return pageNo_; +} + +void QueryAccessorDomainListRequest::setPageNo(int pageNo) { + pageNo_ = pageNo; + setParameter(std::string("PageNo"), std::to_string(pageNo)); +} + +std::string QueryAccessorDomainListRequest::getDomain() const { + return domain_; +} + +void QueryAccessorDomainListRequest::setDomain(const std::string &domain) { + domain_ = domain; + setParameter(std::string("Domain"), domain); +} + +int QueryAccessorDomainListRequest::getPageSize() const { + return pageSize_; +} + +void QueryAccessorDomainListRequest::setPageSize(int pageSize) { + pageSize_ = pageSize; + setParameter(std::string("PageSize"), std::to_string(pageSize)); +} + diff --git a/beian/src/model/QueryAccessorDomainListResult.cc b/beian/src/model/QueryAccessorDomainListResult.cc new file mode 100644 index 000000000..c8e16f0d5 --- /dev/null +++ b/beian/src/model/QueryAccessorDomainListResult.cc @@ -0,0 +1,67 @@ +/* + * 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::Beian; +using namespace AlibabaCloud::Beian::Model; + +QueryAccessorDomainListResult::QueryAccessorDomainListResult() : + ServiceResult() +{} + +QueryAccessorDomainListResult::QueryAccessorDomainListResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +QueryAccessorDomainListResult::~QueryAccessorDomainListResult() +{} + +void QueryAccessorDomainListResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + auto allDomains = dataNode["Domains"]["domains"]; + for (auto value : allDomains) + data_.domains.push_back(value.asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string QueryAccessorDomainListResult::getMessage()const +{ + return message_; +} + +QueryAccessorDomainListResult::Data QueryAccessorDomainListResult::getData()const +{ + return data_; +} + +int QueryAccessorDomainListResult::getCode()const +{ + return code_; +} + diff --git a/beian/src/model/QueryAccessorDomainRequest.cc b/beian/src/model/QueryAccessorDomainRequest.cc new file mode 100644 index 000000000..15d7cf529 --- /dev/null +++ b/beian/src/model/QueryAccessorDomainRequest.cc @@ -0,0 +1,45 @@ +/* + * 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::Beian::Model::QueryAccessorDomainRequest; + +QueryAccessorDomainRequest::QueryAccessorDomainRequest() + : RpcServiceRequest("beian", "2016-08-10", "QueryAccessorDomain") { + setMethod(HttpRequest::Method::Post); +} + +QueryAccessorDomainRequest::~QueryAccessorDomainRequest() {} + +std::string QueryAccessorDomainRequest::getCaller() const { + return caller_; +} + +void QueryAccessorDomainRequest::setCaller(const std::string &caller) { + caller_ = caller; + setParameter(std::string("Caller"), caller); +} + +std::string QueryAccessorDomainRequest::getDomain() const { + return domain_; +} + +void QueryAccessorDomainRequest::setDomain(const std::string &domain) { + domain_ = domain; + setParameter(std::string("Domain"), domain); +} + diff --git a/beian/src/model/QueryAccessorDomainResult.cc b/beian/src/model/QueryAccessorDomainResult.cc new file mode 100644 index 000000000..959d6a3f8 --- /dev/null +++ b/beian/src/model/QueryAccessorDomainResult.cc @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Beian; +using namespace AlibabaCloud::Beian::Model; + +QueryAccessorDomainResult::QueryAccessorDomainResult() : + ServiceResult() +{} + +QueryAccessorDomainResult::QueryAccessorDomainResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +QueryAccessorDomainResult::~QueryAccessorDomainResult() +{} + +void QueryAccessorDomainResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["Data"].isNull()) + data_ = value["Data"].asString() == "true"; + +} + +std::string QueryAccessorDomainResult::getMessage()const +{ + return message_; +} + +bool QueryAccessorDomainResult::getData()const +{ + return data_; +} + +int QueryAccessorDomainResult::getCode()const +{ + return code_; +} + diff --git a/beian/src/model/QueryAccessorDomainStatusRequest.cc b/beian/src/model/QueryAccessorDomainStatusRequest.cc new file mode 100644 index 000000000..8cf1a8d56 --- /dev/null +++ b/beian/src/model/QueryAccessorDomainStatusRequest.cc @@ -0,0 +1,45 @@ +/* + * 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::Beian::Model::QueryAccessorDomainStatusRequest; + +QueryAccessorDomainStatusRequest::QueryAccessorDomainStatusRequest() + : RpcServiceRequest("beian", "2016-08-10", "QueryAccessorDomainStatus") { + setMethod(HttpRequest::Method::Post); +} + +QueryAccessorDomainStatusRequest::~QueryAccessorDomainStatusRequest() {} + +std::string QueryAccessorDomainStatusRequest::getCaller() const { + return caller_; +} + +void QueryAccessorDomainStatusRequest::setCaller(const std::string &caller) { + caller_ = caller; + setParameter(std::string("Caller"), caller); +} + +std::string QueryAccessorDomainStatusRequest::getDomain() const { + return domain_; +} + +void QueryAccessorDomainStatusRequest::setDomain(const std::string &domain) { + domain_ = domain; + setParameter(std::string("Domain"), domain); +} + diff --git a/beian/src/model/QueryAccessorDomainStatusResult.cc b/beian/src/model/QueryAccessorDomainStatusResult.cc new file mode 100644 index 000000000..3392f4fe7 --- /dev/null +++ b/beian/src/model/QueryAccessorDomainStatusResult.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::Beian; +using namespace AlibabaCloud::Beian::Model; + +QueryAccessorDomainStatusResult::QueryAccessorDomainStatusResult() : + ServiceResult() +{} + +QueryAccessorDomainStatusResult::QueryAccessorDomainStatusResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +QueryAccessorDomainStatusResult::~QueryAccessorDomainStatusResult() +{} + +void QueryAccessorDomainStatusResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["Domain"].isNull()) + data_.domain = dataNode["Domain"].asString(); + if(!dataNode["Status"].isNull()) + data_.status = dataNode["Status"].asString(); + if(!dataNode["ReasonCode"].isNull()) + data_.reasonCode = std::stoi(dataNode["ReasonCode"].asString()); + if(!dataNode["Reason"].isNull()) + data_.reason = dataNode["Reason"].asString(); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string QueryAccessorDomainStatusResult::getMessage()const +{ + return message_; +} + +QueryAccessorDomainStatusResult::Data QueryAccessorDomainStatusResult::getData()const +{ + return data_; +} + +int QueryAccessorDomainStatusResult::getCode()const +{ + return code_; +} + diff --git a/beian/src/model/QueryAccessorDomainWhiteListRequest.cc b/beian/src/model/QueryAccessorDomainWhiteListRequest.cc new file mode 100644 index 000000000..ff5005bd2 --- /dev/null +++ b/beian/src/model/QueryAccessorDomainWhiteListRequest.cc @@ -0,0 +1,45 @@ +/* + * 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::Beian::Model::QueryAccessorDomainWhiteListRequest; + +QueryAccessorDomainWhiteListRequest::QueryAccessorDomainWhiteListRequest() + : RpcServiceRequest("beian", "2016-08-10", "QueryAccessorDomainWhiteList") { + setMethod(HttpRequest::Method::Post); +} + +QueryAccessorDomainWhiteListRequest::~QueryAccessorDomainWhiteListRequest() {} + +std::string QueryAccessorDomainWhiteListRequest::getCaller() const { + return caller_; +} + +void QueryAccessorDomainWhiteListRequest::setCaller(const std::string &caller) { + caller_ = caller; + setParameter(std::string("Caller"), caller); +} + +std::string QueryAccessorDomainWhiteListRequest::getDomain() const { + return domain_; +} + +void QueryAccessorDomainWhiteListRequest::setDomain(const std::string &domain) { + domain_ = domain; + setParameter(std::string("Domain"), domain); +} + diff --git a/beian/src/model/QueryAccessorDomainWhiteListResult.cc b/beian/src/model/QueryAccessorDomainWhiteListResult.cc new file mode 100644 index 000000000..8adb349c1 --- /dev/null +++ b/beian/src/model/QueryAccessorDomainWhiteListResult.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 +#include + +using namespace AlibabaCloud::Beian; +using namespace AlibabaCloud::Beian::Model; + +QueryAccessorDomainWhiteListResult::QueryAccessorDomainWhiteListResult() : + ServiceResult() +{} + +QueryAccessorDomainWhiteListResult::QueryAccessorDomainWhiteListResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +QueryAccessorDomainWhiteListResult::~QueryAccessorDomainWhiteListResult() +{} + +void QueryAccessorDomainWhiteListResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["White"].isNull()) + data_.white = dataNode["White"].asString() == "true"; + auto allItemsNode = dataNode["Items"]["itemsItem"]; + for (auto dataNodeItemsitemsItem : allItemsNode) + { + Data::ItemsItem itemsItemObject; + if(!dataNodeItemsitemsItem["Type"].isNull()) + itemsItemObject.type = dataNodeItemsitemsItem["Type"].asString(); + if(!dataNodeItemsitemsItem["CreateTime"].isNull()) + itemsItemObject.createTime = dataNodeItemsitemsItem["CreateTime"].asString(); + if(!dataNodeItemsitemsItem["StartTime"].isNull()) + itemsItemObject.startTime = dataNodeItemsitemsItem["StartTime"].asString(); + if(!dataNodeItemsitemsItem["EndTime"].isNull()) + itemsItemObject.endTime = dataNodeItemsitemsItem["EndTime"].asString(); + if(!dataNodeItemsitemsItem["Valid"].isNull()) + itemsItemObject.valid = dataNodeItemsitemsItem["Valid"].asString() == "true"; + data_.items.push_back(itemsItemObject); + } + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string QueryAccessorDomainWhiteListResult::getMessage()const +{ + return message_; +} + +QueryAccessorDomainWhiteListResult::Data QueryAccessorDomainWhiteListResult::getData()const +{ + return data_; +} + +int QueryAccessorDomainWhiteListResult::getCode()const +{ + return code_; +} + diff --git a/beian/src/model/QueryAccessorDomainsStatusRequest.cc b/beian/src/model/QueryAccessorDomainsStatusRequest.cc new file mode 100644 index 000000000..b67dd01ed --- /dev/null +++ b/beian/src/model/QueryAccessorDomainsStatusRequest.cc @@ -0,0 +1,44 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Beian::Model::QueryAccessorDomainsStatusRequest; + +QueryAccessorDomainsStatusRequest::QueryAccessorDomainsStatusRequest() + : RpcServiceRequest("beian", "2016-08-10", "QueryAccessorDomainsStatus") { + setMethod(HttpRequest::Method::Post); +} + +QueryAccessorDomainsStatusRequest::~QueryAccessorDomainsStatusRequest() {} + +std::vector QueryAccessorDomainsStatusRequest::getDomains() const { + return domains_; +} + +void QueryAccessorDomainsStatusRequest::setDomains(const std::vector &domains) { + domains_ = domains; +} + +std::string QueryAccessorDomainsStatusRequest::getCaller() const { + return caller_; +} + +void QueryAccessorDomainsStatusRequest::setCaller(const std::string &caller) { + caller_ = caller; + setParameter(std::string("Caller"), caller); +} + diff --git a/beian/src/model/QueryAccessorDomainsStatusResult.cc b/beian/src/model/QueryAccessorDomainsStatusResult.cc new file mode 100644 index 000000000..5b75ec09a --- /dev/null +++ b/beian/src/model/QueryAccessorDomainsStatusResult.cc @@ -0,0 +1,77 @@ +/* + * 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::Beian; +using namespace AlibabaCloud::Beian::Model; + +QueryAccessorDomainsStatusResult::QueryAccessorDomainsStatusResult() : + ServiceResult() +{} + +QueryAccessorDomainsStatusResult::QueryAccessorDomainsStatusResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +QueryAccessorDomainsStatusResult::~QueryAccessorDomainsStatusResult() +{} + +void QueryAccessorDomainsStatusResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allDataNode = value["Data"]["DataItem"]; + for (auto valueDataDataItem : allDataNode) + { + DataItem dataObject; + if(!valueDataDataItem["Domain"].isNull()) + dataObject.domain = valueDataDataItem["Domain"].asString(); + if(!valueDataDataItem["Status"].isNull()) + dataObject.status = valueDataDataItem["Status"].asString(); + if(!valueDataDataItem["ReasonCode"].isNull()) + dataObject.reasonCode = std::stoi(valueDataDataItem["ReasonCode"].asString()); + if(!valueDataDataItem["Reason"].isNull()) + dataObject.reason = valueDataDataItem["Reason"].asString(); + data_.push_back(dataObject); + } + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string QueryAccessorDomainsStatusResult::getMessage()const +{ + return message_; +} + +std::vector QueryAccessorDomainsStatusResult::getData()const +{ + return data_; +} + +int QueryAccessorDomainsStatusResult::getCode()const +{ + return code_; +} + diff --git a/beian/src/model/QueryAccessorIpRequest.cc b/beian/src/model/QueryAccessorIpRequest.cc new file mode 100644 index 000000000..815470f71 --- /dev/null +++ b/beian/src/model/QueryAccessorIpRequest.cc @@ -0,0 +1,45 @@ +/* + * 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::Beian::Model::QueryAccessorIpRequest; + +QueryAccessorIpRequest::QueryAccessorIpRequest() + : RpcServiceRequest("beian", "2016-08-10", "QueryAccessorIp") { + setMethod(HttpRequest::Method::Post); +} + +QueryAccessorIpRequest::~QueryAccessorIpRequest() {} + +std::string QueryAccessorIpRequest::getIp() const { + return ip_; +} + +void QueryAccessorIpRequest::setIp(const std::string &ip) { + ip_ = ip; + setParameter(std::string("Ip"), ip); +} + +std::string QueryAccessorIpRequest::getCaller() const { + return caller_; +} + +void QueryAccessorIpRequest::setCaller(const std::string &caller) { + caller_ = caller; + setParameter(std::string("Caller"), caller); +} + diff --git a/beian/src/model/QueryAccessorIpResult.cc b/beian/src/model/QueryAccessorIpResult.cc new file mode 100644 index 000000000..cd1cb9e57 --- /dev/null +++ b/beian/src/model/QueryAccessorIpResult.cc @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Beian; +using namespace AlibabaCloud::Beian::Model; + +QueryAccessorIpResult::QueryAccessorIpResult() : + ServiceResult() +{} + +QueryAccessorIpResult::QueryAccessorIpResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +QueryAccessorIpResult::~QueryAccessorIpResult() +{} + +void QueryAccessorIpResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = value["Code"].asString(); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["Data"].isNull()) + data_ = value["Data"].asString() == "true"; + +} + +std::string QueryAccessorIpResult::getMessage()const +{ + return message_; +} + +bool QueryAccessorIpResult::getData()const +{ + return data_; +} + +std::string QueryAccessorIpResult::getCode()const +{ + return code_; +} + diff --git a/beian/src/model/SubmitAccessorFullDomainsOssListRequest.cc b/beian/src/model/SubmitAccessorFullDomainsOssListRequest.cc new file mode 100644 index 000000000..05bf242c5 --- /dev/null +++ b/beian/src/model/SubmitAccessorFullDomainsOssListRequest.cc @@ -0,0 +1,44 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Beian::Model::SubmitAccessorFullDomainsOssListRequest; + +SubmitAccessorFullDomainsOssListRequest::SubmitAccessorFullDomainsOssListRequest() + : RpcServiceRequest("beian", "2016-08-10", "SubmitAccessorFullDomainsOssList") { + setMethod(HttpRequest::Method::Post); +} + +SubmitAccessorFullDomainsOssListRequest::~SubmitAccessorFullDomainsOssListRequest() {} + +std::string SubmitAccessorFullDomainsOssListRequest::getCaller() const { + return caller_; +} + +void SubmitAccessorFullDomainsOssListRequest::setCaller(const std::string &caller) { + caller_ = caller; + setParameter(std::string("Caller"), caller); +} + +std::vector SubmitAccessorFullDomainsOssListRequest::getOssList() const { + return ossList_; +} + +void SubmitAccessorFullDomainsOssListRequest::setOssList(const std::vector &ossList) { + ossList_ = ossList; +} + diff --git a/beian/src/model/SubmitAccessorFullDomainsOssListResult.cc b/beian/src/model/SubmitAccessorFullDomainsOssListResult.cc new file mode 100644 index 000000000..fc26f57e0 --- /dev/null +++ b/beian/src/model/SubmitAccessorFullDomainsOssListResult.cc @@ -0,0 +1,58 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Beian; +using namespace AlibabaCloud::Beian::Model; + +SubmitAccessorFullDomainsOssListResult::SubmitAccessorFullDomainsOssListResult() : + ServiceResult() +{} + +SubmitAccessorFullDomainsOssListResult::SubmitAccessorFullDomainsOssListResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SubmitAccessorFullDomainsOssListResult::~SubmitAccessorFullDomainsOssListResult() +{} + +void SubmitAccessorFullDomainsOssListResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string SubmitAccessorFullDomainsOssListResult::getMessage()const +{ + return message_; +} + +int SubmitAccessorFullDomainsOssListResult::getCode()const +{ + return code_; +} +