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

Domain Self Diagnosis.

Browse Source
This commit is contained in:
sdk-team
2024-06-11 03:19:07 +00:00
parent d80ca0d7e2
commit db6a17b08c
61 changed files with 4136 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1927
1.36.1928

138
beian/CMakeLists.txt Normal file
View File

@@ -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}
)

158
beian/include/alibabacloud/beian/BeianClient.h Normal file
View File

@@ -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 <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#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<Error, Model::DeleteUnbeianIpCheckTypeResult> DeleteUnbeianIpCheckTypeOutcome;
typedef std::future<DeleteUnbeianIpCheckTypeOutcome> DeleteUnbeianIpCheckTypeOutcomeCallable;
typedef std::function<void(const BeianClient*, const Model::DeleteUnbeianIpCheckTypeRequest&, const DeleteUnbeianIpCheckTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteUnbeianIpCheckTypeAsyncHandler;
typedef Outcome<Error, Model::GetMainDomainResult> GetMainDomainOutcome;
typedef std::future<GetMainDomainOutcome> GetMainDomainOutcomeCallable;
typedef std::function<void(const BeianClient*, const Model::GetMainDomainRequest&, const GetMainDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMainDomainAsyncHandler;
typedef Outcome<Error, Model::InsertUnbeianIpCheckTypeResult> InsertUnbeianIpCheckTypeOutcome;
typedef std::future<InsertUnbeianIpCheckTypeOutcome> InsertUnbeianIpCheckTypeOutcomeCallable;
typedef std::function<void(const BeianClient*, const Model::InsertUnbeianIpCheckTypeRequest&, const InsertUnbeianIpCheckTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InsertUnbeianIpCheckTypeAsyncHandler;
typedef Outcome<Error, Model::ListUnbeianIpCheckTypeResult> ListUnbeianIpCheckTypeOutcome;
typedef std::future<ListUnbeianIpCheckTypeOutcome> ListUnbeianIpCheckTypeOutcomeCallable;
typedef std::function<void(const BeianClient*, const Model::ListUnbeianIpCheckTypeRequest&, const ListUnbeianIpCheckTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUnbeianIpCheckTypeAsyncHandler;
typedef Outcome<Error, Model::ManageAccessorDomainResult> ManageAccessorDomainOutcome;
typedef std::future<ManageAccessorDomainOutcome> ManageAccessorDomainOutcomeCallable;
typedef std::function<void(const BeianClient*, const Model::ManageAccessorDomainRequest&, const ManageAccessorDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ManageAccessorDomainAsyncHandler;
typedef Outcome<Error, Model::ManageAccessorDomainWhiteListResult> ManageAccessorDomainWhiteListOutcome;
typedef std::future<ManageAccessorDomainWhiteListOutcome> ManageAccessorDomainWhiteListOutcomeCallable;
typedef std::function<void(const BeianClient*, const Model::ManageAccessorDomainWhiteListRequest&, const ManageAccessorDomainWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ManageAccessorDomainWhiteListAsyncHandler;
typedef Outcome<Error, Model::ManageAccessorIpResult> ManageAccessorIpOutcome;
typedef std::future<ManageAccessorIpOutcome> ManageAccessorIpOutcomeCallable;
typedef std::function<void(const BeianClient*, const Model::ManageAccessorIpRequest&, const ManageAccessorIpOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ManageAccessorIpAsyncHandler;
typedef Outcome<Error, Model::QueryAccessorDomainResult> QueryAccessorDomainOutcome;
typedef std::future<QueryAccessorDomainOutcome> QueryAccessorDomainOutcomeCallable;
typedef std::function<void(const BeianClient*, const Model::QueryAccessorDomainRequest&, const QueryAccessorDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryAccessorDomainAsyncHandler;
typedef Outcome<Error, Model::QueryAccessorDomainListResult> QueryAccessorDomainListOutcome;
typedef std::future<QueryAccessorDomainListOutcome> QueryAccessorDomainListOutcomeCallable;
typedef std::function<void(const BeianClient*, const Model::QueryAccessorDomainListRequest&, const QueryAccessorDomainListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryAccessorDomainListAsyncHandler;
typedef Outcome<Error, Model::QueryAccessorDomainStatusResult> QueryAccessorDomainStatusOutcome;
typedef std::future<QueryAccessorDomainStatusOutcome> QueryAccessorDomainStatusOutcomeCallable;
typedef std::function<void(const BeianClient*, const Model::QueryAccessorDomainStatusRequest&, const QueryAccessorDomainStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryAccessorDomainStatusAsyncHandler;
typedef Outcome<Error, Model::QueryAccessorDomainWhiteListResult> QueryAccessorDomainWhiteListOutcome;
typedef std::future<QueryAccessorDomainWhiteListOutcome> QueryAccessorDomainWhiteListOutcomeCallable;
typedef std::function<void(const BeianClient*, const Model::QueryAccessorDomainWhiteListRequest&, const QueryAccessorDomainWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryAccessorDomainWhiteListAsyncHandler;
typedef Outcome<Error, Model::QueryAccessorDomainsStatusResult> QueryAccessorDomainsStatusOutcome;
typedef std::future<QueryAccessorDomainsStatusOutcome> QueryAccessorDomainsStatusOutcomeCallable;
typedef std::function<void(const BeianClient*, const Model::QueryAccessorDomainsStatusRequest&, const QueryAccessorDomainsStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryAccessorDomainsStatusAsyncHandler;
typedef Outcome<Error, Model::QueryAccessorIpResult> QueryAccessorIpOutcome;
typedef std::future<QueryAccessorIpOutcome> QueryAccessorIpOutcomeCallable;
typedef std::function<void(const BeianClient*, const Model::QueryAccessorIpRequest&, const QueryAccessorIpOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryAccessorIpAsyncHandler;
typedef Outcome<Error, Model::SubmitAccessorFullDomainsOssListResult> SubmitAccessorFullDomainsOssListOutcome;
typedef std::future<SubmitAccessorFullDomainsOssListOutcome> SubmitAccessorFullDomainsOssListOutcomeCallable;
typedef std::function<void(const BeianClient*, const Model::SubmitAccessorFullDomainsOssListRequest&, const SubmitAccessorFullDomainsOssListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SubmitAccessorFullDomainsOssListAsyncHandler;
BeianClient(const Credentials &credentials, const ClientConfiguration &configuration);
BeianClient(const std::shared_ptr<CredentialsProvider> &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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& context = nullptr) const;
SubmitAccessorFullDomainsOssListOutcomeCallable submitAccessorFullDomainsOssListCallable(const Model::SubmitAccessorFullDomainsOssListRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_BEIAN_BEIANCLIENT_H_

32
beian/include/alibabacloud/beian/BeianExport.h Normal file
View File

@@ -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 <alibabacloud/core/Global.h>
#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_

51
beian/include/alibabacloud/beian/model/DeleteUnbeianIpCheckTypeRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_DELETEUNBEIANIPCHECKTYPEREQUEST_H_
#define ALIBABACLOUD_BEIAN_MODEL_DELETEUNBEIANIPCHECKTYPEREQUEST_H_
#include <alibabacloud/beian/BeianExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

62
beian/include/alibabacloud/beian/model/DeleteUnbeianIpCheckTypeResult.h Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_DELETEUNBEIANIPCHECKTYPERESULT_H_
#define ALIBABACLOUD_BEIAN_MODEL_DELETEUNBEIANIPCHECKTYPERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/beian/BeianExport.h>
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_

42
beian/include/alibabacloud/beian/model/GetMainDomainRequest.h Normal file
View File

@@ -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 <alibabacloud/beian/BeianExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

55
beian/include/alibabacloud/beian/model/GetMainDomainResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_GETMAINDOMAINRESULT_H_
#define ALIBABACLOUD_BEIAN_MODEL_GETMAINDOMAINRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/beian/BeianExport.h>
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_

51
beian/include/alibabacloud/beian/model/InsertUnbeianIpCheckTypeRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_INSERTUNBEIANIPCHECKTYPEREQUEST_H_
#define ALIBABACLOUD_BEIAN_MODEL_INSERTUNBEIANIPCHECKTYPEREQUEST_H_
#include <alibabacloud/beian/BeianExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

62
beian/include/alibabacloud/beian/model/InsertUnbeianIpCheckTypeResult.h Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_INSERTUNBEIANIPCHECKTYPERESULT_H_
#define ALIBABACLOUD_BEIAN_MODEL_INSERTUNBEIANIPCHECKTYPERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/beian/BeianExport.h>
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_

57
beian/include/alibabacloud/beian/model/ListUnbeianIpCheckTypeRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_LISTUNBEIANIPCHECKTYPEREQUEST_H_
#define ALIBABACLOUD_BEIAN_MODEL_LISTUNBEIANIPCHECKTYPEREQUEST_H_
#include <alibabacloud/beian/BeianExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

71
beian/include/alibabacloud/beian/model/ListUnbeianIpCheckTypeResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/beian/BeianExport.h>
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<ListItem> 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_

48
beian/include/alibabacloud/beian/model/ManageAccessorDomainRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINREQUEST_H_
#define ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINREQUEST_H_
#include <alibabacloud/beian/BeianExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

53
beian/include/alibabacloud/beian/model/ManageAccessorDomainResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINRESULT_H_
#define ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/beian/BeianExport.h>
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_

57
beian/include/alibabacloud/beian/model/ManageAccessorDomainWhiteListRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINWHITELISTREQUEST_H_
#define ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINWHITELISTREQUEST_H_
#include <alibabacloud/beian/BeianExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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<std::string> getDomains() const;
void setDomains(const std::vector<std::string> &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<std::string> 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_

53
beian/include/alibabacloud/beian/model/ManageAccessorDomainWhiteListResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINWHITELISTRESULT_H_
#define ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORDOMAINWHITELISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/beian/BeianExport.h>
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_

54
beian/include/alibabacloud/beian/model/ManageAccessorIpRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORIPREQUEST_H_
#define ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORIPREQUEST_H_
#include <alibabacloud/beian/BeianExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

53
beian/include/alibabacloud/beian/model/ManageAccessorIpResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORIPRESULT_H_
#define ALIBABACLOUD_BEIAN_MODEL_MANAGEACCESSORIPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/beian/BeianExport.h>
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_

51
beian/include/alibabacloud/beian/model/QueryAccessorDomainListRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINLISTREQUEST_H_
#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINLISTREQUEST_H_
#include <alibabacloud/beian/BeianExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

59
beian/include/alibabacloud/beian/model/QueryAccessorDomainListResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINLISTRESULT_H_
#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINLISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/beian/BeianExport.h>
namespace AlibabaCloud
{
namespace Beian
{
namespace Model
{
class ALIBABACLOUD_BEIAN_EXPORT QueryAccessorDomainListResult : public ServiceResult
{
public:
struct Data
{
std::vector<std::string> 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_

45
beian/include/alibabacloud/beian/model/QueryAccessorDomainRequest.h Normal file
View File

@@ -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 <alibabacloud/beian/BeianExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

55
beian/include/alibabacloud/beian/model/QueryAccessorDomainResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINRESULT_H_
#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/beian/BeianExport.h>
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_

45
beian/include/alibabacloud/beian/model/QueryAccessorDomainStatusRequest.h Normal file
View File

@@ -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 <alibabacloud/beian/BeianExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

62
beian/include/alibabacloud/beian/model/QueryAccessorDomainStatusResult.h Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSTATUSRESULT_H_
#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSTATUSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/beian/BeianExport.h>
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_

45
beian/include/alibabacloud/beian/model/QueryAccessorDomainWhiteListRequest.h Normal file
View File

@@ -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 <alibabacloud/beian/BeianExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

68
beian/include/alibabacloud/beian/model/QueryAccessorDomainWhiteListResult.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINWHITELISTRESULT_H_
#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINWHITELISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/beian/BeianExport.h>
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<ItemsItem> 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_

45
beian/include/alibabacloud/beian/model/QueryAccessorDomainsStatusRequest.h Normal file
View File

@@ -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 <alibabacloud/beian/BeianExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Beian {
namespace Model {
class ALIBABACLOUD_BEIAN_EXPORT QueryAccessorDomainsStatusRequest : public RpcServiceRequest {
public:
QueryAccessorDomainsStatusRequest();
~QueryAccessorDomainsStatusRequest();
std::vector<std::string> getDomains() const;
void setDomains(const std::vector<std::string> &domains);
std::string getCaller() const;
void setCaller(const std::string &caller);
private:
std::vector<std::string> domains_;
std::string caller_;
};
} // namespace Model
} // namespace Beian
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSSTATUSREQUEST_H_

62
beian/include/alibabacloud/beian/model/QueryAccessorDomainsStatusResult.h Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSSTATUSRESULT_H_
#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSSTATUSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/beian/BeianExport.h>
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<DataItem> getData()const;
int getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::vector<DataItem> data_;
int code_;
};
}
}
}
#endif // !ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORDOMAINSSTATUSRESULT_H_

45
beian/include/alibabacloud/beian/model/QueryAccessorIpRequest.h Normal file
View File

@@ -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 <alibabacloud/beian/BeianExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

55
beian/include/alibabacloud/beian/model/QueryAccessorIpResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORIPRESULT_H_
#define ALIBABACLOUD_BEIAN_MODEL_QUERYACCESSORIPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/beian/BeianExport.h>
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_

45
beian/include/alibabacloud/beian/model/SubmitAccessorFullDomainsOssListRequest.h Normal file
View File

@@ -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 <alibabacloud/beian/BeianExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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<std::string> getOssList() const;
void setOssList(const std::vector<std::string> &ossList);
private:
std::string caller_;
std::vector<std::string> ossList_;
};
} // namespace Model
} // namespace Beian
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_BEIAN_MODEL_SUBMITACCESSORFULLDOMAINSOSSLISTREQUEST_H_

53
beian/include/alibabacloud/beian/model/SubmitAccessorFullDomainsOssListResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_BEIAN_MODEL_SUBMITACCESSORFULLDOMAINSOSSLISTRESULT_H_
#define ALIBABACLOUD_BEIAN_MODEL_SUBMITACCESSORFULLDOMAINSOSSLISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/beian/BeianExport.h>
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_

557
beian/src/BeianClient.cc Normal file
View File

@@ -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 <alibabacloud/beian/BeianClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
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<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
BeianClient::BeianClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
BeianClient::BeianClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
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<const AsyncCallerContext>& 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<std::packaged_task<DeleteUnbeianIpCheckTypeOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<GetMainDomainOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<InsertUnbeianIpCheckTypeOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<ListUnbeianIpCheckTypeOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<ManageAccessorDomainOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<ManageAccessorDomainWhiteListOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<ManageAccessorIpOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<QueryAccessorDomainOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<QueryAccessorDomainListOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<QueryAccessorDomainStatusOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<QueryAccessorDomainWhiteListOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<QueryAccessorDomainsStatusOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<QueryAccessorIpOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<SubmitAccessorFullDomainsOssListOutcome()>>(
[this, request]()
{
return this->submitAccessorFullDomainsOssList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

63
beian/src/model/DeleteUnbeianIpCheckTypeRequest.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/DeleteUnbeianIpCheckTypeRequest.h>
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);
}

75
beian/src/model/DeleteUnbeianIpCheckTypeResult.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/DeleteUnbeianIpCheckTypeResult.h>
#include <json/json.h>
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_;
}

36
beian/src/model/GetMainDomainRequest.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/GetMainDomainRequest.h>
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);
}

65
beian/src/model/GetMainDomainResult.cc Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/beian/model/GetMainDomainResult.h>
#include <json/json.h>
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_;
}

63
beian/src/model/InsertUnbeianIpCheckTypeRequest.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/InsertUnbeianIpCheckTypeRequest.h>
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);
}

75
beian/src/model/InsertUnbeianIpCheckTypeResult.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/InsertUnbeianIpCheckTypeResult.h>
#include <json/json.h>
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_;
}

81
beian/src/model/ListUnbeianIpCheckTypeRequest.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/ListUnbeianIpCheckTypeRequest.h>
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));
}

91
beian/src/model/ListUnbeianIpCheckTypeResult.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/ListUnbeianIpCheckTypeResult.h>
#include <json/json.h>
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_;
}

54
beian/src/model/ManageAccessorDomainRequest.cc Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/beian/model/ManageAccessorDomainRequest.h>
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);
}

58
beian/src/model/ManageAccessorDomainResult.cc Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/beian/model/ManageAccessorDomainResult.h>
#include <json/json.h>
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_;
}

