Generated 2015-11-01 for Market.

This commit is contained in:
sdk-team
2019-09-05 14:00:42 +08:00
parent 8b48258e4e
commit 1b553992aa
94 changed files with 7469 additions and 1 deletions

View File

@@ -1,3 +1,6 @@
2019-09-05 Version 1.36.108
- Generated 2015-11-01 for `Market`.
2019-09-05 Version 1.36.107
- Generated 2016-07-14 for `CloudAPI`.

View File

@@ -1 +1 @@
1.36.107
1.36.108

170
market/CMakeLists.txt Normal file
View File

@@ -0,0 +1,170 @@
#
# Copyright 2009-2017 Alibaba Cloud All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT 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(market_public_header
include/alibabacloud/market/MarketClient.h
include/alibabacloud/market/MarketExport.h )
set(market_public_header_model
include/alibabacloud/market/model/NotifyContractEventRequest.h
include/alibabacloud/market/model/NotifyContractEventResult.h
include/alibabacloud/market/model/PushMeteringDataRequest.h
include/alibabacloud/market/model/PushMeteringDataResult.h
include/alibabacloud/market/model/DescribeOrderRequest.h
include/alibabacloud/market/model/DescribeOrderResult.h
include/alibabacloud/market/model/BindImagePackageRequest.h
include/alibabacloud/market/model/BindImagePackageResult.h
include/alibabacloud/market/model/QueryMarketImagesRequest.h
include/alibabacloud/market/model/QueryMarketImagesResult.h
include/alibabacloud/market/model/DescribeProductsRequest.h
include/alibabacloud/market/model/DescribeProductsResult.h
include/alibabacloud/market/model/CreateOrderRequest.h
include/alibabacloud/market/model/CreateOrderResult.h
include/alibabacloud/market/model/DescribePriceRequest.h
include/alibabacloud/market/model/DescribePriceResult.h
include/alibabacloud/market/model/DescribeRateRequest.h
include/alibabacloud/market/model/DescribeRateResult.h
include/alibabacloud/market/model/QueryMarketCategoriesRequest.h
include/alibabacloud/market/model/QueryMarketCategoriesResult.h
include/alibabacloud/market/model/CreateRateRequest.h
include/alibabacloud/market/model/CreateRateResult.h
include/alibabacloud/market/model/DescribeInstanceRequest.h
include/alibabacloud/market/model/DescribeInstanceResult.h
include/alibabacloud/market/model/DescribeLicenseRequest.h
include/alibabacloud/market/model/DescribeLicenseResult.h
include/alibabacloud/market/model/DescribeInstancesRequest.h
include/alibabacloud/market/model/DescribeInstancesResult.h
include/alibabacloud/market/model/ActivateLicenseRequest.h
include/alibabacloud/market/model/ActivateLicenseResult.h
include/alibabacloud/market/model/DescribeCommodityRequest.h
include/alibabacloud/market/model/DescribeCommodityResult.h
include/alibabacloud/market/model/DescribeProductRequest.h
include/alibabacloud/market/model/DescribeProductResult.h
include/alibabacloud/market/model/CreateCommodityRequest.h
include/alibabacloud/market/model/CreateCommodityResult.h
include/alibabacloud/market/model/DeleteCommodityRequest.h
include/alibabacloud/market/model/DeleteCommodityResult.h
include/alibabacloud/market/model/UpdateCommodityRequest.h
include/alibabacloud/market/model/UpdateCommodityResult.h
include/alibabacloud/market/model/DescribeCommoditiesRequest.h
include/alibabacloud/market/model/DescribeCommoditiesResult.h
include/alibabacloud/market/model/UploadCommodityFileRequest.h
include/alibabacloud/market/model/UploadCommodityFileResult.h )
set(market_src
src/com.aliyun.pop.sdk.domain.Product@6f1c29b7Client.cc
src/model/NotifyContractEventRequest.cc
src/model/NotifyContractEventResult.cc
src/model/PushMeteringDataRequest.cc
src/model/PushMeteringDataResult.cc
src/model/DescribeOrderRequest.cc
src/model/DescribeOrderResult.cc
src/model/BindImagePackageRequest.cc
src/model/BindImagePackageResult.cc
src/model/QueryMarketImagesRequest.cc
src/model/QueryMarketImagesResult.cc
src/model/DescribeProductsRequest.cc
src/model/DescribeProductsResult.cc
src/model/CreateOrderRequest.cc
src/model/CreateOrderResult.cc
src/model/DescribePriceRequest.cc
src/model/DescribePriceResult.cc
src/model/DescribeRateRequest.cc
src/model/DescribeRateResult.cc
src/model/QueryMarketCategoriesRequest.cc
src/model/QueryMarketCategoriesResult.cc
src/model/CreateRateRequest.cc
src/model/CreateRateResult.cc
src/model/DescribeInstanceRequest.cc
src/model/DescribeInstanceResult.cc
src/model/DescribeLicenseRequest.cc
src/model/DescribeLicenseResult.cc
src/model/DescribeInstancesRequest.cc
src/model/DescribeInstancesResult.cc
src/model/ActivateLicenseRequest.cc
src/model/ActivateLicenseResult.cc
src/model/DescribeCommodityRequest.cc
src/model/DescribeCommodityResult.cc
src/model/DescribeProductRequest.cc
src/model/DescribeProductResult.cc
src/model/CreateCommodityRequest.cc
src/model/CreateCommodityResult.cc
src/model/DeleteCommodityRequest.cc
src/model/DeleteCommodityResult.cc
src/model/UpdateCommodityRequest.cc
src/model/UpdateCommodityResult.cc
src/model/DescribeCommoditiesRequest.cc
src/model/DescribeCommoditiesResult.cc
src/model/UploadCommodityFileRequest.cc
src/model/UploadCommodityFileResult.cc )
add_library(market ${LIB_TYPE}
${market_public_header}
${market_public_header_model}
${market_src})
set_target_properties(market
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}market
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(market
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_MARKET_LIBRARY)
endif()
target_include_directories(market
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(market
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(market
jsoncpp)
target_include_directories(market
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(market
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(market
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(market
PRIVATE /usr/include/jsoncpp)
target_link_libraries(market
jsoncpp)
endif()
install(FILES ${market_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/market)
install(FILES ${market_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/market/model)
install(TARGETS market
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

View File

@@ -0,0 +1,222 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_MARKET_MARKETCLIENT_H_
#define ALIBABACLOUD_MARKET_MARKETCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "MarketExport.h"
#include "model/NotifyContractEventRequest.h"
#include "model/NotifyContractEventResult.h"
#include "model/PushMeteringDataRequest.h"
#include "model/PushMeteringDataResult.h"
#include "model/DescribeOrderRequest.h"
#include "model/DescribeOrderResult.h"
#include "model/BindImagePackageRequest.h"
#include "model/BindImagePackageResult.h"
#include "model/QueryMarketImagesRequest.h"
#include "model/QueryMarketImagesResult.h"
#include "model/DescribeProductsRequest.h"
#include "model/DescribeProductsResult.h"
#include "model/CreateOrderRequest.h"
#include "model/CreateOrderResult.h"
#include "model/DescribePriceRequest.h"
#include "model/DescribePriceResult.h"
#include "model/DescribeRateRequest.h"
#include "model/DescribeRateResult.h"
#include "model/QueryMarketCategoriesRequest.h"
#include "model/QueryMarketCategoriesResult.h"
#include "model/CreateRateRequest.h"
#include "model/CreateRateResult.h"
#include "model/DescribeInstanceRequest.h"
#include "model/DescribeInstanceResult.h"
#include "model/DescribeLicenseRequest.h"
#include "model/DescribeLicenseResult.h"
#include "model/DescribeInstancesRequest.h"
#include "model/DescribeInstancesResult.h"
#include "model/ActivateLicenseRequest.h"
#include "model/ActivateLicenseResult.h"
#include "model/DescribeCommodityRequest.h"
#include "model/DescribeCommodityResult.h"
#include "model/DescribeProductRequest.h"
#include "model/DescribeProductResult.h"
#include "model/CreateCommodityRequest.h"
#include "model/CreateCommodityResult.h"
#include "model/DeleteCommodityRequest.h"
#include "model/DeleteCommodityResult.h"
#include "model/UpdateCommodityRequest.h"
#include "model/UpdateCommodityResult.h"
#include "model/DescribeCommoditiesRequest.h"
#include "model/DescribeCommoditiesResult.h"
#include "model/UploadCommodityFileRequest.h"
#include "model/UploadCommodityFileResult.h"
namespace AlibabaCloud
{
namespace Market
{
class ALIBABACLOUD_MARKET_EXPORT MarketClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::NotifyContractEventResult> NotifyContractEventOutcome;
typedef std::future<NotifyContractEventOutcome> NotifyContractEventOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::NotifyContractEventRequest&, const NotifyContractEventOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> NotifyContractEventAsyncHandler;
typedef Outcome<Error, Model::PushMeteringDataResult> PushMeteringDataOutcome;
typedef std::future<PushMeteringDataOutcome> PushMeteringDataOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::PushMeteringDataRequest&, const PushMeteringDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PushMeteringDataAsyncHandler;
typedef Outcome<Error, Model::DescribeOrderResult> DescribeOrderOutcome;
typedef std::future<DescribeOrderOutcome> DescribeOrderOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::DescribeOrderRequest&, const DescribeOrderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeOrderAsyncHandler;
typedef Outcome<Error, Model::BindImagePackageResult> BindImagePackageOutcome;
typedef std::future<BindImagePackageOutcome> BindImagePackageOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::BindImagePackageRequest&, const BindImagePackageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BindImagePackageAsyncHandler;
typedef Outcome<Error, Model::QueryMarketImagesResult> QueryMarketImagesOutcome;
typedef std::future<QueryMarketImagesOutcome> QueryMarketImagesOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::QueryMarketImagesRequest&, const QueryMarketImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryMarketImagesAsyncHandler;
typedef Outcome<Error, Model::DescribeProductsResult> DescribeProductsOutcome;
typedef std::future<DescribeProductsOutcome> DescribeProductsOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::DescribeProductsRequest&, const DescribeProductsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeProductsAsyncHandler;
typedef Outcome<Error, Model::CreateOrderResult> CreateOrderOutcome;
typedef std::future<CreateOrderOutcome> CreateOrderOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::CreateOrderRequest&, const CreateOrderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateOrderAsyncHandler;
typedef Outcome<Error, Model::DescribePriceResult> DescribePriceOutcome;
typedef std::future<DescribePriceOutcome> DescribePriceOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::DescribePriceRequest&, const DescribePriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePriceAsyncHandler;
typedef Outcome<Error, Model::DescribeRateResult> DescribeRateOutcome;
typedef std::future<DescribeRateOutcome> DescribeRateOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::DescribeRateRequest&, const DescribeRateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRateAsyncHandler;
typedef Outcome<Error, Model::QueryMarketCategoriesResult> QueryMarketCategoriesOutcome;
typedef std::future<QueryMarketCategoriesOutcome> QueryMarketCategoriesOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::QueryMarketCategoriesRequest&, const QueryMarketCategoriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryMarketCategoriesAsyncHandler;
typedef Outcome<Error, Model::CreateRateResult> CreateRateOutcome;
typedef std::future<CreateRateOutcome> CreateRateOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::CreateRateRequest&, const CreateRateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRateAsyncHandler;
typedef Outcome<Error, Model::DescribeInstanceResult> DescribeInstanceOutcome;
typedef std::future<DescribeInstanceOutcome> DescribeInstanceOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::DescribeInstanceRequest&, const DescribeInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstanceAsyncHandler;
typedef Outcome<Error, Model::DescribeLicenseResult> DescribeLicenseOutcome;
typedef std::future<DescribeLicenseOutcome> DescribeLicenseOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::DescribeLicenseRequest&, const DescribeLicenseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLicenseAsyncHandler;
typedef Outcome<Error, Model::DescribeInstancesResult> DescribeInstancesOutcome;
typedef std::future<DescribeInstancesOutcome> DescribeInstancesOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::DescribeInstancesRequest&, const DescribeInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstancesAsyncHandler;
typedef Outcome<Error, Model::ActivateLicenseResult> ActivateLicenseOutcome;
typedef std::future<ActivateLicenseOutcome> ActivateLicenseOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::ActivateLicenseRequest&, const ActivateLicenseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ActivateLicenseAsyncHandler;
typedef Outcome<Error, Model::DescribeCommodityResult> DescribeCommodityOutcome;
typedef std::future<DescribeCommodityOutcome> DescribeCommodityOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::DescribeCommodityRequest&, const DescribeCommodityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCommodityAsyncHandler;
typedef Outcome<Error, Model::DescribeProductResult> DescribeProductOutcome;
typedef std::future<DescribeProductOutcome> DescribeProductOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::DescribeProductRequest&, const DescribeProductOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeProductAsyncHandler;
typedef Outcome<Error, Model::CreateCommodityResult> CreateCommodityOutcome;
typedef std::future<CreateCommodityOutcome> CreateCommodityOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::CreateCommodityRequest&, const CreateCommodityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCommodityAsyncHandler;
typedef Outcome<Error, Model::DeleteCommodityResult> DeleteCommodityOutcome;
typedef std::future<DeleteCommodityOutcome> DeleteCommodityOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::DeleteCommodityRequest&, const DeleteCommodityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCommodityAsyncHandler;
typedef Outcome<Error, Model::UpdateCommodityResult> UpdateCommodityOutcome;
typedef std::future<UpdateCommodityOutcome> UpdateCommodityOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::UpdateCommodityRequest&, const UpdateCommodityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateCommodityAsyncHandler;
typedef Outcome<Error, Model::DescribeCommoditiesResult> DescribeCommoditiesOutcome;
typedef std::future<DescribeCommoditiesOutcome> DescribeCommoditiesOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::DescribeCommoditiesRequest&, const DescribeCommoditiesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCommoditiesAsyncHandler;
typedef Outcome<Error, Model::UploadCommodityFileResult> UploadCommodityFileOutcome;
typedef std::future<UploadCommodityFileOutcome> UploadCommodityFileOutcomeCallable;
typedef std::function<void(const MarketClient*, const Model::UploadCommodityFileRequest&, const UploadCommodityFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UploadCommodityFileAsyncHandler;
MarketClient(const Credentials &credentials, const ClientConfiguration &configuration);
MarketClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
MarketClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~MarketClient();
NotifyContractEventOutcome notifyContractEvent(const Model::NotifyContractEventRequest &request)const;
void notifyContractEventAsync(const Model::NotifyContractEventRequest& request, const NotifyContractEventAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
NotifyContractEventOutcomeCallable notifyContractEventCallable(const Model::NotifyContractEventRequest& request) const;
PushMeteringDataOutcome pushMeteringData(const Model::PushMeteringDataRequest &request)const;
void pushMeteringDataAsync(const Model::PushMeteringDataRequest& request, const PushMeteringDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
PushMeteringDataOutcomeCallable pushMeteringDataCallable(const Model::PushMeteringDataRequest& request) const;
DescribeOrderOutcome describeOrder(const Model::DescribeOrderRequest &request)const;
void describeOrderAsync(const Model::DescribeOrderRequest& request, const DescribeOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeOrderOutcomeCallable describeOrderCallable(const Model::DescribeOrderRequest& request) const;
BindImagePackageOutcome bindImagePackage(const Model::BindImagePackageRequest &request)const;
void bindImagePackageAsync(const Model::BindImagePackageRequest& request, const BindImagePackageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BindImagePackageOutcomeCallable bindImagePackageCallable(const Model::BindImagePackageRequest& request) const;
QueryMarketImagesOutcome queryMarketImages(const Model::QueryMarketImagesRequest &request)const;
void queryMarketImagesAsync(const Model::QueryMarketImagesRequest& request, const QueryMarketImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryMarketImagesOutcomeCallable queryMarketImagesCallable(const Model::QueryMarketImagesRequest& request) const;
DescribeProductsOutcome describeProducts(const Model::DescribeProductsRequest &request)const;
void describeProductsAsync(const Model::DescribeProductsRequest& request, const DescribeProductsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeProductsOutcomeCallable describeProductsCallable(const Model::DescribeProductsRequest& request) const;
CreateOrderOutcome createOrder(const Model::CreateOrderRequest &request)const;
void createOrderAsync(const Model::CreateOrderRequest& request, const CreateOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateOrderOutcomeCallable createOrderCallable(const Model::CreateOrderRequest& request) const;
DescribePriceOutcome describePrice(const Model::DescribePriceRequest &request)const;
void describePriceAsync(const Model::DescribePriceRequest& request, const DescribePriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePriceOutcomeCallable describePriceCallable(const Model::DescribePriceRequest& request) const;
DescribeRateOutcome describeRate(const Model::DescribeRateRequest &request)const;
void describeRateAsync(const Model::DescribeRateRequest& request, const DescribeRateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRateOutcomeCallable describeRateCallable(const Model::DescribeRateRequest& request) const;
QueryMarketCategoriesOutcome queryMarketCategories(const Model::QueryMarketCategoriesRequest &request)const;
void queryMarketCategoriesAsync(const Model::QueryMarketCategoriesRequest& request, const QueryMarketCategoriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryMarketCategoriesOutcomeCallable queryMarketCategoriesCallable(const Model::QueryMarketCategoriesRequest& request) const;
CreateRateOutcome createRate(const Model::CreateRateRequest &request)const;
void createRateAsync(const Model::CreateRateRequest& request, const CreateRateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateRateOutcomeCallable createRateCallable(const Model::CreateRateRequest& request) const;
DescribeInstanceOutcome describeInstance(const Model::DescribeInstanceRequest &request)const;
void describeInstanceAsync(const Model::DescribeInstanceRequest& request, const DescribeInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeInstanceOutcomeCallable describeInstanceCallable(const Model::DescribeInstanceRequest& request) const;
DescribeLicenseOutcome describeLicense(const Model::DescribeLicenseRequest &request)const;
void describeLicenseAsync(const Model::DescribeLicenseRequest& request, const DescribeLicenseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLicenseOutcomeCallable describeLicenseCallable(const Model::DescribeLicenseRequest& request) const;
DescribeInstancesOutcome describeInstances(const Model::DescribeInstancesRequest &request)const;
void describeInstancesAsync(const Model::DescribeInstancesRequest& request, const DescribeInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeInstancesOutcomeCallable describeInstancesCallable(const Model::DescribeInstancesRequest& request) const;
ActivateLicenseOutcome activateLicense(const Model::ActivateLicenseRequest &request)const;
void activateLicenseAsync(const Model::ActivateLicenseRequest& request, const ActivateLicenseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ActivateLicenseOutcomeCallable activateLicenseCallable(const Model::ActivateLicenseRequest& request) const;
DescribeCommodityOutcome describeCommodity(const Model::DescribeCommodityRequest &request)const;
void describeCommodityAsync(const Model::DescribeCommodityRequest& request, const DescribeCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCommodityOutcomeCallable describeCommodityCallable(const Model::DescribeCommodityRequest& request) const;
DescribeProductOutcome describeProduct(const Model::DescribeProductRequest &request)const;
void describeProductAsync(const Model::DescribeProductRequest& request, const DescribeProductAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeProductOutcomeCallable describeProductCallable(const Model::DescribeProductRequest& request) const;
CreateCommodityOutcome createCommodity(const Model::CreateCommodityRequest &request)const;
void createCommodityAsync(const Model::CreateCommodityRequest& request, const CreateCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateCommodityOutcomeCallable createCommodityCallable(const Model::CreateCommodityRequest& request) const;
DeleteCommodityOutcome deleteCommodity(const Model::DeleteCommodityRequest &request)const;
void deleteCommodityAsync(const Model::DeleteCommodityRequest& request, const DeleteCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteCommodityOutcomeCallable deleteCommodityCallable(const Model::DeleteCommodityRequest& request) const;
UpdateCommodityOutcome updateCommodity(const Model::UpdateCommodityRequest &request)const;
void updateCommodityAsync(const Model::UpdateCommodityRequest& request, const UpdateCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateCommodityOutcomeCallable updateCommodityCallable(const Model::UpdateCommodityRequest& request) const;
DescribeCommoditiesOutcome describeCommodities(const Model::DescribeCommoditiesRequest &request)const;
void describeCommoditiesAsync(const Model::DescribeCommoditiesRequest& request, const DescribeCommoditiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCommoditiesOutcomeCallable describeCommoditiesCallable(const Model::DescribeCommoditiesRequest& request) const;
UploadCommodityFileOutcome uploadCommodityFile(const Model::UploadCommodityFileRequest &request)const;
void uploadCommodityFileAsync(const Model::UploadCommodityFileRequest& request, const UploadCommodityFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UploadCommodityFileOutcomeCallable uploadCommodityFileCallable(const Model::UploadCommodityFileRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_MARKET_MARKETCLIENT_H_

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_MARKET_MARKETEXPORT_H_
#define ALIBABACLOUD_MARKET_MARKETEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_MARKET_LIBRARY)
# define ALIBABACLOUD_MARKET_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_MARKET_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_MARKET_EXPORT
#endif
#endif // !ALIBABACLOUD_MARKET_MARKETEXPORT_H_

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_MARKET_MODEL_ACTIVATELICENSEREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_ACTIVATELICENSEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT ActivateLicenseRequest : public RpcServiceRequest
{
public:
ActivateLicenseRequest();
~ActivateLicenseRequest();
std::string getIdentification()const;
void setIdentification(const std::string& identification);
std::string getLicenseCode()const;
void setLicenseCode(const std::string& licenseCode);
private:
std::string identification_;
std::string licenseCode_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_ACTIVATELICENSEREQUEST_H_

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_MARKET_MODEL_ACTIVATELICENSERESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_ACTIVATELICENSERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT ActivateLicenseResult : public ServiceResult
{
public:
ActivateLicenseResult();
explicit ActivateLicenseResult(const std::string &payload);
~ActivateLicenseResult();
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_ACTIVATELICENSERESULT_H_

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_MARKET_MODEL_BINDIMAGEPACKAGEREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_BINDIMAGEPACKAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT BindImagePackageRequest : public RpcServiceRequest
{
public:
BindImagePackageRequest();
~BindImagePackageRequest();
std::string getEcsInstanceId()const;
void setEcsInstanceId(const std::string& ecsInstanceId);
std::string getImagePackageInstanceId()const;
void setImagePackageInstanceId(const std::string& imagePackageInstanceId);
private:
std::string ecsInstanceId_;
std::string imagePackageInstanceId_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_BINDIMAGEPACKAGEREQUEST_H_

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_MARKET_MODEL_BINDIMAGEPACKAGERESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_BINDIMAGEPACKAGERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT BindImagePackageResult : public ServiceResult
{
public:
BindImagePackageResult();
explicit BindImagePackageResult(const std::string &payload);
~BindImagePackageResult();
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_BINDIMAGEPACKAGERESULT_H_

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_MARKET_MODEL_CREATECOMMODITYREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_CREATECOMMODITYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT CreateCommodityRequest : public RpcServiceRequest
{
public:
CreateCommodityRequest();
~CreateCommodityRequest();
std::string getApplicationId()const;
void setApplicationId(const std::string& applicationId);
std::string getContent()const;
void setContent(const std::string& content);
private:
std::string applicationId_;
std::string content_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_CREATECOMMODITYREQUEST_H_

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_MARKET_MODEL_CREATECOMMODITYRESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_CREATECOMMODITYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT CreateCommodityResult : public ServiceResult
{
public:
struct Commodity
{
std::string commodityId;
};
CreateCommodityResult();
explicit CreateCommodityResult(const std::string &payload);
~CreateCommodityResult();
Commodity getCommodity()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
Commodity commodity_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_CREATECOMMODITYRESULT_H_

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.
*/
#ifndef ALIBABACLOUD_MARKET_MODEL_CREATEORDERREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_CREATEORDERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT CreateOrderRequest : public RpcServiceRequest
{
public:
CreateOrderRequest();
~CreateOrderRequest();
std::string getOrderSouce()const;
void setOrderSouce(const std::string& orderSouce);
std::string getCommodity()const;
void setCommodity(const std::string& commodity);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getOwnerId()const;
void setOwnerId(const std::string& ownerId);
std::string getPaymentType()const;
void setPaymentType(const std::string& paymentType);
std::string getOrderType()const;
void setOrderType(const std::string& orderType);
private:
std::string orderSouce_;
std::string commodity_;
std::string clientToken_;
std::string ownerId_;
std::string paymentType_;
std::string orderType_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_CREATEORDERREQUEST_H_

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_MARKET_MODEL_CREATEORDERRESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_CREATEORDERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT CreateOrderResult : public ServiceResult
{
public:
CreateOrderResult();
explicit CreateOrderResult(const std::string &payload);
~CreateOrderResult();
std::vector<std::string> getInstanceIds()const;
std::string getOrderId()const;
protected:
void parse(const std::string &payload);
private:
std::vector<std::string> instanceIds_;
std::string orderId_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_CREATEORDERRESULT_H_

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_MARKET_MODEL_CREATERATEREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_CREATERATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT CreateRateRequest : public RpcServiceRequest
{
public:
CreateRateRequest();
~CreateRateRequest();
std::string getScore()const;
void setScore(const std::string& score);
std::string getOrderId()const;
void setOrderId(const std::string& orderId);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getContent()const;
void setContent(const std::string& content);
private:
std::string score_;
std::string orderId_;
std::string requestId_;
std::string content_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_CREATERATEREQUEST_H_

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_MARKET_MODEL_CREATERATERESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_CREATERATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT CreateRateResult : public ServiceResult
{
public:
CreateRateResult();
explicit CreateRateResult(const std::string &payload);
~CreateRateResult();
long getId()const;
protected:
void parse(const std::string &payload);
private:
long id_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_CREATERATERESULT_H_

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_MARKET_MODEL_DELETECOMMODITYREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_DELETECOMMODITYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DeleteCommodityRequest : public RpcServiceRequest
{
public:
DeleteCommodityRequest();
~DeleteCommodityRequest();
std::string getCommodityId()const;
void setCommodityId(const std::string& commodityId);
private:
std::string commodityId_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DELETECOMMODITYREQUEST_H_

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_MARKET_MODEL_DELETECOMMODITYRESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_DELETECOMMODITYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DeleteCommodityResult : public ServiceResult
{
public:
DeleteCommodityResult();
explicit DeleteCommodityResult(const std::string &payload);
~DeleteCommodityResult();
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DELETECOMMODITYRESULT_H_

View File

@@ -0,0 +1,87 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_MARKET_MODEL_DESCRIBECOMMODITIESREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBECOMMODITIESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeCommoditiesRequest : public RpcServiceRequest
{
public:
DescribeCommoditiesRequest();
~DescribeCommoditiesRequest();
std::string getCommodityGmtModifiedTo()const;
void setCommodityGmtModifiedTo(const std::string& commodityGmtModifiedTo);
std::string getCommodityGmtModifiedFrom()const;
void setCommodityGmtModifiedFrom(const std::string& commodityGmtModifiedFrom);
std::string getCommodityId()const;
void setCommodityId(const std::string& commodityId);
std::string getCommodityGmtPublishFrom()const;
void setCommodityGmtPublishFrom(const std::string& commodityGmtPublishFrom);
std::string getCommodityStatuses()const;
void setCommodityStatuses(const std::string& commodityStatuses);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getCommodityGmtCreatedFrom()const;
void setCommodityGmtCreatedFrom(const std::string& commodityGmtCreatedFrom);
std::string getCommodityIds()const;
void setCommodityIds(const std::string& commodityIds);
std::string getCommodityGmtCreatedTo()const;
void setCommodityGmtCreatedTo(const std::string& commodityGmtCreatedTo);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getCommodityGmtPublishTo()const;
void setCommodityGmtPublishTo(const std::string& commodityGmtPublishTo);
std::string getCommodityAuditStatuses()const;
void setCommodityAuditStatuses(const std::string& commodityAuditStatuses);
std::string getProperties()const;
void setProperties(const std::string& properties);
std::string getCommodityCategoryIds()const;
void setCommodityCategoryIds(const std::string& commodityCategoryIds);
private:
std::string commodityGmtModifiedTo_;
std::string commodityGmtModifiedFrom_;
std::string commodityId_;
std::string commodityGmtPublishFrom_;
std::string commodityStatuses_;
int pageNumber_;
std::string commodityGmtCreatedFrom_;
std::string commodityIds_;
std::string commodityGmtCreatedTo_;
int pageSize_;
std::string commodityGmtPublishTo_;
std::string commodityAuditStatuses_;
std::string properties_;
std::string commodityCategoryIds_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBECOMMODITIESREQUEST_H_

View File

@@ -0,0 +1,70 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_MARKET_MODEL_DESCRIBECOMMODITIESRESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBECOMMODITIESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeCommoditiesResult : public ServiceResult
{
public:
struct Data
{
struct Pageable
{
int pageSize;
int pageNumber;
};
struct Commodity
{
std::string commodityId;
std::string properties;
std::string applicationId;
};
long totalCount;
Pageable pageable;
std::vector<Commodity> commodities;
};
DescribeCommoditiesResult();
explicit DescribeCommoditiesResult(const std::string &payload);
~DescribeCommoditiesResult();
Data getData()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBECOMMODITIESRESULT_H_

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_MARKET_MODEL_DESCRIBECOMMODITYREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBECOMMODITYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeCommodityRequest : public RpcServiceRequest
{
public:
DescribeCommodityRequest();
~DescribeCommodityRequest();
std::string getCommodityId()const;
void setCommodityId(const std::string& commodityId);
private:
std::string commodityId_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBECOMMODITYREQUEST_H_

View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MARKET_MODEL_DESCRIBECOMMODITYRESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBECOMMODITYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeCommodityResult : public ServiceResult
{
public:
struct Commodity
{
std::string commodityId;
std::string commoditySpecs;
std::string properties;
std::string applicationId;
};
DescribeCommodityResult();
explicit DescribeCommodityResult(const std::string &payload);
~DescribeCommodityResult();
Commodity getCommodity()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
Commodity commodity_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBECOMMODITYRESULT_H_

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_MARKET_MODEL_DESCRIBEINSTANCEREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBEINSTANCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeInstanceRequest : public RpcServiceRequest
{
public:
DescribeInstanceRequest();
~DescribeInstanceRequest();
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getInstanceId()const;
void setInstanceId(const std::string& instanceId);
std::string getOrderType()const;
void setOrderType(const std::string& orderType);
private:
long ownerId_;
std::string instanceId_;
std::string orderType_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBEINSTANCEREQUEST_H_

View File

@@ -0,0 +1,114 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_MARKET_MODEL_DESCRIBEINSTANCERESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBEINSTANCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeInstanceResult : public ServiceResult
{
public:
struct RelationalData
{
std::string serviceStatus;
};
struct Module
{
struct Property
{
struct PropertyValue
{
std::string type;
std::string min;
std::string max;
std::string value;
std::string displayName;
std::string step;
std::string remark;
};
std::vector<Property::PropertyValue> propertyValues;
std::string key;
std::string displayUnit;
std::string name;
std::string showType;
};
std::string id;
std::vector<Module::Property> properties;
std::string code;
std::string name;
};
DescribeInstanceResult();
explicit DescribeInstanceResult(const std::string &payload);
~DescribeInstanceResult();
std::string getStatus()const;
std::string getProductName()const;
long getInstanceId()const;
std::string getProductCode()const;
long getEndOn()const;
std::vector<Module> getModules()const;
RelationalData getRelationalData()const;
std::string getProductType()const;
std::string getAppJson()const;
long getOrderId()const;
std::string getConstraints()const;
std::string getExtendJson()const;
std::string getSupplierName()const;
std::string getComponentJson()const;
std::string getProductSkuCode()const;
long getCreatedOn()const;
std::string getHostJson()const;
long getBeganOn()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
std::string productName_;
long instanceId_;
std::string productCode_;
long endOn_;
std::vector<Module> modules_;
RelationalData relationalData_;
std::string productType_;
std::string appJson_;
long orderId_;
std::string constraints_;
std::string extendJson_;
std::string supplierName_;
std::string componentJson_;
std::string productSkuCode_;
long createdOn_;
std::string hostJson_;
long beganOn_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBEINSTANCERESULT_H_

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_MARKET_MODEL_DESCRIBEINSTANCESREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBEINSTANCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeInstancesRequest : public RpcServiceRequest
{
public:
DescribeInstancesRequest();
~DescribeInstancesRequest();
int getPageSize()const;
void setPageSize(int pageSize);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getProductType()const;
void setProductType(const std::string& productType);
private:
int pageSize_;
int pageNumber_;
std::string productType_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBEINSTANCESREQUEST_H_

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.
*/
#ifndef ALIBABACLOUD_MARKET_MODEL_DESCRIBEINSTANCESRESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBEINSTANCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeInstancesResult : public ServiceResult
{
public:
struct InstanceItem
{
std::string status;
std::string productName;
long instanceId;
std::string productCode;
long endOn;
std::string productType;
std::string appJson;
long orderId;
std::string idaasJson;
std::string extendJson;
std::string supplierName;
std::string imageJson;
std::string productSkuCode;
long createdOn;
std::string hostJson;
std::string apiJson;
long beganOn;
};
DescribeInstancesResult();
explicit DescribeInstancesResult(const std::string &payload);
~DescribeInstancesResult();
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<InstanceItem> getInstanceItems()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<InstanceItem> instanceItems_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBEINSTANCESRESULT_H_

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_MARKET_MODEL_DESCRIBELICENSEREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBELICENSEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeLicenseRequest : public RpcServiceRequest
{
public:
DescribeLicenseRequest();
~DescribeLicenseRequest();
std::string getLicenseCode()const;
void setLicenseCode(const std::string& licenseCode);
private:
std::string licenseCode_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBELICENSEREQUEST_H_

View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_MARKET_MODEL_DESCRIBELICENSERESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBELICENSERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeLicenseResult : public ServiceResult
{
public:
struct License
{
struct ExtendInfo
{
std::string email;
std::string mobile;
long accountQuantity;
long aliUid;
};
struct LicenseAttribute
{
std::string value;
std::string code;
};
std::string licenseCode;
std::string productName;
std::string instanceId;
std::string activateTime;
std::string productCode;
std::string supplierName;
std::string licenseStatus;
std::string createTime;
std::string expiredTime;
std::vector<LicenseAttribute> extendArray;
ExtendInfo extendInfo;
std::string productSkuId;
};
DescribeLicenseResult();
explicit DescribeLicenseResult(const std::string &payload);
~DescribeLicenseResult();
License getLicense()const;
protected:
void parse(const std::string &payload);
private:
License license_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBELICENSERESULT_H_

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_MARKET_MODEL_DESCRIBEORDERREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBEORDERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeOrderRequest : public RpcServiceRequest
{
public:
DescribeOrderRequest();
~DescribeOrderRequest();
std::string getOrderId()const;
void setOrderId(const std::string& orderId);
private:
std::string orderId_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBEORDERREQUEST_H_

View File

@@ -0,0 +1,89 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MARKET_MODEL_DESCRIBEORDERRESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBEORDERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeOrderResult : public ServiceResult
{
public:
DescribeOrderResult();
explicit DescribeOrderResult(const std::string &payload);
~DescribeOrderResult();
long getPaidOn()const;
std::string getPeriodType()const;
float getCouponPrice()const;
std::string getPayStatus()const;
float getOriginalPrice()const;
std::string getProductName()const;
std::string getProductCode()const;
std::string getSupplierCompanyName()const;
int getQuantity()const;
long getOrderId()const;
std::vector<std::string> getSupplierTelephones()const;
std::string getOrderStatus()const;
std::string getOrderType()const;
float getTotalPrice()const;
std::string getProductSkuCode()const;
long getCreatedOn()const;
float getPaymentPrice()const;
std::vector<std::string> getInstanceIds()const;
long getAccountQuantity()const;
long getAliUid()const;
protected:
void parse(const std::string &payload);
private:
long paidOn_;
std::string periodType_;
float couponPrice_;
std::string payStatus_;
float originalPrice_;
std::string productName_;
std::string productCode_;
std::string supplierCompanyName_;
int quantity_;
long orderId_;
std::vector<std::string> supplierTelephones_;
std::string orderStatus_;
std::string orderType_;
float totalPrice_;
std::string productSkuCode_;
long createdOn_;
float paymentPrice_;
std::vector<std::string> instanceIds_;
long accountQuantity_;
long aliUid_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBEORDERRESULT_H_

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_MARKET_MODEL_DESCRIBEPRICEREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBEPRICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribePriceRequest : public RpcServiceRequest
{
public:
DescribePriceRequest();
~DescribePriceRequest();
std::string getCommodity()const;
void setCommodity(const std::string& commodity);
std::string getOrderType()const;
void setOrderType(const std::string& orderType);
private:
std::string commodity_;
std::string orderType_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBEPRICEREQUEST_H_

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.
*/
#ifndef ALIBABACLOUD_MARKET_MODEL_DESCRIBEPRICERESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBEPRICERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribePriceResult : public ServiceResult
{
public:
struct PromotionRule
{
std::string ruleId;
std::string title;
std::string name;
};
DescribePriceResult();
explicit DescribePriceResult(const std::string &payload);
~DescribePriceResult();
std::vector<PromotionRule> getPromotionRules()const;
float getOriginalPrice()const;
std::string getProductCode()const;
float getDiscountPrice()const;
float getTradePrice()const;
protected:
void parse(const std::string &payload);
private:
std::vector<PromotionRule> promotionRules_;
float originalPrice_;
std::string productCode_;
float discountPrice_;
float tradePrice_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBEPRICERESULT_H_

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_MARKET_MODEL_DESCRIBEPRODUCTREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBEPRODUCTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeProductRequest : public RpcServiceRequest
{
public:
DescribeProductRequest();
~DescribeProductRequest();
std::string getCode()const;
void setCode(const std::string& code);
bool getQueryDraft()const;
void setQueryDraft(bool queryDraft);
std::string getAliUid()const;
void setAliUid(const std::string& aliUid);
private:
std::string code_;
bool queryDraft_;
std::string aliUid_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBEPRODUCTREQUEST_H_

View File

@@ -0,0 +1,144 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_MARKET_MODEL_DESCRIBEPRODUCTRESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBEPRODUCTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeProductResult : public ServiceResult
{
public:
struct ShopInfo
{
struct WangWang
{
std::string userName;
std::string remark;
};
std::vector<WangWang> wangWangs;
std::vector<std::string> telephones;
long id;
std::string emails;
std::string name;
};
struct ProductSku
{
struct OrderPeriod
{
std::string periodType;
std::string name;
};
struct Module
{
struct Property
{
struct PropertyValue
{
std::string type;
std::string min;
std::string max;
std::string value;
std::string displayName;
std::string step;
std::string remark;
};
std::vector<Property::PropertyValue> propertyValues;
std::string key;
std::string displayUnit;
std::string name;
std::string showType;
};
std::string id;
std::vector<Module::Property> properties;
std::string code;
std::string name;
};
std::string constraints;
std::vector<ProductSku::Module> modules;
std::string chargeType;
std::vector<ProductSku::OrderPeriod> orderPeriods;
bool hidden;
std::string code;
std::string name;
};
struct ProductExtra
{
int order;
std::string type;
std::string values;
std::string label;
std::string key;
};
DescribeProductResult();
explicit DescribeProductResult(const std::string &payload);
~DescribeProductResult();
std::string getStatus()const;
std::string getDescription()const;
ShopInfo getShopInfo()const;
std::vector<ProductSku> getProductSkus()const;
long getUseCount()const;
long getGmtModified()const;
long getGmtCreated()const;
std::string getCode()const;
std::string getName()const;
std::string getShortDescription()const;
std::string getType()const;
float getScore()const;
std::string getAuditStatus()const;
std::string getAuditFailMsg()const;
std::vector<ProductExtra> getProductExtras()const;
long getAuditTime()const;
std::string getPicUrl()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
std::string description_;
ShopInfo shopInfo_;
std::vector<ProductSku> productSkus_;
long useCount_;
long gmtModified_;
long gmtCreated_;
std::string code_;
std::string name_;
std::string shortDescription_;
std::string type_;
float score_;
std::string auditStatus_;
std::string auditFailMsg_;
std::vector<ProductExtra> productExtras_;
long auditTime_;
std::string picUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBEPRODUCTRESULT_H_

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_MARKET_MODEL_DESCRIBEPRODUCTSREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBEPRODUCTSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeProductsRequest : public RpcServiceRequest
{
struct Filter
{
std::string value;
std::string key;
};
public:
DescribeProductsRequest();
~DescribeProductsRequest();
std::vector<Filter> getFilter()const;
void setFilter(const std::vector<Filter>& filter);
std::string getSearchTerm()const;
void setSearchTerm(const std::string& searchTerm);
int getPageSize()const;
void setPageSize(int pageSize);
int getPageNumber()const;
void setPageNumber(int pageNumber);
private:
std::vector<Filter> filter_;
std::string searchTerm_;
int pageSize_;
int pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBEPRODUCTSREQUEST_H_

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.
*/
#ifndef ALIBABACLOUD_MARKET_MODEL_DESCRIBEPRODUCTSRESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBEPRODUCTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeProductsResult : public ServiceResult
{
public:
struct ProductItem
{
long categoryId;
std::string warrantyDate;
std::string imageUrl;
std::string targetUrl;
std::string operationSystem;
std::string deliveryDate;
std::string code;
std::string name;
std::string shortDescription;
long supplierId;
std::string deliveryWay;
std::string score;
std::string supplierName;
std::string suggestedPrice;
std::string tags;
};
DescribeProductsResult();
explicit DescribeProductsResult(const std::string &payload);
~DescribeProductsResult();
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<ProductItem> getProductItems()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<ProductItem> productItems_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBEPRODUCTSRESULT_H_

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_MARKET_MODEL_DESCRIBERATEREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBERATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeRateRequest : public RpcServiceRequest
{
public:
DescribeRateRequest();
~DescribeRateRequest();
std::string getOrderId()const;
void setOrderId(const std::string& orderId);
private:
std::string orderId_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBERATEREQUEST_H_

View File

@@ -0,0 +1,79 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_MARKET_MODEL_DESCRIBERATERESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_DESCRIBERATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT DescribeRateResult : public ServiceResult
{
public:
DescribeRateResult();
explicit DescribeRateResult(const std::string &payload);
~DescribeRateResult();
std::string getInstanceId()const;
std::string getExplaintion()const;
long getGmtExplaintion()const;
std::string getProductId()const;
long getGmtCreated()const;
std::string getAdditionalContent()const;
std::string getOrderId()const;
long getGmtAdditionalExplaintion()const;
std::string getScore()const;
std::string getType()const;
std::string getContent()const;
std::string getAdditionalExplaintion()const;
long getId()const;
long getGmtAdditional()const;
long getAliUid()const;
protected:
void parse(const std::string &payload);
private:
std::string instanceId_;
std::string explaintion_;
long gmtExplaintion_;
std::string productId_;
long gmtCreated_;
std::string additionalContent_;
std::string orderId_;
long gmtAdditionalExplaintion_;
std::string score_;
std::string type_;
std::string content_;
std::string additionalExplaintion_;
long id_;
long gmtAdditional_;
long aliUid_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_DESCRIBERATERESULT_H_

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_MARKET_MODEL_NOTIFYCONTRACTEVENTREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_NOTIFYCONTRACTEVENTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT NotifyContractEventRequest : public RpcServiceRequest
{
public:
NotifyContractEventRequest();
~NotifyContractEventRequest();
std::string getEventMessage()const;
void setEventMessage(const std::string& eventMessage);
std::string getEventType()const;
void setEventType(const std::string& eventType);
private:
std::string eventMessage_;
std::string eventType_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_NOTIFYCONTRACTEVENTREQUEST_H_

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_MARKET_MODEL_NOTIFYCONTRACTEVENTRESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_NOTIFYCONTRACTEVENTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT NotifyContractEventResult : public ServiceResult
{
public:
NotifyContractEventResult();
explicit NotifyContractEventResult(const std::string &payload);
~NotifyContractEventResult();
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_NOTIFYCONTRACTEVENTRESULT_H_

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_MARKET_MODEL_PUSHMETERINGDATAREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_PUSHMETERINGDATAREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT PushMeteringDataRequest : public RpcServiceRequest
{
public:
PushMeteringDataRequest();
~PushMeteringDataRequest();
std::string getMetering()const;
void setMetering(const std::string& metering);
private:
std::string metering_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_PUSHMETERINGDATAREQUEST_H_

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_MARKET_MODEL_PUSHMETERINGDATARESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_PUSHMETERINGDATARESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT PushMeteringDataResult : public ServiceResult
{
public:
PushMeteringDataResult();
explicit PushMeteringDataResult(const std::string &payload);
~PushMeteringDataResult();
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_PUSHMETERINGDATARESULT_H_

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_MARKET_MODEL_QUERYMARKETCATEGORIESREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_QUERYMARKETCATEGORIESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT QueryMarketCategoriesRequest : public RpcServiceRequest
{
public:
QueryMarketCategoriesRequest();
~QueryMarketCategoriesRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_QUERYMARKETCATEGORIESREQUEST_H_

View File

@@ -0,0 +1,70 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_MARKET_MODEL_QUERYMARKETCATEGORIESRESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_QUERYMARKETCATEGORIESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT QueryMarketCategoriesResult : public ServiceResult
{
public:
struct Category
{
struct ChildCategory
{
std::string categoryCode;
std::string categoryName;
long id;
};
std::string categoryCode;
std::string categoryName;
long id;
std::vector<Category::ChildCategory> childCategories;
};
QueryMarketCategoriesResult();
explicit QueryMarketCategoriesResult(const std::string &payload);
~QueryMarketCategoriesResult();
int getTotalCount()const;
int getPageSize()const;
std::vector<Category> getCategories()const;
int getPageNumber()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
std::vector<Category> categories_;
int pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_QUERYMARKETCATEGORIESRESULT_H_

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_MARKET_MODEL_QUERYMARKETIMAGESREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_QUERYMARKETIMAGESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT QueryMarketImagesRequest : public RpcServiceRequest
{
public:
QueryMarketImagesRequest();
~QueryMarketImagesRequest();
std::string getParam()const;
void setParam(const std::string& param);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string param_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_QUERYMARKETIMAGESREQUEST_H_

View File

@@ -0,0 +1,130 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_MARKET_MODEL_QUERYMARKETIMAGESRESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_QUERYMARKETIMAGESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT QueryMarketImagesResult : public ServiceResult
{
public:
struct ImageProduct
{
struct Quota
{
long unusedQuota;
long totalQuota;
long usingQuota;
};
struct PriceInfo
{
struct Order
{
float originalPrice;
std::string priceUnit;
float discountPrice;
std::string currency;
int period;
std::vector<std::string> ruleIdSet;
float tradePrice;
};
struct Rule
{
long ruleId;
std::string title;
std::string name;
};
Order order;
std::vector<Rule> rules;
};
struct Image
{
struct DiskDeviceMapping
{
std::string diskType;
std::string snapshotId;
std::string format;
int size;
std::string device;
std::string importOSSBucket;
std::string importOSSObject;
};
bool isDefault;
std::vector<Image::DiskDeviceMapping> diskDeviceMappings;
std::string versionDescription;
std::string version;
int imageSize;
bool supportIO;
std::string imageId;
std::string region;
};
std::string buyUrl;
std::string productName;
long userCount;
std::vector<ImageProduct::Image> images;
int osBit;
std::string detailUrl;
std::string agreementUrl;
std::vector<std::string> skuCodes;
PriceInfo priceInfo;
std::string shortDescription;
float score;
Quota quota;
std::string imageProductCode;
std::string supplierName;
bool supportIO;
std::string categoryName;
std::string pictureUrl;
std::string storeUrl;
std::string baseSystem;
long createdOn;
std::string smallPicUrl;
std::string osKind;
};
QueryMarketImagesResult();
explicit QueryMarketImagesResult(const std::string &payload);
~QueryMarketImagesResult();
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<ImageProduct> getResult()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<ImageProduct> result_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_QUERYMARKETIMAGESRESULT_H_

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_MARKET_MODEL_UPDATECOMMODITYREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_UPDATECOMMODITYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT UpdateCommodityRequest : public RpcServiceRequest
{
public:
UpdateCommodityRequest();
~UpdateCommodityRequest();
std::string getCommodityId()const;
void setCommodityId(const std::string& commodityId);
std::string getContent()const;
void setContent(const std::string& content);
private:
std::string commodityId_;
std::string content_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_UPDATECOMMODITYREQUEST_H_

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_MARKET_MODEL_UPDATECOMMODITYRESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_UPDATECOMMODITYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT UpdateCommodityResult : public ServiceResult
{
public:
UpdateCommodityResult();
explicit UpdateCommodityResult(const std::string &payload);
~UpdateCommodityResult();
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_UPDATECOMMODITYRESULT_H_

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_MARKET_MODEL_UPLOADCOMMODITYFILEREQUEST_H_
#define ALIBABACLOUD_MARKET_MODEL_UPLOADCOMMODITYFILEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT UploadCommodityFileRequest : public RpcServiceRequest
{
public:
UploadCommodityFileRequest();
~UploadCommodityFileRequest();
std::string getFileResourceType()const;
void setFileResourceType(const std::string& fileResourceType);
std::string getFileResource()const;
void setFileResource(const std::string& fileResource);
std::string getFileContentType()const;
void setFileContentType(const std::string& fileContentType);
private:
std::string fileResourceType_;
std::string fileResource_;
std::string fileContentType_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_UPLOADCOMMODITYFILEREQUEST_H_

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.
*/
#ifndef ALIBABACLOUD_MARKET_MODEL_UPLOADCOMMODITYFILERESULT_H_
#define ALIBABACLOUD_MARKET_MODEL_UPLOADCOMMODITYFILERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/market/MarketExport.h>
namespace AlibabaCloud
{
namespace Market
{
namespace Model
{
class ALIBABACLOUD_MARKET_EXPORT UploadCommodityFileResult : public ServiceResult
{
public:
struct Data
{
std::string resource;
std::string resourceType;
};
UploadCommodityFileResult();
explicit UploadCommodityFileResult(const std::string &payload);
~UploadCommodityFileResult();
Data getData()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_MARKET_MODEL_UPLOADCOMMODITYFILERESULT_H_

845
market/src/MarketClient.cc Normal file
View File

@@ -0,0 +1,845 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/MarketClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
namespace
{
const std::string SERVICE_NAME = "Market";
}
MarketClient::MarketClient(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, "yunmarket");
}
MarketClient::MarketClient(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, "yunmarket");
}
MarketClient::MarketClient(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, "yunmarket");
}
MarketClient::~MarketClient()
{}
MarketClient::NotifyContractEventOutcome MarketClient::notifyContractEvent(const NotifyContractEventRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return NotifyContractEventOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return NotifyContractEventOutcome(NotifyContractEventResult(outcome.result()));
else
return NotifyContractEventOutcome(outcome.error());
}
void MarketClient::notifyContractEventAsync(const NotifyContractEventRequest& request, const NotifyContractEventAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, notifyContractEvent(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::NotifyContractEventOutcomeCallable MarketClient::notifyContractEventCallable(const NotifyContractEventRequest &request) const
{
auto task = std::make_shared<std::packaged_task<NotifyContractEventOutcome()>>(
[this, request]()
{
return this->notifyContractEvent(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::PushMeteringDataOutcome MarketClient::pushMeteringData(const PushMeteringDataRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return PushMeteringDataOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return PushMeteringDataOutcome(PushMeteringDataResult(outcome.result()));
else
return PushMeteringDataOutcome(outcome.error());
}
void MarketClient::pushMeteringDataAsync(const PushMeteringDataRequest& request, const PushMeteringDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, pushMeteringData(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::PushMeteringDataOutcomeCallable MarketClient::pushMeteringDataCallable(const PushMeteringDataRequest &request) const
{
auto task = std::make_shared<std::packaged_task<PushMeteringDataOutcome()>>(
[this, request]()
{
return this->pushMeteringData(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::DescribeOrderOutcome MarketClient::describeOrder(const DescribeOrderRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeOrderOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeOrderOutcome(DescribeOrderResult(outcome.result()));
else
return DescribeOrderOutcome(outcome.error());
}
void MarketClient::describeOrderAsync(const DescribeOrderRequest& request, const DescribeOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeOrder(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::DescribeOrderOutcomeCallable MarketClient::describeOrderCallable(const DescribeOrderRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeOrderOutcome()>>(
[this, request]()
{
return this->describeOrder(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::BindImagePackageOutcome MarketClient::bindImagePackage(const BindImagePackageRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return BindImagePackageOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return BindImagePackageOutcome(BindImagePackageResult(outcome.result()));
else
return BindImagePackageOutcome(outcome.error());
}
void MarketClient::bindImagePackageAsync(const BindImagePackageRequest& request, const BindImagePackageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, bindImagePackage(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::BindImagePackageOutcomeCallable MarketClient::bindImagePackageCallable(const BindImagePackageRequest &request) const
{
auto task = std::make_shared<std::packaged_task<BindImagePackageOutcome()>>(
[this, request]()
{
return this->bindImagePackage(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::QueryMarketImagesOutcome MarketClient::queryMarketImages(const QueryMarketImagesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QueryMarketImagesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QueryMarketImagesOutcome(QueryMarketImagesResult(outcome.result()));
else
return QueryMarketImagesOutcome(outcome.error());
}
void MarketClient::queryMarketImagesAsync(const QueryMarketImagesRequest& request, const QueryMarketImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, queryMarketImages(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::QueryMarketImagesOutcomeCallable MarketClient::queryMarketImagesCallable(const QueryMarketImagesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QueryMarketImagesOutcome()>>(
[this, request]()
{
return this->queryMarketImages(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::DescribeProductsOutcome MarketClient::describeProducts(const DescribeProductsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeProductsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeProductsOutcome(DescribeProductsResult(outcome.result()));
else
return DescribeProductsOutcome(outcome.error());
}
void MarketClient::describeProductsAsync(const DescribeProductsRequest& request, const DescribeProductsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeProducts(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::DescribeProductsOutcomeCallable MarketClient::describeProductsCallable(const DescribeProductsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeProductsOutcome()>>(
[this, request]()
{
return this->describeProducts(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::CreateOrderOutcome MarketClient::createOrder(const CreateOrderRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateOrderOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateOrderOutcome(CreateOrderResult(outcome.result()));
else
return CreateOrderOutcome(outcome.error());
}
void MarketClient::createOrderAsync(const CreateOrderRequest& request, const CreateOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createOrder(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::CreateOrderOutcomeCallable MarketClient::createOrderCallable(const CreateOrderRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateOrderOutcome()>>(
[this, request]()
{
return this->createOrder(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::DescribePriceOutcome MarketClient::describePrice(const DescribePriceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribePriceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribePriceOutcome(DescribePriceResult(outcome.result()));
else
return DescribePriceOutcome(outcome.error());
}
void MarketClient::describePriceAsync(const DescribePriceRequest& request, const DescribePriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describePrice(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::DescribePriceOutcomeCallable MarketClient::describePriceCallable(const DescribePriceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribePriceOutcome()>>(
[this, request]()
{
return this->describePrice(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::DescribeRateOutcome MarketClient::describeRate(const DescribeRateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeRateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeRateOutcome(DescribeRateResult(outcome.result()));
else
return DescribeRateOutcome(outcome.error());
}
void MarketClient::describeRateAsync(const DescribeRateRequest& request, const DescribeRateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeRate(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::DescribeRateOutcomeCallable MarketClient::describeRateCallable(const DescribeRateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeRateOutcome()>>(
[this, request]()
{
return this->describeRate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::QueryMarketCategoriesOutcome MarketClient::queryMarketCategories(const QueryMarketCategoriesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QueryMarketCategoriesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QueryMarketCategoriesOutcome(QueryMarketCategoriesResult(outcome.result()));
else
return QueryMarketCategoriesOutcome(outcome.error());
}
void MarketClient::queryMarketCategoriesAsync(const QueryMarketCategoriesRequest& request, const QueryMarketCategoriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, queryMarketCategories(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::QueryMarketCategoriesOutcomeCallable MarketClient::queryMarketCategoriesCallable(const QueryMarketCategoriesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QueryMarketCategoriesOutcome()>>(
[this, request]()
{
return this->queryMarketCategories(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::CreateRateOutcome MarketClient::createRate(const CreateRateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateRateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateRateOutcome(CreateRateResult(outcome.result()));
else
return CreateRateOutcome(outcome.error());
}
void MarketClient::createRateAsync(const CreateRateRequest& request, const CreateRateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createRate(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::CreateRateOutcomeCallable MarketClient::createRateCallable(const CreateRateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateRateOutcome()>>(
[this, request]()
{
return this->createRate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::DescribeInstanceOutcome MarketClient::describeInstance(const DescribeInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeInstanceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeInstanceOutcome(DescribeInstanceResult(outcome.result()));
else
return DescribeInstanceOutcome(outcome.error());
}
void MarketClient::describeInstanceAsync(const DescribeInstanceRequest& request, const DescribeInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeInstance(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::DescribeInstanceOutcomeCallable MarketClient::describeInstanceCallable(const DescribeInstanceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeInstanceOutcome()>>(
[this, request]()
{
return this->describeInstance(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::DescribeLicenseOutcome MarketClient::describeLicense(const DescribeLicenseRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLicenseOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLicenseOutcome(DescribeLicenseResult(outcome.result()));
else
return DescribeLicenseOutcome(outcome.error());
}
void MarketClient::describeLicenseAsync(const DescribeLicenseRequest& request, const DescribeLicenseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLicense(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::DescribeLicenseOutcomeCallable MarketClient::describeLicenseCallable(const DescribeLicenseRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLicenseOutcome()>>(
[this, request]()
{
return this->describeLicense(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::DescribeInstancesOutcome MarketClient::describeInstances(const DescribeInstancesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeInstancesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeInstancesOutcome(DescribeInstancesResult(outcome.result()));
else
return DescribeInstancesOutcome(outcome.error());
}
void MarketClient::describeInstancesAsync(const DescribeInstancesRequest& request, const DescribeInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeInstances(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::DescribeInstancesOutcomeCallable MarketClient::describeInstancesCallable(const DescribeInstancesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeInstancesOutcome()>>(
[this, request]()
{
return this->describeInstances(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::ActivateLicenseOutcome MarketClient::activateLicense(const ActivateLicenseRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ActivateLicenseOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ActivateLicenseOutcome(ActivateLicenseResult(outcome.result()));
else
return ActivateLicenseOutcome(outcome.error());
}
void MarketClient::activateLicenseAsync(const ActivateLicenseRequest& request, const ActivateLicenseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, activateLicense(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::ActivateLicenseOutcomeCallable MarketClient::activateLicenseCallable(const ActivateLicenseRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ActivateLicenseOutcome()>>(
[this, request]()
{
return this->activateLicense(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::DescribeCommodityOutcome MarketClient::describeCommodity(const DescribeCommodityRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeCommodityOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeCommodityOutcome(DescribeCommodityResult(outcome.result()));
else
return DescribeCommodityOutcome(outcome.error());
}
void MarketClient::describeCommodityAsync(const DescribeCommodityRequest& request, const DescribeCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeCommodity(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::DescribeCommodityOutcomeCallable MarketClient::describeCommodityCallable(const DescribeCommodityRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeCommodityOutcome()>>(
[this, request]()
{
return this->describeCommodity(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::DescribeProductOutcome MarketClient::describeProduct(const DescribeProductRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeProductOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeProductOutcome(DescribeProductResult(outcome.result()));
else
return DescribeProductOutcome(outcome.error());
}
void MarketClient::describeProductAsync(const DescribeProductRequest& request, const DescribeProductAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeProduct(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::DescribeProductOutcomeCallable MarketClient::describeProductCallable(const DescribeProductRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeProductOutcome()>>(
[this, request]()
{
return this->describeProduct(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::CreateCommodityOutcome MarketClient::createCommodity(const CreateCommodityRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateCommodityOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateCommodityOutcome(CreateCommodityResult(outcome.result()));
else
return CreateCommodityOutcome(outcome.error());
}
void MarketClient::createCommodityAsync(const CreateCommodityRequest& request, const CreateCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createCommodity(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::CreateCommodityOutcomeCallable MarketClient::createCommodityCallable(const CreateCommodityRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateCommodityOutcome()>>(
[this, request]()
{
return this->createCommodity(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::DeleteCommodityOutcome MarketClient::deleteCommodity(const DeleteCommodityRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteCommodityOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteCommodityOutcome(DeleteCommodityResult(outcome.result()));
else
return DeleteCommodityOutcome(outcome.error());
}
void MarketClient::deleteCommodityAsync(const DeleteCommodityRequest& request, const DeleteCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteCommodity(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::DeleteCommodityOutcomeCallable MarketClient::deleteCommodityCallable(const DeleteCommodityRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteCommodityOutcome()>>(
[this, request]()
{
return this->deleteCommodity(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::UpdateCommodityOutcome MarketClient::updateCommodity(const UpdateCommodityRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateCommodityOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateCommodityOutcome(UpdateCommodityResult(outcome.result()));
else
return UpdateCommodityOutcome(outcome.error());
}
void MarketClient::updateCommodityAsync(const UpdateCommodityRequest& request, const UpdateCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateCommodity(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::UpdateCommodityOutcomeCallable MarketClient::updateCommodityCallable(const UpdateCommodityRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateCommodityOutcome()>>(
[this, request]()
{
return this->updateCommodity(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::DescribeCommoditiesOutcome MarketClient::describeCommodities(const DescribeCommoditiesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeCommoditiesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeCommoditiesOutcome(DescribeCommoditiesResult(outcome.result()));
else
return DescribeCommoditiesOutcome(outcome.error());
}
void MarketClient::describeCommoditiesAsync(const DescribeCommoditiesRequest& request, const DescribeCommoditiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeCommodities(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::DescribeCommoditiesOutcomeCallable MarketClient::describeCommoditiesCallable(const DescribeCommoditiesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeCommoditiesOutcome()>>(
[this, request]()
{
return this->describeCommodities(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
MarketClient::UploadCommodityFileOutcome MarketClient::uploadCommodityFile(const UploadCommodityFileRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UploadCommodityFileOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UploadCommodityFileOutcome(UploadCommodityFileResult(outcome.result()));
else
return UploadCommodityFileOutcome(outcome.error());
}
void MarketClient::uploadCommodityFileAsync(const UploadCommodityFileRequest& request, const UploadCommodityFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, uploadCommodityFile(request), context);
};
asyncExecute(new Runnable(fn));
}
MarketClient::UploadCommodityFileOutcomeCallable MarketClient::uploadCommodityFileCallable(const UploadCommodityFileRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UploadCommodityFileOutcome()>>(
[this, request]()
{
return this->uploadCommodityFile(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/ActivateLicenseRequest.h>
using AlibabaCloud::Market::Model::ActivateLicenseRequest;
ActivateLicenseRequest::ActivateLicenseRequest() :
RpcServiceRequest("market", "2015-11-01", "ActivateLicense")
{}
ActivateLicenseRequest::~ActivateLicenseRequest()
{}
std::string ActivateLicenseRequest::getIdentification()const
{
return identification_;
}
void ActivateLicenseRequest::setIdentification(const std::string& identification)
{
identification_ = identification;
setCoreParameter("Identification", identification);
}
std::string ActivateLicenseRequest::getLicenseCode()const
{
return licenseCode_;
}
void ActivateLicenseRequest::setLicenseCode(const std::string& licenseCode)
{
licenseCode_ = licenseCode;
setCoreParameter("LicenseCode", licenseCode);
}

View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/ActivateLicenseResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
ActivateLicenseResult::ActivateLicenseResult() :
ServiceResult()
{}
ActivateLicenseResult::ActivateLicenseResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ActivateLicenseResult::~ActivateLicenseResult()
{}
void ActivateLicenseResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool ActivateLicenseResult::getSuccess()const
{
return success_;
}

View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/BindImagePackageRequest.h>
using AlibabaCloud::Market::Model::BindImagePackageRequest;
BindImagePackageRequest::BindImagePackageRequest() :
RpcServiceRequest("market", "2015-11-01", "BindImagePackage")
{}
BindImagePackageRequest::~BindImagePackageRequest()
{}
std::string BindImagePackageRequest::getEcsInstanceId()const
{
return ecsInstanceId_;
}
void BindImagePackageRequest::setEcsInstanceId(const std::string& ecsInstanceId)
{
ecsInstanceId_ = ecsInstanceId;
setCoreParameter("EcsInstanceId", ecsInstanceId);
}
std::string BindImagePackageRequest::getImagePackageInstanceId()const
{
return imagePackageInstanceId_;
}
void BindImagePackageRequest::setImagePackageInstanceId(const std::string& imagePackageInstanceId)
{
imagePackageInstanceId_ = imagePackageInstanceId;
setCoreParameter("ImagePackageInstanceId", imagePackageInstanceId);
}

View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/BindImagePackageResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
BindImagePackageResult::BindImagePackageResult() :
ServiceResult()
{}
BindImagePackageResult::BindImagePackageResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
BindImagePackageResult::~BindImagePackageResult()
{}
void BindImagePackageResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool BindImagePackageResult::getSuccess()const
{
return success_;
}

View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/CreateCommodityRequest.h>
using AlibabaCloud::Market::Model::CreateCommodityRequest;
CreateCommodityRequest::CreateCommodityRequest() :
RpcServiceRequest("market", "2015-11-01", "CreateCommodity")
{}
CreateCommodityRequest::~CreateCommodityRequest()
{}
std::string CreateCommodityRequest::getApplicationId()const
{
return applicationId_;
}
void CreateCommodityRequest::setApplicationId(const std::string& applicationId)
{
applicationId_ = applicationId;
setCoreParameter("ApplicationId", applicationId);
}
std::string CreateCommodityRequest::getContent()const
{
return content_;
}
void CreateCommodityRequest::setContent(const std::string& content)
{
content_ = content;
setCoreParameter("Content", content);
}

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.
*/
#include <alibabacloud/market/model/CreateCommodityResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
CreateCommodityResult::CreateCommodityResult() :
ServiceResult()
{}
CreateCommodityResult::CreateCommodityResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateCommodityResult::~CreateCommodityResult()
{}
void CreateCommodityResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto commodityNode = value["Commodity"];
if(!commodityNode["CommodityId"].isNull())
commodity_.commodityId = commodityNode["CommodityId"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
CreateCommodityResult::Commodity CreateCommodityResult::getCommodity()const
{
return commodity_;
}
bool CreateCommodityResult::getSuccess()const
{
return success_;
}

View File

@@ -0,0 +1,93 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/CreateOrderRequest.h>
using AlibabaCloud::Market::Model::CreateOrderRequest;
CreateOrderRequest::CreateOrderRequest() :
RpcServiceRequest("market", "2015-11-01", "CreateOrder")
{}
CreateOrderRequest::~CreateOrderRequest()
{}
std::string CreateOrderRequest::getOrderSouce()const
{
return orderSouce_;
}
void CreateOrderRequest::setOrderSouce(const std::string& orderSouce)
{
orderSouce_ = orderSouce;
setCoreParameter("OrderSouce", orderSouce);
}
std::string CreateOrderRequest::getCommodity()const
{
return commodity_;
}
void CreateOrderRequest::setCommodity(const std::string& commodity)
{
commodity_ = commodity;
setCoreParameter("Commodity", commodity);
}
std::string CreateOrderRequest::getClientToken()const
{
return clientToken_;
}
void CreateOrderRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setCoreParameter("ClientToken", clientToken);
}
std::string CreateOrderRequest::getOwnerId()const
{
return ownerId_;
}
void CreateOrderRequest::setOwnerId(const std::string& ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", ownerId);
}
std::string CreateOrderRequest::getPaymentType()const
{
return paymentType_;
}
void CreateOrderRequest::setPaymentType(const std::string& paymentType)
{
paymentType_ = paymentType;
setCoreParameter("PaymentType", paymentType);
}
std::string CreateOrderRequest::getOrderType()const
{
return orderType_;
}
void CreateOrderRequest::setOrderType(const std::string& orderType)
{
orderType_ = orderType;
setCoreParameter("OrderType", orderType);
}

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.
*/
#include <alibabacloud/market/model/CreateOrderResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
CreateOrderResult::CreateOrderResult() :
ServiceResult()
{}
CreateOrderResult::CreateOrderResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateOrderResult::~CreateOrderResult()
{}
void CreateOrderResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allInstanceIds = value["InstanceIds"]["InstanceId"];
for (const auto &item : allInstanceIds)
instanceIds_.push_back(item.asString());
if(!value["OrderId"].isNull())
orderId_ = value["OrderId"].asString();
}
std::vector<std::string> CreateOrderResult::getInstanceIds()const
{
return instanceIds_;
}
std::string CreateOrderResult::getOrderId()const
{
return orderId_;
}

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.
*/
#include <alibabacloud/market/model/CreateRateRequest.h>
using AlibabaCloud::Market::Model::CreateRateRequest;
CreateRateRequest::CreateRateRequest() :
RpcServiceRequest("market", "2015-11-01", "CreateRate")
{}
CreateRateRequest::~CreateRateRequest()
{}
std::string CreateRateRequest::getScore()const
{
return score_;
}
void CreateRateRequest::setScore(const std::string& score)
{
score_ = score;
setCoreParameter("Score", score);
}
std::string CreateRateRequest::getOrderId()const
{
return orderId_;
}
void CreateRateRequest::setOrderId(const std::string& orderId)
{
orderId_ = orderId;
setCoreParameter("OrderId", orderId);
}
std::string CreateRateRequest::getRequestId()const
{
return requestId_;
}
void CreateRateRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setCoreParameter("RequestId", requestId);
}
std::string CreateRateRequest::getContent()const
{
return content_;
}
void CreateRateRequest::setContent(const std::string& content)
{
content_ = content;
setCoreParameter("Content", content);
}

View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/CreateRateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
CreateRateResult::CreateRateResult() :
ServiceResult()
{}
CreateRateResult::CreateRateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateRateResult::~CreateRateResult()
{}
void CreateRateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Id"].isNull())
id_ = std::stol(value["Id"].asString());
}
long CreateRateResult::getId()const
{
return id_;
}

View File

@@ -0,0 +1,38 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/DeleteCommodityRequest.h>
using AlibabaCloud::Market::Model::DeleteCommodityRequest;
DeleteCommodityRequest::DeleteCommodityRequest() :
RpcServiceRequest("market", "2015-11-01", "DeleteCommodity")
{}
DeleteCommodityRequest::~DeleteCommodityRequest()
{}
std::string DeleteCommodityRequest::getCommodityId()const
{
return commodityId_;
}
void DeleteCommodityRequest::setCommodityId(const std::string& commodityId)
{
commodityId_ = commodityId;
setCoreParameter("CommodityId", commodityId);
}

View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/DeleteCommodityResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
DeleteCommodityResult::DeleteCommodityResult() :
ServiceResult()
{}
DeleteCommodityResult::DeleteCommodityResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteCommodityResult::~DeleteCommodityResult()
{}
void DeleteCommodityResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool DeleteCommodityResult::getSuccess()const
{
return success_;
}

View File

@@ -0,0 +1,181 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/DescribeCommoditiesRequest.h>
using AlibabaCloud::Market::Model::DescribeCommoditiesRequest;
DescribeCommoditiesRequest::DescribeCommoditiesRequest() :
RpcServiceRequest("market", "2015-11-01", "DescribeCommodities")
{}
DescribeCommoditiesRequest::~DescribeCommoditiesRequest()
{}
std::string DescribeCommoditiesRequest::getCommodityGmtModifiedTo()const
{
return commodityGmtModifiedTo_;
}
void DescribeCommoditiesRequest::setCommodityGmtModifiedTo(const std::string& commodityGmtModifiedTo)
{
commodityGmtModifiedTo_ = commodityGmtModifiedTo;
setCoreParameter("CommodityGmtModifiedTo", commodityGmtModifiedTo);
}
std::string DescribeCommoditiesRequest::getCommodityGmtModifiedFrom()const
{
return commodityGmtModifiedFrom_;
}
void DescribeCommoditiesRequest::setCommodityGmtModifiedFrom(const std::string& commodityGmtModifiedFrom)
{
commodityGmtModifiedFrom_ = commodityGmtModifiedFrom;
setCoreParameter("CommodityGmtModifiedFrom", commodityGmtModifiedFrom);
}
std::string DescribeCommoditiesRequest::getCommodityId()const
{
return commodityId_;
}
void DescribeCommoditiesRequest::setCommodityId(const std::string& commodityId)
{
commodityId_ = commodityId;
setCoreParameter("CommodityId", commodityId);
}
std::string DescribeCommoditiesRequest::getCommodityGmtPublishFrom()const
{
return commodityGmtPublishFrom_;
}
void DescribeCommoditiesRequest::setCommodityGmtPublishFrom(const std::string& commodityGmtPublishFrom)
{
commodityGmtPublishFrom_ = commodityGmtPublishFrom;
setCoreParameter("CommodityGmtPublishFrom", commodityGmtPublishFrom);
}
std::string DescribeCommoditiesRequest::getCommodityStatuses()const
{
return commodityStatuses_;
}
void DescribeCommoditiesRequest::setCommodityStatuses(const std::string& commodityStatuses)
{
commodityStatuses_ = commodityStatuses;
setCoreParameter("CommodityStatuses", commodityStatuses);
}
int DescribeCommoditiesRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeCommoditiesRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setCoreParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeCommoditiesRequest::getCommodityGmtCreatedFrom()const
{
return commodityGmtCreatedFrom_;
}
void DescribeCommoditiesRequest::setCommodityGmtCreatedFrom(const std::string& commodityGmtCreatedFrom)
{
commodityGmtCreatedFrom_ = commodityGmtCreatedFrom;
setCoreParameter("CommodityGmtCreatedFrom", commodityGmtCreatedFrom);
}
std::string DescribeCommoditiesRequest::getCommodityIds()const
{
return commodityIds_;
}
void DescribeCommoditiesRequest::setCommodityIds(const std::string& commodityIds)
{
commodityIds_ = commodityIds;
setCoreParameter("CommodityIds", commodityIds);
}
std::string DescribeCommoditiesRequest::getCommodityGmtCreatedTo()const
{
return commodityGmtCreatedTo_;
}
void DescribeCommoditiesRequest::setCommodityGmtCreatedTo(const std::string& commodityGmtCreatedTo)
{
commodityGmtCreatedTo_ = commodityGmtCreatedTo;
setCoreParameter("CommodityGmtCreatedTo", commodityGmtCreatedTo);
}
int DescribeCommoditiesRequest::getPageSize()const
{
return pageSize_;
}
void DescribeCommoditiesRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeCommoditiesRequest::getCommodityGmtPublishTo()const
{
return commodityGmtPublishTo_;
}
void DescribeCommoditiesRequest::setCommodityGmtPublishTo(const std::string& commodityGmtPublishTo)
{
commodityGmtPublishTo_ = commodityGmtPublishTo;
setCoreParameter("CommodityGmtPublishTo", commodityGmtPublishTo);
}
std::string DescribeCommoditiesRequest::getCommodityAuditStatuses()const
{
return commodityAuditStatuses_;
}
void DescribeCommoditiesRequest::setCommodityAuditStatuses(const std::string& commodityAuditStatuses)
{
commodityAuditStatuses_ = commodityAuditStatuses;
setCoreParameter("CommodityAuditStatuses", commodityAuditStatuses);
}
std::string DescribeCommoditiesRequest::getProperties()const
{
return properties_;
}
void DescribeCommoditiesRequest::setProperties(const std::string& properties)
{
properties_ = properties;
setCoreParameter("Properties", properties);
}
std::string DescribeCommoditiesRequest::getCommodityCategoryIds()const
{
return commodityCategoryIds_;
}
void DescribeCommoditiesRequest::setCommodityCategoryIds(const std::string& commodityCategoryIds)
{
commodityCategoryIds_ = commodityCategoryIds;
setCoreParameter("CommodityCategoryIds", commodityCategoryIds);
}

View File

@@ -0,0 +1,76 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/DescribeCommoditiesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
DescribeCommoditiesResult::DescribeCommoditiesResult() :
ServiceResult()
{}
DescribeCommoditiesResult::DescribeCommoditiesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeCommoditiesResult::~DescribeCommoditiesResult()
{}
void DescribeCommoditiesResult::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["TotalCount"].isNull())
data_.totalCount = std::stol(dataNode["TotalCount"].asString());
auto allCommodities = value["Commodities"]["Commodity"];
for (auto value : allCommodities)
{
Data::Commodity commodityObject;
if(!value["CommodityId"].isNull())
commodityObject.commodityId = value["CommodityId"].asString();
if(!value["Properties"].isNull())
commodityObject.properties = value["Properties"].asString();
if(!value["ApplicationId"].isNull())
commodityObject.applicationId = value["ApplicationId"].asString();
data_.commodities.push_back(commodityObject);
}
auto pageableNode = dataNode["Pageable"];
if(!pageableNode["PageNumber"].isNull())
data_.pageable.pageNumber = std::stoi(pageableNode["PageNumber"].asString());
if(!pageableNode["PageSize"].isNull())
data_.pageable.pageSize = std::stoi(pageableNode["PageSize"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
DescribeCommoditiesResult::Data DescribeCommoditiesResult::getData()const
{
return data_;
}
bool DescribeCommoditiesResult::getSuccess()const
{
return success_;
}

View File

@@ -0,0 +1,38 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/DescribeCommodityRequest.h>
using AlibabaCloud::Market::Model::DescribeCommodityRequest;
DescribeCommodityRequest::DescribeCommodityRequest() :
RpcServiceRequest("market", "2015-11-01", "DescribeCommodity")
{}
DescribeCommodityRequest::~DescribeCommodityRequest()
{}
std::string DescribeCommodityRequest::getCommodityId()const
{
return commodityId_;
}
void DescribeCommodityRequest::setCommodityId(const std::string& commodityId)
{
commodityId_ = commodityId;
setCoreParameter("CommodityId", commodityId);
}

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/market/model/DescribeCommodityResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
DescribeCommodityResult::DescribeCommodityResult() :
ServiceResult()
{}
DescribeCommodityResult::DescribeCommodityResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeCommodityResult::~DescribeCommodityResult()
{}
void DescribeCommodityResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto commodityNode = value["Commodity"];
if(!commodityNode["CommodityId"].isNull())
commodity_.commodityId = commodityNode["CommodityId"].asString();
if(!commodityNode["Properties"].isNull())
commodity_.properties = commodityNode["Properties"].asString();
if(!commodityNode["CommoditySpecs"].isNull())
commodity_.commoditySpecs = commodityNode["CommoditySpecs"].asString();
if(!commodityNode["ApplicationId"].isNull())
commodity_.applicationId = commodityNode["ApplicationId"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
DescribeCommodityResult::Commodity DescribeCommodityResult::getCommodity()const
{
return commodity_;
}
bool DescribeCommodityResult::getSuccess()const
{
return success_;
}

View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/DescribeInstanceRequest.h>
using AlibabaCloud::Market::Model::DescribeInstanceRequest;
DescribeInstanceRequest::DescribeInstanceRequest() :
RpcServiceRequest("market", "2015-11-01", "DescribeInstance")
{}
DescribeInstanceRequest::~DescribeInstanceRequest()
{}
long DescribeInstanceRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeInstanceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeInstanceRequest::getInstanceId()const
{
return instanceId_;
}
void DescribeInstanceRequest::setInstanceId(const std::string& instanceId)
{
instanceId_ = instanceId;
setCoreParameter("InstanceId", instanceId);
}
std::string DescribeInstanceRequest::getOrderType()const
{
return orderType_;
}
void DescribeInstanceRequest::setOrderType(const std::string& orderType)
{
orderType_ = orderType;
setCoreParameter("OrderType", orderType);
}

View File

@@ -0,0 +1,215 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/DescribeInstanceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
DescribeInstanceResult::DescribeInstanceResult() :
ServiceResult()
{}
DescribeInstanceResult::DescribeInstanceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeInstanceResult::~DescribeInstanceResult()
{}
void DescribeInstanceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allModules = value["Modules"]["Module"];
for (auto value : allModules)
{
Module modulesObject;
if(!value["Id"].isNull())
modulesObject.id = value["Id"].asString();
if(!value["Name"].isNull())
modulesObject.name = value["Name"].asString();
if(!value["Code"].isNull())
modulesObject.code = value["Code"].asString();
auto allProperties = value["Properties"]["Property"];
for (auto value : allProperties)
{
Module::Property propertiesObject;
if(!value["Name"].isNull())
propertiesObject.name = value["Name"].asString();
if(!value["Key"].isNull())
propertiesObject.key = value["Key"].asString();
if(!value["ShowType"].isNull())
propertiesObject.showType = value["ShowType"].asString();
if(!value["DisplayUnit"].isNull())
propertiesObject.displayUnit = value["DisplayUnit"].asString();
auto allPropertyValues = value["PropertyValues"]["PropertyValue"];
for (auto value : allPropertyValues)
{
Module::Property::PropertyValue propertyValuesObject;
if(!value["Value"].isNull())
propertyValuesObject.value = value["Value"].asString();
if(!value["DisplayName"].isNull())
propertyValuesObject.displayName = value["DisplayName"].asString();
if(!value["Type"].isNull())
propertyValuesObject.type = value["Type"].asString();
if(!value["Min"].isNull())
propertyValuesObject.min = value["Min"].asString();
if(!value["Max"].isNull())
propertyValuesObject.max = value["Max"].asString();
if(!value["Step"].isNull())
propertyValuesObject.step = value["Step"].asString();
if(!value["Remark"].isNull())
propertyValuesObject.remark = value["Remark"].asString();
propertiesObject.propertyValues.push_back(propertyValuesObject);
}
modulesObject.properties.push_back(propertiesObject);
}
modules_.push_back(modulesObject);
}
auto relationalDataNode = value["RelationalData"];
if(!relationalDataNode["ServiceStatus"].isNull())
relationalData_.serviceStatus = relationalDataNode["ServiceStatus"].asString();
if(!value["InstanceId"].isNull())
instanceId_ = std::stol(value["InstanceId"].asString());
if(!value["OrderId"].isNull())
orderId_ = std::stol(value["OrderId"].asString());
if(!value["SupplierName"].isNull())
supplierName_ = value["SupplierName"].asString();
if(!value["ProductCode"].isNull())
productCode_ = value["ProductCode"].asString();
if(!value["ProductSkuCode"].isNull())
productSkuCode_ = value["ProductSkuCode"].asString();
if(!value["ProductName"].isNull())
productName_ = value["ProductName"].asString();
if(!value["ProductType"].isNull())
productType_ = value["ProductType"].asString();
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["BeganOn"].isNull())
beganOn_ = std::stol(value["BeganOn"].asString());
if(!value["EndOn"].isNull())
endOn_ = std::stol(value["EndOn"].asString());
if(!value["CreatedOn"].isNull())
createdOn_ = std::stol(value["CreatedOn"].asString());
if(!value["ExtendJson"].isNull())
extendJson_ = value["ExtendJson"].asString();
if(!value["HostJson"].isNull())
hostJson_ = value["HostJson"].asString();
if(!value["AppJson"].isNull())
appJson_ = value["AppJson"].asString();
if(!value["ComponentJson"].isNull())
componentJson_ = value["ComponentJson"].asString();
if(!value["Constraints"].isNull())
constraints_ = value["Constraints"].asString();
}
std::string DescribeInstanceResult::getStatus()const
{
return status_;
}
std::string DescribeInstanceResult::getProductName()const
{
return productName_;
}
long DescribeInstanceResult::getInstanceId()const
{
return instanceId_;
}
std::string DescribeInstanceResult::getProductCode()const
{
return productCode_;
}
long DescribeInstanceResult::getEndOn()const
{
return endOn_;
}
std::vector<DescribeInstanceResult::Module> DescribeInstanceResult::getModules()const
{
return modules_;
}
DescribeInstanceResult::RelationalData DescribeInstanceResult::getRelationalData()const
{
return relationalData_;
}
std::string DescribeInstanceResult::getProductType()const
{
return productType_;
}
std::string DescribeInstanceResult::getAppJson()const
{
return appJson_;
}
long DescribeInstanceResult::getOrderId()const
{
return orderId_;
}
std::string DescribeInstanceResult::getConstraints()const
{
return constraints_;
}
std::string DescribeInstanceResult::getExtendJson()const
{
return extendJson_;
}
std::string DescribeInstanceResult::getSupplierName()const
{
return supplierName_;
}
std::string DescribeInstanceResult::getComponentJson()const
{
return componentJson_;
}
std::string DescribeInstanceResult::getProductSkuCode()const
{
return productSkuCode_;
}
long DescribeInstanceResult::getCreatedOn()const
{
return createdOn_;
}
std::string DescribeInstanceResult::getHostJson()const
{
return hostJson_;
}
long DescribeInstanceResult::getBeganOn()const
{
return beganOn_;
}

View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/DescribeInstancesRequest.h>
using AlibabaCloud::Market::Model::DescribeInstancesRequest;
DescribeInstancesRequest::DescribeInstancesRequest() :
RpcServiceRequest("market", "2015-11-01", "DescribeInstances")
{}
DescribeInstancesRequest::~DescribeInstancesRequest()
{}
int DescribeInstancesRequest::getPageSize()const
{
return pageSize_;
}
void DescribeInstancesRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
int DescribeInstancesRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeInstancesRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setCoreParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeInstancesRequest::getProductType()const
{
return productType_;
}
void DescribeInstancesRequest::setProductType(const std::string& productType)
{
productType_ = productType;
setCoreParameter("ProductType", productType);
}

View File

@@ -0,0 +1,110 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/DescribeInstancesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
DescribeInstancesResult::DescribeInstancesResult() :
ServiceResult()
{}
DescribeInstancesResult::DescribeInstancesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeInstancesResult::~DescribeInstancesResult()
{}
void DescribeInstancesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allInstanceItems = value["InstanceItems"]["InstanceItem"];
for (auto value : allInstanceItems)
{
InstanceItem instanceItemsObject;
if(!value["InstanceId"].isNull())
instanceItemsObject.instanceId = std::stol(value["InstanceId"].asString());
if(!value["OrderId"].isNull())
instanceItemsObject.orderId = std::stol(value["OrderId"].asString());
if(!value["SupplierName"].isNull())
instanceItemsObject.supplierName = value["SupplierName"].asString();
if(!value["ProductCode"].isNull())
instanceItemsObject.productCode = value["ProductCode"].asString();
if(!value["ProductSkuCode"].isNull())
instanceItemsObject.productSkuCode = value["ProductSkuCode"].asString();
if(!value["ProductName"].isNull())
instanceItemsObject.productName = value["ProductName"].asString();
if(!value["ProductType"].isNull())
instanceItemsObject.productType = value["ProductType"].asString();
if(!value["Status"].isNull())
instanceItemsObject.status = value["Status"].asString();
if(!value["BeganOn"].isNull())
instanceItemsObject.beganOn = std::stol(value["BeganOn"].asString());
if(!value["EndOn"].isNull())
instanceItemsObject.endOn = std::stol(value["EndOn"].asString());
if(!value["CreatedOn"].isNull())
instanceItemsObject.createdOn = std::stol(value["CreatedOn"].asString());
if(!value["ExtendJson"].isNull())
instanceItemsObject.extendJson = value["ExtendJson"].asString();
if(!value["HostJson"].isNull())
instanceItemsObject.hostJson = value["HostJson"].asString();
if(!value["AppJson"].isNull())
instanceItemsObject.appJson = value["AppJson"].asString();
if(!value["ApiJson"].isNull())
instanceItemsObject.apiJson = value["ApiJson"].asString();
if(!value["ImageJson"].isNull())
instanceItemsObject.imageJson = value["ImageJson"].asString();
if(!value["IdaasJson"].isNull())
instanceItemsObject.idaasJson = value["IdaasJson"].asString();
instanceItems_.push_back(instanceItemsObject);
}
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
int DescribeInstancesResult::getTotalCount()const
{
return totalCount_;
}
int DescribeInstancesResult::getPageSize()const
{
return pageSize_;
}
int DescribeInstancesResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescribeInstancesResult::InstanceItem> DescribeInstancesResult::getInstanceItems()const
{
return instanceItems_;
}

View File

@@ -0,0 +1,38 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/DescribeLicenseRequest.h>
using AlibabaCloud::Market::Model::DescribeLicenseRequest;
DescribeLicenseRequest::DescribeLicenseRequest() :
RpcServiceRequest("market", "2015-11-01", "DescribeLicense")
{}
DescribeLicenseRequest::~DescribeLicenseRequest()
{}
std::string DescribeLicenseRequest::getLicenseCode()const
{
return licenseCode_;
}
void DescribeLicenseRequest::setLicenseCode(const std::string& licenseCode)
{
licenseCode_ = licenseCode;
setCoreParameter("LicenseCode", licenseCode);
}

View File

@@ -0,0 +1,89 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/DescribeLicenseResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
DescribeLicenseResult::DescribeLicenseResult() :
ServiceResult()
{}
DescribeLicenseResult::DescribeLicenseResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeLicenseResult::~DescribeLicenseResult()
{}
void DescribeLicenseResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto licenseNode = value["License"];
if(!licenseNode["LicenseStatus"].isNull())
license_.licenseStatus = licenseNode["LicenseStatus"].asString();
if(!licenseNode["LicenseCode"].isNull())
license_.licenseCode = licenseNode["LicenseCode"].asString();
if(!licenseNode["InstanceId"].isNull())
license_.instanceId = licenseNode["InstanceId"].asString();
if(!licenseNode["CreateTime"].isNull())
license_.createTime = licenseNode["CreateTime"].asString();
if(!licenseNode["ExpiredTime"].isNull())
license_.expiredTime = licenseNode["ExpiredTime"].asString();
if(!licenseNode["ActivateTime"].isNull())
license_.activateTime = licenseNode["ActivateTime"].asString();
if(!licenseNode["ProductSkuId"].isNull())
license_.productSkuId = licenseNode["ProductSkuId"].asString();
if(!licenseNode["ProductCode"].isNull())
license_.productCode = licenseNode["ProductCode"].asString();
if(!licenseNode["ProductName"].isNull())
license_.productName = licenseNode["ProductName"].asString();
if(!licenseNode["SupplierName"].isNull())
license_.supplierName = licenseNode["SupplierName"].asString();
auto allExtendArray = value["ExtendArray"]["LicenseAttribute"];
for (auto value : allExtendArray)
{
License::LicenseAttribute licenseAttributeObject;
if(!value["Code"].isNull())
licenseAttributeObject.code = value["Code"].asString();
if(!value["Value"].isNull())
licenseAttributeObject.value = value["Value"].asString();
license_.extendArray.push_back(licenseAttributeObject);
}
auto extendInfoNode = licenseNode["ExtendInfo"];
if(!extendInfoNode["AliUid"].isNull())
license_.extendInfo.aliUid = std::stol(extendInfoNode["AliUid"].asString());
if(!extendInfoNode["Email"].isNull())
license_.extendInfo.email = extendInfoNode["Email"].asString();
if(!extendInfoNode["Mobile"].isNull())
license_.extendInfo.mobile = extendInfoNode["Mobile"].asString();
if(!extendInfoNode["AccountQuantity"].isNull())
license_.extendInfo.accountQuantity = std::stol(extendInfoNode["AccountQuantity"].asString());
}
DescribeLicenseResult::License DescribeLicenseResult::getLicense()const
{
return license_;
}

View File

@@ -0,0 +1,38 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/DescribeOrderRequest.h>
using AlibabaCloud::Market::Model::DescribeOrderRequest;
DescribeOrderRequest::DescribeOrderRequest() :
RpcServiceRequest("market", "2015-11-01", "DescribeOrder")
{}
DescribeOrderRequest::~DescribeOrderRequest()
{}
std::string DescribeOrderRequest::getOrderId()const
{
return orderId_;
}
void DescribeOrderRequest::setOrderId(const std::string& orderId)
{
orderId_ = orderId;
setCoreParameter("OrderId", orderId);
}

View File

@@ -0,0 +1,186 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/DescribeOrderResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
DescribeOrderResult::DescribeOrderResult() :
ServiceResult()
{}
DescribeOrderResult::DescribeOrderResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeOrderResult::~DescribeOrderResult()
{}
void DescribeOrderResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allSupplierTelephones = value["SupplierTelephones"]["Telephone"];
for (const auto &item : allSupplierTelephones)
supplierTelephones_.push_back(item.asString());
auto allInstanceIds = value["InstanceIds"]["InstanceId"];
for (const auto &item : allInstanceIds)
instanceIds_.push_back(item.asString());
if(!value["OrderId"].isNull())
orderId_ = std::stol(value["OrderId"].asString());
if(!value["AliUid"].isNull())
aliUid_ = std::stol(value["AliUid"].asString());
if(!value["SupplierCompanyName"].isNull())
supplierCompanyName_ = value["SupplierCompanyName"].asString();
if(!value["ProductCode"].isNull())
productCode_ = value["ProductCode"].asString();
if(!value["ProductSkuCode"].isNull())
productSkuCode_ = value["ProductSkuCode"].asString();
if(!value["ProductName"].isNull())
productName_ = value["ProductName"].asString();
if(!value["PeriodType"].isNull())
periodType_ = value["PeriodType"].asString();
if(!value["Quantity"].isNull())
quantity_ = std::stoi(value["Quantity"].asString());
if(!value["AccountQuantity"].isNull())
accountQuantity_ = std::stol(value["AccountQuantity"].asString());
if(!value["OrderType"].isNull())
orderType_ = value["OrderType"].asString();
if(!value["OrderStatus"].isNull())
orderStatus_ = value["OrderStatus"].asString();
if(!value["PayStatus"].isNull())
payStatus_ = value["PayStatus"].asString();
if(!value["PaidOn"].isNull())
paidOn_ = std::stol(value["PaidOn"].asString());
if(!value["CreatedOn"].isNull())
createdOn_ = std::stol(value["CreatedOn"].asString());
if(!value["OriginalPrice"].isNull())
originalPrice_ = std::stof(value["OriginalPrice"].asString());
if(!value["TotalPrice"].isNull())
totalPrice_ = std::stof(value["TotalPrice"].asString());
if(!value["PaymentPrice"].isNull())
paymentPrice_ = std::stof(value["PaymentPrice"].asString());
if(!value["CouponPrice"].isNull())
couponPrice_ = std::stof(value["CouponPrice"].asString());
}
long DescribeOrderResult::getPaidOn()const
{
return paidOn_;
}
std::string DescribeOrderResult::getPeriodType()const
{
return periodType_;
}
float DescribeOrderResult::getCouponPrice()const
{
return couponPrice_;
}
std::string DescribeOrderResult::getPayStatus()const
{
return payStatus_;
}
float DescribeOrderResult::getOriginalPrice()const
{
return originalPrice_;
}
std::string DescribeOrderResult::getProductName()const
{
return productName_;
}
std::string DescribeOrderResult::getProductCode()const
{
return productCode_;
}
std::string DescribeOrderResult::getSupplierCompanyName()const
{
return supplierCompanyName_;
}
int DescribeOrderResult::getQuantity()const
{
return quantity_;
}
long DescribeOrderResult::getOrderId()const
{
return orderId_;
}
std::vector<std::string> DescribeOrderResult::getSupplierTelephones()const
{
return supplierTelephones_;
}
std::string DescribeOrderResult::getOrderStatus()const
{
return orderStatus_;
}
std::string DescribeOrderResult::getOrderType()const
{
return orderType_;
}
float DescribeOrderResult::getTotalPrice()const
{
return totalPrice_;
}
std::string DescribeOrderResult::getProductSkuCode()const
{
return productSkuCode_;
}
long DescribeOrderResult::getCreatedOn()const
{
return createdOn_;
}
float DescribeOrderResult::getPaymentPrice()const
{
return paymentPrice_;
}
std::vector<std::string> DescribeOrderResult::getInstanceIds()const
{
return instanceIds_;
}
long DescribeOrderResult::getAccountQuantity()const
{
return accountQuantity_;
}
long DescribeOrderResult::getAliUid()const
{
return aliUid_;
}

View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/DescribePriceRequest.h>
using AlibabaCloud::Market::Model::DescribePriceRequest;
DescribePriceRequest::DescribePriceRequest() :
RpcServiceRequest("market", "2015-11-01", "DescribePrice")
{}
DescribePriceRequest::~DescribePriceRequest()
{}
std::string DescribePriceRequest::getCommodity()const
{
return commodity_;
}
void DescribePriceRequest::setCommodity(const std::string& commodity)
{
commodity_ = commodity;
setCoreParameter("Commodity", commodity);
}
std::string DescribePriceRequest::getOrderType()const
{
return orderType_;
}
void DescribePriceRequest::setOrderType(const std::string& orderType)
{
orderType_ = orderType;
setCoreParameter("OrderType", orderType);
}

View File

@@ -0,0 +1,89 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/DescribePriceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
DescribePriceResult::DescribePriceResult() :
ServiceResult()
{}
DescribePriceResult::DescribePriceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribePriceResult::~DescribePriceResult()
{}
void DescribePriceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allPromotionRules = value["PromotionRules"]["PromotionRule"];
for (auto value : allPromotionRules)
{
PromotionRule promotionRulesObject;
if(!value["RuleId"].isNull())
promotionRulesObject.ruleId = value["RuleId"].asString();
if(!value["Name"].isNull())
promotionRulesObject.name = value["Name"].asString();
if(!value["Title"].isNull())
promotionRulesObject.title = value["Title"].asString();
promotionRules_.push_back(promotionRulesObject);
}
if(!value["ProductCode"].isNull())
productCode_ = value["ProductCode"].asString();
if(!value["OriginalPrice"].isNull())
originalPrice_ = std::stof(value["OriginalPrice"].asString());
if(!value["TradePrice"].isNull())
tradePrice_ = std::stof(value["TradePrice"].asString());
if(!value["DiscountPrice"].isNull())
discountPrice_ = std::stof(value["DiscountPrice"].asString());
}
std::vector<DescribePriceResult::PromotionRule> DescribePriceResult::getPromotionRules()const
{
return promotionRules_;
}
float DescribePriceResult::getOriginalPrice()const
{
return originalPrice_;
}
std::string DescribePriceResult::getProductCode()const
{
return productCode_;
}
float DescribePriceResult::getDiscountPrice()const
{
return discountPrice_;
}
float DescribePriceResult::getTradePrice()const
{
return tradePrice_;
}

View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/DescribeProductRequest.h>
using AlibabaCloud::Market::Model::DescribeProductRequest;
DescribeProductRequest::DescribeProductRequest() :
RpcServiceRequest("market", "2015-11-01", "DescribeProduct")
{}
DescribeProductRequest::~DescribeProductRequest()
{}
std::string DescribeProductRequest::getCode()const
{
return code_;
}
void DescribeProductRequest::setCode(const std::string& code)
{
code_ = code;
setCoreParameter("Code", code);
}
bool DescribeProductRequest::getQueryDraft()const
{
return queryDraft_;
}
void DescribeProductRequest::setQueryDraft(bool queryDraft)
{
queryDraft_ = queryDraft;
setCoreParameter("QueryDraft", queryDraft ? "true" : "false");
}
std::string DescribeProductRequest::getAliUid()const
{
return aliUid_;
}
void DescribeProductRequest::setAliUid(const std::string& aliUid)
{
aliUid_ = aliUid;
setCoreParameter("AliUid", aliUid);
}

View File

@@ -0,0 +1,265 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/DescribeProductResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
DescribeProductResult::DescribeProductResult() :
ServiceResult()
{}
DescribeProductResult::DescribeProductResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeProductResult::~DescribeProductResult()
{}
void DescribeProductResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allProductSkus = value["ProductSkus"]["ProductSku"];
for (auto value : allProductSkus)
{
ProductSku productSkusObject;
if(!value["Name"].isNull())
productSkusObject.name = value["Name"].asString();
if(!value["Code"].isNull())
productSkusObject.code = value["Code"].asString();
if(!value["ChargeType"].isNull())
productSkusObject.chargeType = value["ChargeType"].asString();
if(!value["Constraints"].isNull())
productSkusObject.constraints = value["Constraints"].asString();
if(!value["Hidden"].isNull())
productSkusObject.hidden = value["Hidden"].asString() == "true";
auto allOrderPeriods = value["OrderPeriods"]["OrderPeriod"];
for (auto value : allOrderPeriods)
{
ProductSku::OrderPeriod orderPeriodsObject;
if(!value["Name"].isNull())
orderPeriodsObject.name = value["Name"].asString();
if(!value["PeriodType"].isNull())
orderPeriodsObject.periodType = value["PeriodType"].asString();
productSkusObject.orderPeriods.push_back(orderPeriodsObject);
}
auto allModules = value["Modules"]["Module"];
for (auto value : allModules)
{
ProductSku::Module modulesObject;
if(!value["Id"].isNull())
modulesObject.id = value["Id"].asString();
if(!value["Name"].isNull())
modulesObject.name = value["Name"].asString();
if(!value["Code"].isNull())
modulesObject.code = value["Code"].asString();
auto allProperties = value["Properties"]["Property"];
for (auto value : allProperties)
{
ProductSku::Module::Property propertiesObject;
if(!value["Name"].isNull())
propertiesObject.name = value["Name"].asString();
if(!value["Key"].isNull())
propertiesObject.key = value["Key"].asString();
if(!value["ShowType"].isNull())
propertiesObject.showType = value["ShowType"].asString();
if(!value["DisplayUnit"].isNull())
propertiesObject.displayUnit = value["DisplayUnit"].asString();
auto allPropertyValues = value["PropertyValues"]["PropertyValue"];
for (auto value : allPropertyValues)
{
ProductSku::Module::Property::PropertyValue propertyValuesObject;
if(!value["Value"].isNull())
propertyValuesObject.value = value["Value"].asString();
if(!value["DisplayName"].isNull())
propertyValuesObject.displayName = value["DisplayName"].asString();
if(!value["Type"].isNull())
propertyValuesObject.type = value["Type"].asString();
if(!value["Min"].isNull())
propertyValuesObject.min = value["Min"].asString();
if(!value["Max"].isNull())
propertyValuesObject.max = value["Max"].asString();
if(!value["Step"].isNull())
propertyValuesObject.step = value["Step"].asString();
if(!value["Remark"].isNull())
propertyValuesObject.remark = value["Remark"].asString();
propertiesObject.propertyValues.push_back(propertyValuesObject);
}
modulesObject.properties.push_back(propertiesObject);
}
productSkusObject.modules.push_back(modulesObject);
}
productSkus_.push_back(productSkusObject);
}
auto allProductExtras = value["ProductExtras"]["ProductExtra"];
for (auto value : allProductExtras)
{
ProductExtra productExtrasObject;
if(!value["Key"].isNull())
productExtrasObject.key = value["Key"].asString();
if(!value["Values"].isNull())
productExtrasObject.values = value["Values"].asString();
if(!value["Label"].isNull())
productExtrasObject.label = value["Label"].asString();
if(!value["Order"].isNull())
productExtrasObject.order = std::stoi(value["Order"].asString());
if(!value["Type"].isNull())
productExtrasObject.type = value["Type"].asString();
productExtras_.push_back(productExtrasObject);
}
auto shopInfoNode = value["ShopInfo"];
if(!shopInfoNode["Id"].isNull())
shopInfo_.id = std::stol(shopInfoNode["Id"].asString());
if(!shopInfoNode["Name"].isNull())
shopInfo_.name = shopInfoNode["Name"].asString();
if(!shopInfoNode["Emails"].isNull())
shopInfo_.emails = shopInfoNode["Emails"].asString();
auto allWangWangs = value["WangWangs"]["WangWang"];
for (auto value : allWangWangs)
{
ShopInfo::WangWang wangWangObject;
if(!value["UserName"].isNull())
wangWangObject.userName = value["UserName"].asString();
if(!value["Remark"].isNull())
wangWangObject.remark = value["Remark"].asString();
shopInfo_.wangWangs.push_back(wangWangObject);
}
auto allTelephones = shopInfoNode["Telephones"]["Telephone"];
for (auto value : allTelephones)
shopInfo_.telephones.push_back(value.asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["Type"].isNull())
type_ = value["Type"].asString();
if(!value["PicUrl"].isNull())
picUrl_ = value["PicUrl"].asString();
if(!value["Description"].isNull())
description_ = value["Description"].asString();
if(!value["ShortDescription"].isNull())
shortDescription_ = value["ShortDescription"].asString();
if(!value["UseCount"].isNull())
useCount_ = std::stol(value["UseCount"].asString());
if(!value["Score"].isNull())
score_ = std::stof(value["Score"].asString());
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["AuditStatus"].isNull())
auditStatus_ = value["AuditStatus"].asString();
if(!value["AuditFailMsg"].isNull())
auditFailMsg_ = value["AuditFailMsg"].asString();
if(!value["AuditTime"].isNull())
auditTime_ = std::stol(value["AuditTime"].asString());
if(!value["GmtCreated"].isNull())
gmtCreated_ = std::stol(value["GmtCreated"].asString());
if(!value["GmtModified"].isNull())
gmtModified_ = std::stol(value["GmtModified"].asString());
}
std::string DescribeProductResult::getStatus()const
{
return status_;
}
std::string DescribeProductResult::getDescription()const
{
return description_;
}
DescribeProductResult::ShopInfo DescribeProductResult::getShopInfo()const
{
return shopInfo_;
}
std::vector<DescribeProductResult::ProductSku> DescribeProductResult::getProductSkus()const
{
return productSkus_;
}
long DescribeProductResult::getUseCount()const
{
return useCount_;
}
long DescribeProductResult::getGmtModified()const
{
return gmtModified_;
}
long DescribeProductResult::getGmtCreated()const
{
return gmtCreated_;
}
std::string DescribeProductResult::getCode()const
{
return code_;
}
std::string DescribeProductResult::getName()const
{
return name_;
}
std::string DescribeProductResult::getShortDescription()const
{
return shortDescription_;
}
std::string DescribeProductResult::getType()const
{
return type_;
}
float DescribeProductResult::getScore()const
{
return score_;
}
std::string DescribeProductResult::getAuditStatus()const
{
return auditStatus_;
}
std::string DescribeProductResult::getAuditFailMsg()const
{
return auditFailMsg_;
}
std::vector<DescribeProductResult::ProductExtra> DescribeProductResult::getProductExtras()const
{
return productExtras_;
}
long DescribeProductResult::getAuditTime()const
{
return auditTime_;
}
std::string DescribeProductResult::getPicUrl()const
{
return picUrl_;
}

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/market/model/DescribeProductsRequest.h>
using AlibabaCloud::Market::Model::DescribeProductsRequest;
DescribeProductsRequest::DescribeProductsRequest() :
RpcServiceRequest("market", "2015-11-01", "DescribeProducts")
{}
DescribeProductsRequest::~DescribeProductsRequest()
{}
std::vector<DescribeProductsRequest::Filter> DescribeProductsRequest::getFilter()const
{
return filter_;
}
void DescribeProductsRequest::setFilter(const std::vector<Filter>& filter)
{
filter_ = filter;
int i = 0;
for(int i = 0; i!= filter.size(); i++) {
auto obj = filter.at(i);
std::string str ="Filter."+ std::to_string(i);
setCoreParameter(str + ".Value", obj.value);
setCoreParameter(str + ".Key", obj.key);
}
}
std::string DescribeProductsRequest::getSearchTerm()const
{
return searchTerm_;
}
void DescribeProductsRequest::setSearchTerm(const std::string& searchTerm)
{
searchTerm_ = searchTerm;
setCoreParameter("SearchTerm", searchTerm);
}
int DescribeProductsRequest::getPageSize()const
{
return pageSize_;
}
void DescribeProductsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
int DescribeProductsRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeProductsRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setCoreParameter("PageNumber", std::to_string(pageNumber));
}

View File

@@ -0,0 +1,106 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/DescribeProductsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
DescribeProductsResult::DescribeProductsResult() :
ServiceResult()
{}
DescribeProductsResult::DescribeProductsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeProductsResult::~DescribeProductsResult()
{}
void DescribeProductsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allProductItems = value["ProductItems"]["ProductItem"];
for (auto value : allProductItems)
{
ProductItem productItemsObject;
if(!value["Code"].isNull())
productItemsObject.code = value["Code"].asString();
if(!value["Name"].isNull())
productItemsObject.name = value["Name"].asString();
if(!value["CategoryId"].isNull())
productItemsObject.categoryId = std::stol(value["CategoryId"].asString());
if(!value["SupplierId"].isNull())
productItemsObject.supplierId = std::stol(value["SupplierId"].asString());
if(!value["SupplierName"].isNull())
productItemsObject.supplierName = value["SupplierName"].asString();
if(!value["ShortDescription"].isNull())
productItemsObject.shortDescription = value["ShortDescription"].asString();
if(!value["Tags"].isNull())
productItemsObject.tags = value["Tags"].asString();
if(!value["SuggestedPrice"].isNull())
productItemsObject.suggestedPrice = value["SuggestedPrice"].asString();
if(!value["TargetUrl"].isNull())
productItemsObject.targetUrl = value["TargetUrl"].asString();
if(!value["ImageUrl"].isNull())
productItemsObject.imageUrl = value["ImageUrl"].asString();
if(!value["Score"].isNull())
productItemsObject.score = value["Score"].asString();
if(!value["OperationSystem"].isNull())
productItemsObject.operationSystem = value["OperationSystem"].asString();
if(!value["WarrantyDate"].isNull())
productItemsObject.warrantyDate = value["WarrantyDate"].asString();
if(!value["DeliveryDate"].isNull())
productItemsObject.deliveryDate = value["DeliveryDate"].asString();
if(!value["DeliveryWay"].isNull())
productItemsObject.deliveryWay = value["DeliveryWay"].asString();
productItems_.push_back(productItemsObject);
}
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
int DescribeProductsResult::getTotalCount()const
{
return totalCount_;
}
int DescribeProductsResult::getPageSize()const
{
return pageSize_;
}
int DescribeProductsResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescribeProductsResult::ProductItem> DescribeProductsResult::getProductItems()const
{
return productItems_;
}

View File

@@ -0,0 +1,38 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/DescribeRateRequest.h>
using AlibabaCloud::Market::Model::DescribeRateRequest;
DescribeRateRequest::DescribeRateRequest() :
RpcServiceRequest("market", "2015-11-01", "DescribeRate")
{}
DescribeRateRequest::~DescribeRateRequest()
{}
std::string DescribeRateRequest::getOrderId()const
{
return orderId_;
}
void DescribeRateRequest::setOrderId(const std::string& orderId)
{
orderId_ = orderId;
setCoreParameter("OrderId", orderId);
}

View File

@@ -0,0 +1,149 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/DescribeRateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
DescribeRateResult::DescribeRateResult() :
ServiceResult()
{}
DescribeRateResult::DescribeRateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeRateResult::~DescribeRateResult()
{}
void DescribeRateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Id"].isNull())
id_ = std::stol(value["Id"].asString());
if(!value["OrderId"].isNull())
orderId_ = value["OrderId"].asString();
if(!value["InstanceId"].isNull())
instanceId_ = value["InstanceId"].asString();
if(!value["AliUid"].isNull())
aliUid_ = std::stol(value["AliUid"].asString());
if(!value["ProductId"].isNull())
productId_ = value["ProductId"].asString();
if(!value["Score"].isNull())
score_ = value["Score"].asString();
if(!value["Content"].isNull())
content_ = value["Content"].asString();
if(!value["GmtCreated"].isNull())
gmtCreated_ = std::stol(value["GmtCreated"].asString());
if(!value["Explaintion"].isNull())
explaintion_ = value["Explaintion"].asString();
if(!value["GmtExplaintion"].isNull())
gmtExplaintion_ = std::stol(value["GmtExplaintion"].asString());
if(!value["AdditionalContent"].isNull())
additionalContent_ = value["AdditionalContent"].asString();
if(!value["GmtAdditional"].isNull())
gmtAdditional_ = std::stol(value["GmtAdditional"].asString());
if(!value["AdditionalExplaintion"].isNull())
additionalExplaintion_ = value["AdditionalExplaintion"].asString();
if(!value["GmtAdditionalExplaintion"].isNull())
gmtAdditionalExplaintion_ = std::stol(value["GmtAdditionalExplaintion"].asString());
if(!value["Type"].isNull())
type_ = value["Type"].asString();
}
std::string DescribeRateResult::getInstanceId()const
{
return instanceId_;
}
std::string DescribeRateResult::getExplaintion()const
{
return explaintion_;
}
long DescribeRateResult::getGmtExplaintion()const
{
return gmtExplaintion_;
}
std::string DescribeRateResult::getProductId()const
{
return productId_;
}
long DescribeRateResult::getGmtCreated()const
{
return gmtCreated_;
}
std::string DescribeRateResult::getAdditionalContent()const
{
return additionalContent_;
}
std::string DescribeRateResult::getOrderId()const
{
return orderId_;
}
long DescribeRateResult::getGmtAdditionalExplaintion()const
{
return gmtAdditionalExplaintion_;
}
std::string DescribeRateResult::getScore()const
{
return score_;
}
std::string DescribeRateResult::getType()const
{
return type_;
}
std::string DescribeRateResult::getContent()const
{
return content_;
}
std::string DescribeRateResult::getAdditionalExplaintion()const
{
return additionalExplaintion_;
}
long DescribeRateResult::getId()const
{
return id_;
}
long DescribeRateResult::getGmtAdditional()const
{
return gmtAdditional_;
}
long DescribeRateResult::getAliUid()const
{
return aliUid_;
}

View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/NotifyContractEventRequest.h>
using AlibabaCloud::Market::Model::NotifyContractEventRequest;
NotifyContractEventRequest::NotifyContractEventRequest() :
RpcServiceRequest("market", "2015-11-01", "NotifyContractEvent")
{}
NotifyContractEventRequest::~NotifyContractEventRequest()
{}
std::string NotifyContractEventRequest::getEventMessage()const
{
return eventMessage_;
}
void NotifyContractEventRequest::setEventMessage(const std::string& eventMessage)
{
eventMessage_ = eventMessage;
setCoreParameter("EventMessage", eventMessage);
}
std::string NotifyContractEventRequest::getEventType()const
{
return eventType_;
}
void NotifyContractEventRequest::setEventType(const std::string& eventType)
{
eventType_ = eventType;
setCoreParameter("EventType", eventType);
}

View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/NotifyContractEventResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
NotifyContractEventResult::NotifyContractEventResult() :
ServiceResult()
{}
NotifyContractEventResult::NotifyContractEventResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
NotifyContractEventResult::~NotifyContractEventResult()
{}
void NotifyContractEventResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool NotifyContractEventResult::getSuccess()const
{
return success_;
}

View File

@@ -0,0 +1,38 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/PushMeteringDataRequest.h>
using AlibabaCloud::Market::Model::PushMeteringDataRequest;
PushMeteringDataRequest::PushMeteringDataRequest() :
RpcServiceRequest("market", "2015-11-01", "PushMeteringData")
{}
PushMeteringDataRequest::~PushMeteringDataRequest()
{}
std::string PushMeteringDataRequest::getMetering()const
{
return metering_;
}
void PushMeteringDataRequest::setMetering(const std::string& metering)
{
metering_ = metering;
setCoreParameter("Metering", metering);
}

View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/PushMeteringDataResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
PushMeteringDataResult::PushMeteringDataResult() :
ServiceResult()
{}
PushMeteringDataResult::PushMeteringDataResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
PushMeteringDataResult::~PushMeteringDataResult()
{}
void PushMeteringDataResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool PushMeteringDataResult::getSuccess()const
{
return success_;
}

View File

@@ -0,0 +1,38 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/QueryMarketCategoriesRequest.h>
using AlibabaCloud::Market::Model::QueryMarketCategoriesRequest;
QueryMarketCategoriesRequest::QueryMarketCategoriesRequest() :
RpcServiceRequest("market", "2015-11-01", "QueryMarketCategories")
{}
QueryMarketCategoriesRequest::~QueryMarketCategoriesRequest()
{}
std::string QueryMarketCategoriesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void QueryMarketCategoriesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}

View File

@@ -0,0 +1,94 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/QueryMarketCategoriesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
QueryMarketCategoriesResult::QueryMarketCategoriesResult() :
ServiceResult()
{}
QueryMarketCategoriesResult::QueryMarketCategoriesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
QueryMarketCategoriesResult::~QueryMarketCategoriesResult()
{}
void QueryMarketCategoriesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allCategories = value["Categories"]["Category"];
for (auto value : allCategories)
{
Category categoriesObject;
if(!value["Id"].isNull())
categoriesObject.id = std::stol(value["Id"].asString());
if(!value["CategoryCode"].isNull())
categoriesObject.categoryCode = value["CategoryCode"].asString();
if(!value["CategoryName"].isNull())
categoriesObject.categoryName = value["CategoryName"].asString();
auto allChildCategories = value["ChildCategories"]["ChildCategory"];
for (auto value : allChildCategories)
{
Category::ChildCategory childCategoriesObject;
if(!value["Id"].isNull())
childCategoriesObject.id = std::stol(value["Id"].asString());
if(!value["CategoryCode"].isNull())
childCategoriesObject.categoryCode = value["CategoryCode"].asString();
if(!value["CategoryName"].isNull())
childCategoriesObject.categoryName = value["CategoryName"].asString();
categoriesObject.childCategories.push_back(childCategoriesObject);
}
categories_.push_back(categoriesObject);
}
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
int QueryMarketCategoriesResult::getTotalCount()const
{
return totalCount_;
}
int QueryMarketCategoriesResult::getPageSize()const
{
return pageSize_;
}
std::vector<QueryMarketCategoriesResult::Category> QueryMarketCategoriesResult::getCategories()const
{
return categories_;
}
int QueryMarketCategoriesResult::getPageNumber()const
{
return pageNumber_;
}

View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/QueryMarketImagesRequest.h>
using AlibabaCloud::Market::Model::QueryMarketImagesRequest;
QueryMarketImagesRequest::QueryMarketImagesRequest() :
RpcServiceRequest("market", "2015-11-01", "QueryMarketImages")
{}
QueryMarketImagesRequest::~QueryMarketImagesRequest()
{}
std::string QueryMarketImagesRequest::getParam()const
{
return param_;
}
void QueryMarketImagesRequest::setParam(const std::string& param)
{
param_ = param;
setCoreParameter("Param", param);
}
std::string QueryMarketImagesRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void QueryMarketImagesRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setCoreParameter("AccessKeyId", accessKeyId);
}

View File

@@ -0,0 +1,191 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/QueryMarketImagesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
QueryMarketImagesResult::QueryMarketImagesResult() :
ServiceResult()
{}
QueryMarketImagesResult::QueryMarketImagesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
QueryMarketImagesResult::~QueryMarketImagesResult()
{}
void QueryMarketImagesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allResult = value["Result"]["ImageProduct"];
for (auto value : allResult)
{
ImageProduct resultObject;
if(!value["ImageProductCode"].isNull())
resultObject.imageProductCode = value["ImageProductCode"].asString();
if(!value["ProductName"].isNull())
resultObject.productName = value["ProductName"].asString();
if(!value["CategoryName"].isNull())
resultObject.categoryName = value["CategoryName"].asString();
if(!value["SupplierName"].isNull())
resultObject.supplierName = value["SupplierName"].asString();
if(!value["BaseSystem"].isNull())
resultObject.baseSystem = value["BaseSystem"].asString();
if(!value["OsKind"].isNull())
resultObject.osKind = value["OsKind"].asString();
if(!value["OsBit"].isNull())
resultObject.osBit = std::stoi(value["OsBit"].asString());
if(!value["PictureUrl"].isNull())
resultObject.pictureUrl = value["PictureUrl"].asString();
if(!value["SmallPicUrl"].isNull())
resultObject.smallPicUrl = value["SmallPicUrl"].asString();
if(!value["ShortDescription"].isNull())
resultObject.shortDescription = value["ShortDescription"].asString();
if(!value["AgreementUrl"].isNull())
resultObject.agreementUrl = value["AgreementUrl"].asString();
if(!value["DetailUrl"].isNull())
resultObject.detailUrl = value["DetailUrl"].asString();
if(!value["BuyUrl"].isNull())
resultObject.buyUrl = value["BuyUrl"].asString();
if(!value["StoreUrl"].isNull())
resultObject.storeUrl = value["StoreUrl"].asString();
if(!value["Score"].isNull())
resultObject.score = std::stof(value["Score"].asString());
if(!value["UserCount"].isNull())
resultObject.userCount = std::stol(value["UserCount"].asString());
if(!value["SupportIO"].isNull())
resultObject.supportIO = value["SupportIO"].asString() == "true";
if(!value["CreatedOn"].isNull())
resultObject.createdOn = std::stol(value["CreatedOn"].asString());
auto allImages = value["Images"]["Image"];
for (auto value : allImages)
{
ImageProduct::Image imagesObject;
if(!value["Version"].isNull())
imagesObject.version = value["Version"].asString();
if(!value["VersionDescription"].isNull())
imagesObject.versionDescription = value["VersionDescription"].asString();
if(!value["ImageId"].isNull())
imagesObject.imageId = value["ImageId"].asString();
if(!value["ImageSize"].isNull())
imagesObject.imageSize = std::stoi(value["ImageSize"].asString());
if(!value["Region"].isNull())
imagesObject.region = value["Region"].asString();
if(!value["IsDefault"].isNull())
imagesObject.isDefault = value["IsDefault"].asString() == "true";
if(!value["SupportIO"].isNull())
imagesObject.supportIO = value["SupportIO"].asString() == "true";
auto allDiskDeviceMappings = value["DiskDeviceMappings"]["DiskDeviceMapping"];
for (auto value : allDiskDeviceMappings)
{
ImageProduct::Image::DiskDeviceMapping diskDeviceMappingsObject;
if(!value["DiskType"].isNull())
diskDeviceMappingsObject.diskType = value["DiskType"].asString();
if(!value["Format"].isNull())
diskDeviceMappingsObject.format = value["Format"].asString();
if(!value["SnapshotId"].isNull())
diskDeviceMappingsObject.snapshotId = value["SnapshotId"].asString();
if(!value["Size"].isNull())
diskDeviceMappingsObject.size = std::stoi(value["Size"].asString());
if(!value["Device"].isNull())
diskDeviceMappingsObject.device = value["Device"].asString();
if(!value["ImportOSSBucket"].isNull())
diskDeviceMappingsObject.importOSSBucket = value["ImportOSSBucket"].asString();
if(!value["ImportOSSObject"].isNull())
diskDeviceMappingsObject.importOSSObject = value["ImportOSSObject"].asString();
imagesObject.diskDeviceMappings.push_back(diskDeviceMappingsObject);
}
resultObject.images.push_back(imagesObject);
}
auto quotaNode = value["Quota"];
if(!quotaNode["TotalQuota"].isNull())
resultObject.quota.totalQuota = std::stol(quotaNode["TotalQuota"].asString());
if(!quotaNode["UsingQuota"].isNull())
resultObject.quota.usingQuota = std::stol(quotaNode["UsingQuota"].asString());
if(!quotaNode["UnusedQuota"].isNull())
resultObject.quota.unusedQuota = std::stol(quotaNode["UnusedQuota"].asString());
auto priceInfoNode = value["PriceInfo"];
auto allRules = value["Rules"]["Rule"];
for (auto value : allRules)
{
ImageProduct::PriceInfo::Rule ruleObject;
if(!value["RuleId"].isNull())
ruleObject.ruleId = std::stol(value["RuleId"].asString());
if(!value["Title"].isNull())
ruleObject.title = value["Title"].asString();
if(!value["Name"].isNull())
ruleObject.name = value["Name"].asString();
resultObject.priceInfo.rules.push_back(ruleObject);
}
auto orderNode = priceInfoNode["Order"];
if(!orderNode["OriginalPrice"].isNull())
resultObject.priceInfo.order.originalPrice = std::stof(orderNode["OriginalPrice"].asString());
if(!orderNode["DiscountPrice"].isNull())
resultObject.priceInfo.order.discountPrice = std::stof(orderNode["DiscountPrice"].asString());
if(!orderNode["TradePrice"].isNull())
resultObject.priceInfo.order.tradePrice = std::stof(orderNode["TradePrice"].asString());
if(!orderNode["Currency"].isNull())
resultObject.priceInfo.order.currency = orderNode["Currency"].asString();
if(!orderNode["Period"].isNull())
resultObject.priceInfo.order.period = std::stoi(orderNode["Period"].asString());
if(!orderNode["PriceUnit"].isNull())
resultObject.priceInfo.order.priceUnit = orderNode["PriceUnit"].asString();
auto allRuleIdSet = orderNode["RuleIdSet"]["RuleId"];
for (auto value : allRuleIdSet)
resultObject.priceInfo.order.ruleIdSet.push_back(value.asString());
auto allSkuCodes = value["SkuCodes"]["SkuCode"];
for (auto value : allSkuCodes)
resultObject.skuCodes.push_back(value.asString());
result_.push_back(resultObject);
}
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}
int QueryMarketImagesResult::getTotalCount()const
{
return totalCount_;
}
int QueryMarketImagesResult::getPageSize()const
{
return pageSize_;
}
int QueryMarketImagesResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<QueryMarketImagesResult::ImageProduct> QueryMarketImagesResult::getResult()const
{
return result_;
}

View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/UpdateCommodityRequest.h>
using AlibabaCloud::Market::Model::UpdateCommodityRequest;
UpdateCommodityRequest::UpdateCommodityRequest() :
RpcServiceRequest("market", "2015-11-01", "UpdateCommodity")
{}
UpdateCommodityRequest::~UpdateCommodityRequest()
{}
std::string UpdateCommodityRequest::getCommodityId()const
{
return commodityId_;
}
void UpdateCommodityRequest::setCommodityId(const std::string& commodityId)
{
commodityId_ = commodityId;
setCoreParameter("CommodityId", commodityId);
}
std::string UpdateCommodityRequest::getContent()const
{
return content_;
}
void UpdateCommodityRequest::setContent(const std::string& content)
{
content_ = content;
setCoreParameter("Content", content);
}

View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/UpdateCommodityResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
UpdateCommodityResult::UpdateCommodityResult() :
ServiceResult()
{}
UpdateCommodityResult::UpdateCommodityResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateCommodityResult::~UpdateCommodityResult()
{}
void UpdateCommodityResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool UpdateCommodityResult::getSuccess()const
{
return success_;
}

View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/market/model/UploadCommodityFileRequest.h>
using AlibabaCloud::Market::Model::UploadCommodityFileRequest;
UploadCommodityFileRequest::UploadCommodityFileRequest() :
RpcServiceRequest("market", "2015-11-01", "UploadCommodityFile")
{}
UploadCommodityFileRequest::~UploadCommodityFileRequest()
{}
std::string UploadCommodityFileRequest::getFileResourceType()const
{
return fileResourceType_;
}
void UploadCommodityFileRequest::setFileResourceType(const std::string& fileResourceType)
{
fileResourceType_ = fileResourceType;
setCoreParameter("FileResourceType", fileResourceType);
}
std::string UploadCommodityFileRequest::getFileResource()const
{
return fileResource_;
}
void UploadCommodityFileRequest::setFileResource(const std::string& fileResource)
{
fileResource_ = fileResource;
setCoreParameter("FileResource", fileResource);
}
std::string UploadCommodityFileRequest::getFileContentType()const
{
return fileContentType_;
}
void UploadCommodityFileRequest::setFileContentType(const std::string& fileContentType)
{
fileContentType_ = fileContentType;
setCoreParameter("FileContentType", fileContentType);
}

View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/market/model/UploadCommodityFileResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Market;
using namespace AlibabaCloud::Market::Model;
UploadCommodityFileResult::UploadCommodityFileResult() :
ServiceResult()
{}
UploadCommodityFileResult::UploadCommodityFileResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UploadCommodityFileResult::~UploadCommodityFileResult()
{}
void UploadCommodityFileResult::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["ResourceType"].isNull())
data_.resourceType = dataNode["ResourceType"].asString();
if(!dataNode["Resource"].isNull())
data_.resource = dataNode["Resource"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
UploadCommodityFileResult::Data UploadCommodityFileResult::getData()const
{
return data_;
}
bool UploadCommodityFileResult::getSuccess()const
{
return success_;
}