80
beian/src/model/ManageAccessorDomainWhiteListRequest.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/ManageAccessorDomainWhiteListRequest.h>
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<std::string> ManageAccessorDomainWhiteListRequest::getDomains() const {
return domains_;
}
void ManageAccessorDomainWhiteListRequest::setDomains(const std::vector<std::string> &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);
}

58
beian/src/model/ManageAccessorDomainWhiteListResult.cc Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/beian/model/ManageAccessorDomainWhiteListResult.h>
#include <json/json.h>
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_;
}

72
beian/src/model/ManageAccessorIpRequest.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/beian/model/ManageAccessorIpRequest.h>
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);
}

58
beian/src/model/ManageAccessorIpResult.cc Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/beian/model/ManageAccessorIpResult.h>
#include <json/json.h>
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_;
}

63
beian/src/model/QueryAccessorDomainListRequest.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/QueryAccessorDomainListRequest.h>
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));
}

67
beian/src/model/QueryAccessorDomainListResult.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/QueryAccessorDomainListResult.h>
#include <json/json.h>
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_;
}

45
beian/src/model/QueryAccessorDomainRequest.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/QueryAccessorDomainRequest.h>
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);
}

65
beian/src/model/QueryAccessorDomainResult.cc Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/beian/model/QueryAccessorDomainResult.h>
#include <json/json.h>
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_;
}

45
beian/src/model/QueryAccessorDomainStatusRequest.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/QueryAccessorDomainStatusRequest.h>
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);
}

72
beian/src/model/QueryAccessorDomainStatusResult.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/beian/model/QueryAccessorDomainStatusResult.h>
#include <json/json.h>
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_;
}

45
beian/src/model/QueryAccessorDomainWhiteListRequest.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/QueryAccessorDomainWhiteListRequest.h>
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);
}

82
beian/src/model/QueryAccessorDomainWhiteListResult.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/QueryAccessorDomainWhiteListResult.h>
#include <json/json.h>
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_;
}

44
beian/src/model/QueryAccessorDomainsStatusRequest.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/beian/model/QueryAccessorDomainsStatusRequest.h>
using AlibabaCloud::Beian::Model::QueryAccessorDomainsStatusRequest;
QueryAccessorDomainsStatusRequest::QueryAccessorDomainsStatusRequest()
: RpcServiceRequest("beian", "2016-08-10", "QueryAccessorDomainsStatus") {
setMethod(HttpRequest::Method::Post);
}
QueryAccessorDomainsStatusRequest::~QueryAccessorDomainsStatusRequest() {}
std::vector<std::string> QueryAccessorDomainsStatusRequest::getDomains() const {
return domains_;
}
void QueryAccessorDomainsStatusRequest::setDomains(const std::vector<std::string> &domains) {
domains_ = domains;
}
std::string QueryAccessorDomainsStatusRequest::getCaller() const {
return caller_;
}
void QueryAccessorDomainsStatusRequest::setCaller(const std::string &caller) {
caller_ = caller;
setParameter(std::string("Caller"), caller);
}

77
beian/src/model/QueryAccessorDomainsStatusResult.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/QueryAccessorDomainsStatusResult.h>
#include <json/json.h>
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::DataItem> QueryAccessorDomainsStatusResult::getData()const
{
return data_;
}
int QueryAccessorDomainsStatusResult::getCode()const
{
return code_;
}

45
beian/src/model/QueryAccessorIpRequest.cc Normal file
View File

@@ -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 <alibabacloud/beian/model/QueryAccessorIpRequest.h>
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);
}

65
beian/src/model/QueryAccessorIpResult.cc Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/beian/model/QueryAccessorIpResult.h>
#include <json/json.h>
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_;
}

44
beian/src/model/SubmitAccessorFullDomainsOssListRequest.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/beian/model/SubmitAccessorFullDomainsOssListRequest.h>
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<std::string> SubmitAccessorFullDomainsOssListRequest::getOssList() const {
return ossList_;
}
void SubmitAccessorFullDomainsOssListRequest::setOssList(const std::vector<std::string> &ossList) {
ossList_ = ossList;
}

58
beian/src/model/SubmitAccessorFullDomainsOssListResult.cc Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/beian/model/SubmitAccessorFullDomainsOssListResult.h>
#include <json/json.h>
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_;
}