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

regenerate code

Browse Source
This commit is contained in:
wb-hx510875
2020-03-26 17:27:13 +08:00
committed by Axios
parent cba94f2119
commit f0c2600a26
6249 changed files with 188711 additions and 43443 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
trademark/CMakeLists.txt
View File

@@ -21,6 +21,8 @@ set(trademark_public_header
include/alibabacloud/trademark/TrademarkExport.h )
set(trademark_public_header_model
include/alibabacloud/trademark/model/AcceptPartnerNotificationRequest.h
include/alibabacloud/trademark/model/AcceptPartnerNotificationResult.h
include/alibabacloud/trademark/model/ApplyNotaryPostRequest.h
include/alibabacloud/trademark/model/ApplyNotaryPostResult.h
include/alibabacloud/trademark/model/BindMaterialRequest.h
@@ -29,8 +31,14 @@ set(trademark_public_header_model
include/alibabacloud/trademark/model/CancelTradeOrderResult.h
include/alibabacloud/trademark/model/CheckLoaFillRequest.h
include/alibabacloud/trademark/model/CheckLoaFillResult.h
include/alibabacloud/trademark/model/CheckTrademarkOrderRequest.h
include/alibabacloud/trademark/model/CheckTrademarkOrderResult.h
include/alibabacloud/trademark/model/CombineLoaRequest.h
include/alibabacloud/trademark/model/CombineLoaResult.h
include/alibabacloud/trademark/model/ConfirmAdditionalMaterialRequest.h
include/alibabacloud/trademark/model/ConfirmAdditionalMaterialResult.h
include/alibabacloud/trademark/model/ConfirmApplicantRequest.h
include/alibabacloud/trademark/model/ConfirmApplicantResult.h
include/alibabacloud/trademark/model/ConvertImageToGrayRequest.h
include/alibabacloud/trademark/model/ConvertImageToGrayResult.h
include/alibabacloud/trademark/model/CreateIntentionOrderRequest.h
@@ -43,6 +51,8 @@ set(trademark_public_header_model
include/alibabacloud/trademark/model/DeleteTmMonitorRuleResult.h
include/alibabacloud/trademark/model/DenySupplementRequest.h
include/alibabacloud/trademark/model/DenySupplementResult.h
include/alibabacloud/trademark/model/DescirbeCombineTrademarkRequest.h
include/alibabacloud/trademark/model/DescirbeCombineTrademarkResult.h
include/alibabacloud/trademark/model/FillLogisticsRequest.h
include/alibabacloud/trademark/model/FillLogisticsResult.h
include/alibabacloud/trademark/model/FilterUnavailableCodesRequest.h
@@ -73,12 +83,16 @@ set(trademark_public_header_model
include/alibabacloud/trademark/model/QueryIntentionDetailResult.h
include/alibabacloud/trademark/model/QueryIntentionListRequest.h
include/alibabacloud/trademark/model/QueryIntentionListResult.h
include/alibabacloud/trademark/model/QueryIntentionPriceRequest.h
include/alibabacloud/trademark/model/QueryIntentionPriceResult.h
include/alibabacloud/trademark/model/QueryMaterialRequest.h
include/alibabacloud/trademark/model/QueryMaterialResult.h
include/alibabacloud/trademark/model/QueryMaterialListRequest.h
include/alibabacloud/trademark/model/QueryMaterialListResult.h
include/alibabacloud/trademark/model/QueryMonitorKeywordsRequest.h
include/alibabacloud/trademark/model/QueryMonitorKeywordsResult.h
include/alibabacloud/trademark/model/QueryOfficialFileCustomListRequest.h
include/alibabacloud/trademark/model/QueryOfficialFileCustomListResult.h
include/alibabacloud/trademark/model/QueryOssResourcesRequest.h
include/alibabacloud/trademark/model/QueryOssResourcesResult.h
include/alibabacloud/trademark/model/QueryQrCodeUploadStatusRequest.h
@@ -109,8 +123,20 @@ set(trademark_public_header_model
include/alibabacloud/trademark/model/QueryTrademarkPriceResult.h
include/alibabacloud/trademark/model/RefundProduceRequest.h
include/alibabacloud/trademark/model/RefundProduceResult.h
include/alibabacloud/trademark/model/RefuseAdditionalMaterialRequest.h
include/alibabacloud/trademark/model/RefuseAdditionalMaterialResult.h
include/alibabacloud/trademark/model/RefuseApplicantRequest.h
include/alibabacloud/trademark/model/RefuseApplicantResult.h
include/alibabacloud/trademark/model/RejectApplicantRequest.h
include/alibabacloud/trademark/model/RejectApplicantResult.h
include/alibabacloud/trademark/model/SaveTaskRequest.h
include/alibabacloud/trademark/model/SaveTaskResult.h
include/alibabacloud/trademark/model/SaveTaskForOfficialFileCustomRequest.h
include/alibabacloud/trademark/model/SaveTaskForOfficialFileCustomResult.h
include/alibabacloud/trademark/model/SaveTradeMarkReviewMaterialDetailRequest.h
include/alibabacloud/trademark/model/SaveTradeMarkReviewMaterialDetailResult.h
include/alibabacloud/trademark/model/SearchTmOnsalesRequest.h
include/alibabacloud/trademark/model/SearchTmOnsalesResult.h
include/alibabacloud/trademark/model/StartNotaryRequest.h
include/alibabacloud/trademark/model/StartNotaryResult.h
include/alibabacloud/trademark/model/StoreMaterialTemporarilyRequest.h
@@ -132,6 +158,8 @@ set(trademark_public_header_model
set(trademark_src
src/TrademarkClient.cc
src/model/AcceptPartnerNotificationRequest.cc
src/model/AcceptPartnerNotificationResult.cc
src/model/ApplyNotaryPostRequest.cc
src/model/ApplyNotaryPostResult.cc
src/model/BindMaterialRequest.cc
@@ -140,8 +168,14 @@ set(trademark_src
src/model/CancelTradeOrderResult.cc
src/model/CheckLoaFillRequest.cc
src/model/CheckLoaFillResult.cc
src/model/CheckTrademarkOrderRequest.cc
src/model/CheckTrademarkOrderResult.cc
src/model/CombineLoaRequest.cc
src/model/CombineLoaResult.cc
src/model/ConfirmAdditionalMaterialRequest.cc
src/model/ConfirmAdditionalMaterialResult.cc
src/model/ConfirmApplicantRequest.cc
src/model/ConfirmApplicantResult.cc
src/model/ConvertImageToGrayRequest.cc
src/model/ConvertImageToGrayResult.cc
src/model/CreateIntentionOrderRequest.cc
@@ -154,6 +188,8 @@ set(trademark_src
src/model/DeleteTmMonitorRuleResult.cc
src/model/DenySupplementRequest.cc
src/model/DenySupplementResult.cc
src/model/DescirbeCombineTrademarkRequest.cc
src/model/DescirbeCombineTrademarkResult.cc
src/model/FillLogisticsRequest.cc
src/model/FillLogisticsResult.cc
src/model/FilterUnavailableCodesRequest.cc
@@ -184,12 +220,16 @@ set(trademark_src
src/model/QueryIntentionDetailResult.cc
src/model/QueryIntentionListRequest.cc
src/model/QueryIntentionListResult.cc
src/model/QueryIntentionPriceRequest.cc
src/model/QueryIntentionPriceResult.cc
src/model/QueryMaterialRequest.cc
src/model/QueryMaterialResult.cc
src/model/QueryMaterialListRequest.cc
src/model/QueryMaterialListResult.cc
src/model/QueryMonitorKeywordsRequest.cc
src/model/QueryMonitorKeywordsResult.cc
src/model/QueryOfficialFileCustomListRequest.cc
src/model/QueryOfficialFileCustomListResult.cc
src/model/QueryOssResourcesRequest.cc
src/model/QueryOssResourcesResult.cc
src/model/QueryQrCodeUploadStatusRequest.cc
@@ -220,8 +260,20 @@ set(trademark_src
src/model/QueryTrademarkPriceResult.cc
src/model/RefundProduceRequest.cc
src/model/RefundProduceResult.cc
src/model/RefuseAdditionalMaterialRequest.cc
src/model/RefuseAdditionalMaterialResult.cc
src/model/RefuseApplicantRequest.cc
src/model/RefuseApplicantResult.cc
src/model/RejectApplicantRequest.cc
src/model/RejectApplicantResult.cc
src/model/SaveTaskRequest.cc
src/model/SaveTaskResult.cc
src/model/SaveTaskForOfficialFileCustomRequest.cc
src/model/SaveTaskForOfficialFileCustomResult.cc
src/model/SaveTradeMarkReviewMaterialDetailRequest.cc
src/model/SaveTradeMarkReviewMaterialDetailResult.cc
src/model/SearchTmOnsalesRequest.cc
src/model/SearchTmOnsalesResult.cc
src/model/StartNotaryRequest.cc
src/model/StartNotaryResult.cc
src/model/StoreMaterialTemporarilyRequest.cc

104
trademark/include/alibabacloud/trademark/TrademarkClient.h
View File

@@ -22,6 +22,8 @@
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "TrademarkExport.h"
#include "model/AcceptPartnerNotificationRequest.h"
#include "model/AcceptPartnerNotificationResult.h"
#include "model/ApplyNotaryPostRequest.h"
#include "model/ApplyNotaryPostResult.h"
#include "model/BindMaterialRequest.h"
@@ -30,8 +32,14 @@
#include "model/CancelTradeOrderResult.h"
#include "model/CheckLoaFillRequest.h"
#include "model/CheckLoaFillResult.h"
#include "model/CheckTrademarkOrderRequest.h"
#include "model/CheckTrademarkOrderResult.h"
#include "model/CombineLoaRequest.h"
#include "model/CombineLoaResult.h"
#include "model/ConfirmAdditionalMaterialRequest.h"
#include "model/ConfirmAdditionalMaterialResult.h"
#include "model/ConfirmApplicantRequest.h"
#include "model/ConfirmApplicantResult.h"
#include "model/ConvertImageToGrayRequest.h"
#include "model/ConvertImageToGrayResult.h"
#include "model/CreateIntentionOrderRequest.h"
@@ -44,6 +52,8 @@
#include "model/DeleteTmMonitorRuleResult.h"
#include "model/DenySupplementRequest.h"
#include "model/DenySupplementResult.h"
#include "model/DescirbeCombineTrademarkRequest.h"
#include "model/DescirbeCombineTrademarkResult.h"
#include "model/FillLogisticsRequest.h"
#include "model/FillLogisticsResult.h"
#include "model/FilterUnavailableCodesRequest.h"
@@ -74,12 +84,16 @@
#include "model/QueryIntentionDetailResult.h"
#include "model/QueryIntentionListRequest.h"
#include "model/QueryIntentionListResult.h"
#include "model/QueryIntentionPriceRequest.h"
#include "model/QueryIntentionPriceResult.h"
#include "model/QueryMaterialRequest.h"
#include "model/QueryMaterialResult.h"
#include "model/QueryMaterialListRequest.h"
#include "model/QueryMaterialListResult.h"
#include "model/QueryMonitorKeywordsRequest.h"
#include "model/QueryMonitorKeywordsResult.h"
#include "model/QueryOfficialFileCustomListRequest.h"
#include "model/QueryOfficialFileCustomListResult.h"
#include "model/QueryOssResourcesRequest.h"
#include "model/QueryOssResourcesResult.h"
#include "model/QueryQrCodeUploadStatusRequest.h"
@@ -110,8 +124,20 @@
#include "model/QueryTrademarkPriceResult.h"
#include "model/RefundProduceRequest.h"
#include "model/RefundProduceResult.h"
#include "model/RefuseAdditionalMaterialRequest.h"
#include "model/RefuseAdditionalMaterialResult.h"
#include "model/RefuseApplicantRequest.h"
#include "model/RefuseApplicantResult.h"
#include "model/RejectApplicantRequest.h"
#include "model/RejectApplicantResult.h"
#include "model/SaveTaskRequest.h"
#include "model/SaveTaskResult.h"
#include "model/SaveTaskForOfficialFileCustomRequest.h"
#include "model/SaveTaskForOfficialFileCustomResult.h"
#include "model/SaveTradeMarkReviewMaterialDetailRequest.h"
#include "model/SaveTradeMarkReviewMaterialDetailResult.h"
#include "model/SearchTmOnsalesRequest.h"
#include "model/SearchTmOnsalesResult.h"
#include "model/StartNotaryRequest.h"
#include "model/StartNotaryResult.h"
#include "model/StoreMaterialTemporarilyRequest.h"
@@ -139,6 +165,9 @@ namespace AlibabaCloud
class ALIBABACLOUD_TRADEMARK_EXPORT TrademarkClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AcceptPartnerNotificationResult> AcceptPartnerNotificationOutcome;
typedef std::future<AcceptPartnerNotificationOutcome> AcceptPartnerNotificationOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::AcceptPartnerNotificationRequest&, const AcceptPartnerNotificationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AcceptPartnerNotificationAsyncHandler;
typedef Outcome<Error, Model::ApplyNotaryPostResult> ApplyNotaryPostOutcome;
typedef std::future<ApplyNotaryPostOutcome> ApplyNotaryPostOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::ApplyNotaryPostRequest&, const ApplyNotaryPostOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ApplyNotaryPostAsyncHandler;
@@ -151,9 +180,18 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CheckLoaFillResult> CheckLoaFillOutcome;
typedef std::future<CheckLoaFillOutcome> CheckLoaFillOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::CheckLoaFillRequest&, const CheckLoaFillOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckLoaFillAsyncHandler;
typedef Outcome<Error, Model::CheckTrademarkOrderResult> CheckTrademarkOrderOutcome;
typedef std::future<CheckTrademarkOrderOutcome> CheckTrademarkOrderOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::CheckTrademarkOrderRequest&, const CheckTrademarkOrderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckTrademarkOrderAsyncHandler;
typedef Outcome<Error, Model::CombineLoaResult> CombineLoaOutcome;
typedef std::future<CombineLoaOutcome> CombineLoaOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::CombineLoaRequest&, const CombineLoaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CombineLoaAsyncHandler;
typedef Outcome<Error, Model::ConfirmAdditionalMaterialResult> ConfirmAdditionalMaterialOutcome;
typedef std::future<ConfirmAdditionalMaterialOutcome> ConfirmAdditionalMaterialOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::ConfirmAdditionalMaterialRequest&, const ConfirmAdditionalMaterialOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConfirmAdditionalMaterialAsyncHandler;
typedef Outcome<Error, Model::ConfirmApplicantResult> ConfirmApplicantOutcome;
typedef std::future<ConfirmApplicantOutcome> ConfirmApplicantOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::ConfirmApplicantRequest&, const ConfirmApplicantOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConfirmApplicantAsyncHandler;
typedef Outcome<Error, Model::ConvertImageToGrayResult> ConvertImageToGrayOutcome;
typedef std::future<ConvertImageToGrayOutcome> ConvertImageToGrayOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::ConvertImageToGrayRequest&, const ConvertImageToGrayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConvertImageToGrayAsyncHandler;
@@ -172,6 +210,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DenySupplementResult> DenySupplementOutcome;
typedef std::future<DenySupplementOutcome> DenySupplementOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::DenySupplementRequest&, const DenySupplementOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DenySupplementAsyncHandler;
typedef Outcome<Error, Model::DescirbeCombineTrademarkResult> DescirbeCombineTrademarkOutcome;
typedef std::future<DescirbeCombineTrademarkOutcome> DescirbeCombineTrademarkOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::DescirbeCombineTrademarkRequest&, const DescirbeCombineTrademarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescirbeCombineTrademarkAsyncHandler;
typedef Outcome<Error, Model::FillLogisticsResult> FillLogisticsOutcome;
typedef std::future<FillLogisticsOutcome> FillLogisticsOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::FillLogisticsRequest&, const FillLogisticsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FillLogisticsAsyncHandler;
@@ -217,6 +258,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::QueryIntentionListResult> QueryIntentionListOutcome;
typedef std::future<QueryIntentionListOutcome> QueryIntentionListOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::QueryIntentionListRequest&, const QueryIntentionListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryIntentionListAsyncHandler;
typedef Outcome<Error, Model::QueryIntentionPriceResult> QueryIntentionPriceOutcome;
typedef std::future<QueryIntentionPriceOutcome> QueryIntentionPriceOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::QueryIntentionPriceRequest&, const QueryIntentionPriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryIntentionPriceAsyncHandler;
typedef Outcome<Error, Model::QueryMaterialResult> QueryMaterialOutcome;
typedef std::future<QueryMaterialOutcome> QueryMaterialOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::QueryMaterialRequest&, const QueryMaterialOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryMaterialAsyncHandler;
@@ -226,6 +270,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::QueryMonitorKeywordsResult> QueryMonitorKeywordsOutcome;
typedef std::future<QueryMonitorKeywordsOutcome> QueryMonitorKeywordsOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::QueryMonitorKeywordsRequest&, const QueryMonitorKeywordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryMonitorKeywordsAsyncHandler;
typedef Outcome<Error, Model::QueryOfficialFileCustomListResult> QueryOfficialFileCustomListOutcome;
typedef std::future<QueryOfficialFileCustomListOutcome> QueryOfficialFileCustomListOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::QueryOfficialFileCustomListRequest&, const QueryOfficialFileCustomListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryOfficialFileCustomListAsyncHandler;
typedef Outcome<Error, Model::QueryOssResourcesResult> QueryOssResourcesOutcome;
typedef std::future<QueryOssResourcesOutcome> QueryOssResourcesOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::QueryOssResourcesRequest&, const QueryOssResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryOssResourcesAsyncHandler;
@@ -271,9 +318,27 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::RefundProduceResult> RefundProduceOutcome;
typedef std::future<RefundProduceOutcome> RefundProduceOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::RefundProduceRequest&, const RefundProduceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RefundProduceAsyncHandler;
typedef Outcome<Error, Model::RefuseAdditionalMaterialResult> RefuseAdditionalMaterialOutcome;
typedef std::future<RefuseAdditionalMaterialOutcome> RefuseAdditionalMaterialOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::RefuseAdditionalMaterialRequest&, const RefuseAdditionalMaterialOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RefuseAdditionalMaterialAsyncHandler;
typedef Outcome<Error, Model::RefuseApplicantResult> RefuseApplicantOutcome;
typedef std::future<RefuseApplicantOutcome> RefuseApplicantOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::RefuseApplicantRequest&, const RefuseApplicantOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RefuseApplicantAsyncHandler;
typedef Outcome<Error, Model::RejectApplicantResult> RejectApplicantOutcome;
typedef std::future<RejectApplicantOutcome> RejectApplicantOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::RejectApplicantRequest&, const RejectApplicantOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RejectApplicantAsyncHandler;
typedef Outcome<Error, Model::SaveTaskResult> SaveTaskOutcome;
typedef std::future<SaveTaskOutcome> SaveTaskOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::SaveTaskRequest&, const SaveTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SaveTaskAsyncHandler;
typedef Outcome<Error, Model::SaveTaskForOfficialFileCustomResult> SaveTaskForOfficialFileCustomOutcome;
typedef std::future<SaveTaskForOfficialFileCustomOutcome> SaveTaskForOfficialFileCustomOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::SaveTaskForOfficialFileCustomRequest&, const SaveTaskForOfficialFileCustomOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SaveTaskForOfficialFileCustomAsyncHandler;
typedef Outcome<Error, Model::SaveTradeMarkReviewMaterialDetailResult> SaveTradeMarkReviewMaterialDetailOutcome;
typedef std::future<SaveTradeMarkReviewMaterialDetailOutcome> SaveTradeMarkReviewMaterialDetailOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::SaveTradeMarkReviewMaterialDetailRequest&, const SaveTradeMarkReviewMaterialDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SaveTradeMarkReviewMaterialDetailAsyncHandler;
typedef Outcome<Error, Model::SearchTmOnsalesResult> SearchTmOnsalesOutcome;
typedef std::future<SearchTmOnsalesOutcome> SearchTmOnsalesOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::SearchTmOnsalesRequest&, const SearchTmOnsalesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchTmOnsalesAsyncHandler;
typedef Outcome<Error, Model::StartNotaryResult> StartNotaryOutcome;
typedef std::future<StartNotaryOutcome> StartNotaryOutcomeCallable;
typedef std::function<void(const TrademarkClient*, const Model::StartNotaryRequest&, const StartNotaryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartNotaryAsyncHandler;
@@ -306,6 +371,9 @@ namespace AlibabaCloud
TrademarkClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
TrademarkClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~TrademarkClient();
AcceptPartnerNotificationOutcome acceptPartnerNotification(const Model::AcceptPartnerNotificationRequest &request)const;
void acceptPartnerNotificationAsync(const Model::AcceptPartnerNotificationRequest& request, const AcceptPartnerNotificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AcceptPartnerNotificationOutcomeCallable acceptPartnerNotificationCallable(const Model::AcceptPartnerNotificationRequest& request) const;
ApplyNotaryPostOutcome applyNotaryPost(const Model::ApplyNotaryPostRequest &request)const;
void applyNotaryPostAsync(const Model::ApplyNotaryPostRequest& request, const ApplyNotaryPostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ApplyNotaryPostOutcomeCallable applyNotaryPostCallable(const Model::ApplyNotaryPostRequest& request) const;
@@ -318,9 +386,18 @@ namespace AlibabaCloud
CheckLoaFillOutcome checkLoaFill(const Model::CheckLoaFillRequest &request)const;
void checkLoaFillAsync(const Model::CheckLoaFillRequest& request, const CheckLoaFillAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckLoaFillOutcomeCallable checkLoaFillCallable(const Model::CheckLoaFillRequest& request) const;
CheckTrademarkOrderOutcome checkTrademarkOrder(const Model::CheckTrademarkOrderRequest &request)const;
void checkTrademarkOrderAsync(const Model::CheckTrademarkOrderRequest& request, const CheckTrademarkOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckTrademarkOrderOutcomeCallable checkTrademarkOrderCallable(const Model::CheckTrademarkOrderRequest& request) const;
CombineLoaOutcome combineLoa(const Model::CombineLoaRequest &request)const;
void combineLoaAsync(const Model::CombineLoaRequest& request, const CombineLoaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CombineLoaOutcomeCallable combineLoaCallable(const Model::CombineLoaRequest& request) const;
ConfirmAdditionalMaterialOutcome confirmAdditionalMaterial(const Model::ConfirmAdditionalMaterialRequest &request)const;
void confirmAdditionalMaterialAsync(const Model::ConfirmAdditionalMaterialRequest& request, const ConfirmAdditionalMaterialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ConfirmAdditionalMaterialOutcomeCallable confirmAdditionalMaterialCallable(const Model::ConfirmAdditionalMaterialRequest& request) const;
ConfirmApplicantOutcome confirmApplicant(const Model::ConfirmApplicantRequest &request)const;
void confirmApplicantAsync(const Model::ConfirmApplicantRequest& request, const ConfirmApplicantAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ConfirmApplicantOutcomeCallable confirmApplicantCallable(const Model::ConfirmApplicantRequest& request) const;
ConvertImageToGrayOutcome convertImageToGray(const Model::ConvertImageToGrayRequest &request)const;
void convertImageToGrayAsync(const Model::ConvertImageToGrayRequest& request, const ConvertImageToGrayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ConvertImageToGrayOutcomeCallable convertImageToGrayCallable(const Model::ConvertImageToGrayRequest& request) const;
@@ -339,6 +416,9 @@ namespace AlibabaCloud
DenySupplementOutcome denySupplement(const Model::DenySupplementRequest &request)const;
void denySupplementAsync(const Model::DenySupplementRequest& request, const DenySupplementAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DenySupplementOutcomeCallable denySupplementCallable(const Model::DenySupplementRequest& request) const;
DescirbeCombineTrademarkOutcome descirbeCombineTrademark(const Model::DescirbeCombineTrademarkRequest &request)const;
void descirbeCombineTrademarkAsync(const Model::DescirbeCombineTrademarkRequest& request, const DescirbeCombineTrademarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescirbeCombineTrademarkOutcomeCallable descirbeCombineTrademarkCallable(const Model::DescirbeCombineTrademarkRequest& request) const;
FillLogisticsOutcome fillLogistics(const Model::FillLogisticsRequest &request)const;
void fillLogisticsAsync(const Model::FillLogisticsRequest& request, const FillLogisticsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FillLogisticsOutcomeCallable fillLogisticsCallable(const Model::FillLogisticsRequest& request) const;
@@ -384,6 +464,9 @@ namespace AlibabaCloud
QueryIntentionListOutcome queryIntentionList(const Model::QueryIntentionListRequest &request)const;
void queryIntentionListAsync(const Model::QueryIntentionListRequest& request, const QueryIntentionListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryIntentionListOutcomeCallable queryIntentionListCallable(const Model::QueryIntentionListRequest& request) const;
QueryIntentionPriceOutcome queryIntentionPrice(const Model::QueryIntentionPriceRequest &request)const;
void queryIntentionPriceAsync(const Model::QueryIntentionPriceRequest& request, const QueryIntentionPriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryIntentionPriceOutcomeCallable queryIntentionPriceCallable(const Model::QueryIntentionPriceRequest& request) const;
QueryMaterialOutcome queryMaterial(const Model::QueryMaterialRequest &request)const;
void queryMaterialAsync(const Model::QueryMaterialRequest& request, const QueryMaterialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryMaterialOutcomeCallable queryMaterialCallable(const Model::QueryMaterialRequest& request) const;
@@ -393,6 +476,9 @@ namespace AlibabaCloud
QueryMonitorKeywordsOutcome queryMonitorKeywords(const Model::QueryMonitorKeywordsRequest &request)const;
void queryMonitorKeywordsAsync(const Model::QueryMonitorKeywordsRequest& request, const QueryMonitorKeywordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryMonitorKeywordsOutcomeCallable queryMonitorKeywordsCallable(const Model::QueryMonitorKeywordsRequest& request) const;
QueryOfficialFileCustomListOutcome queryOfficialFileCustomList(const Model::QueryOfficialFileCustomListRequest &request)const;
void queryOfficialFileCustomListAsync(const Model::QueryOfficialFileCustomListRequest& request, const QueryOfficialFileCustomListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryOfficialFileCustomListOutcomeCallable queryOfficialFileCustomListCallable(const Model::QueryOfficialFileCustomListRequest& request) const;
QueryOssResourcesOutcome queryOssResources(const Model::QueryOssResourcesRequest &request)const;
void queryOssResourcesAsync(const Model::QueryOssResourcesRequest& request, const QueryOssResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryOssResourcesOutcomeCallable queryOssResourcesCallable(const Model::QueryOssResourcesRequest& request) const;
@@ -438,9 +524,27 @@ namespace AlibabaCloud
RefundProduceOutcome refundProduce(const Model::RefundProduceRequest &request)const;
void refundProduceAsync(const Model::RefundProduceRequest& request, const RefundProduceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RefundProduceOutcomeCallable refundProduceCallable(const Model::RefundProduceRequest& request) const;
RefuseAdditionalMaterialOutcome refuseAdditionalMaterial(const Model::RefuseAdditionalMaterialRequest &request)const;
void refuseAdditionalMaterialAsync(const Model::RefuseAdditionalMaterialRequest& request, const RefuseAdditionalMaterialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RefuseAdditionalMaterialOutcomeCallable refuseAdditionalMaterialCallable(const Model::RefuseAdditionalMaterialRequest& request) const;
RefuseApplicantOutcome refuseApplicant(const Model::RefuseApplicantRequest &request)const;
void refuseApplicantAsync(const Model::RefuseApplicantRequest& request, const RefuseApplicantAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RefuseApplicantOutcomeCallable refuseApplicantCallable(const Model::RefuseApplicantRequest& request) const;
RejectApplicantOutcome rejectApplicant(const Model::RejectApplicantRequest &request)const;
void rejectApplicantAsync(const Model::RejectApplicantRequest& request, const RejectApplicantAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RejectApplicantOutcomeCallable rejectApplicantCallable(const Model::RejectApplicantRequest& request) const;
SaveTaskOutcome saveTask(const Model::SaveTaskRequest &request)const;
void saveTaskAsync(const Model::SaveTaskRequest& request, const SaveTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SaveTaskOutcomeCallable saveTaskCallable(const Model::SaveTaskRequest& request) const;
SaveTaskForOfficialFileCustomOutcome saveTaskForOfficialFileCustom(const Model::SaveTaskForOfficialFileCustomRequest &request)const;
void saveTaskForOfficialFileCustomAsync(const Model::SaveTaskForOfficialFileCustomRequest& request, const SaveTaskForOfficialFileCustomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SaveTaskForOfficialFileCustomOutcomeCallable saveTaskForOfficialFileCustomCallable(const Model::SaveTaskForOfficialFileCustomRequest& request) const;
SaveTradeMarkReviewMaterialDetailOutcome saveTradeMarkReviewMaterialDetail(const Model::SaveTradeMarkReviewMaterialDetailRequest &request)const;
void saveTradeMarkReviewMaterialDetailAsync(const Model::SaveTradeMarkReviewMaterialDetailRequest& request, const SaveTradeMarkReviewMaterialDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SaveTradeMarkReviewMaterialDetailOutcomeCallable saveTradeMarkReviewMaterialDetailCallable(const Model::SaveTradeMarkReviewMaterialDetailRequest& request) const;
SearchTmOnsalesOutcome searchTmOnsales(const Model::SearchTmOnsalesRequest &request)const;
void searchTmOnsalesAsync(const Model::SearchTmOnsalesRequest& request, const SearchTmOnsalesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SearchTmOnsalesOutcomeCallable searchTmOnsalesCallable(const Model::SearchTmOnsalesRequest& request) const;
StartNotaryOutcome startNotary(const Model::StartNotaryRequest &request)const;
void startNotaryAsync(const Model::StartNotaryRequest& request, const StartNotaryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartNotaryOutcomeCallable startNotaryCallable(const Model::StartNotaryRequest& request) const;

57
trademark/include/alibabacloud/trademark/model/AcceptPartnerNotificationRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_TRADEMARK_MODEL_ACCEPTPARTNERNOTIFICATIONREQUEST_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_ACCEPTPARTNERNOTIFICATIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT AcceptPartnerNotificationRequest : public RpcServiceRequest
{
public:
AcceptPartnerNotificationRequest();
~AcceptPartnerNotificationRequest();
std::string getMaterial()const;
void setMaterial(const std::string& material);
std::string getBizId()const;
void setBizId(const std::string& bizId);
std::string getRemark()const;
void setRemark(const std::string& remark);
std::string getOperation()const;
void setOperation(const std::string& operation);
private:
std::string material_;
std::string bizId_;
std::string remark_;
std::string operation_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_ACCEPTPARTNERNOTIFICATIONREQUEST_H_

55
trademark/include/alibabacloud/trademark/model/AcceptPartnerNotificationResult.h Normal file
View File

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

105
trademark/include/alibabacloud/trademark/model/CheckTrademarkOrderRequest.h Normal file
View File

@@ -0,0 +1,105 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_TRADEMARK_MODEL_CHECKTRADEMARKORDERREQUEST_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_CHECKTRADEMARKORDERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT CheckTrademarkOrderRequest : public RpcServiceRequest
{
public:
CheckTrademarkOrderRequest();
~CheckTrademarkOrderRequest();
std::string getRealUserName()const;
void setRealUserName(const std::string& realUserName);
std::string getOrderData()const;
void setOrderData(const std::string& orderData);
std::string getChannel()const;
void setChannel(const std::string& channel);
int getType()const;
void setType(int type);
std::string getMaterialId()const;
void setMaterialId(const std::string& materialId);
long getUserId()const;
void setUserId(long userId);
std::string getTmComment()const;
void setTmComment(const std::string& tmComment);
std::string getTmNameType()const;
void setTmNameType(const std::string& tmNameType);
std::string getTmIcon()const;
void setTmIcon(const std::string& tmIcon);
std::string getUid()const;
void setUid(const std::string& uid);
std::string getRenewInfoId()const;
void setRenewInfoId(const std::string& renewInfoId);
std::string getRootCode()const;
void setRootCode(const std::string& rootCode);
std::string getLoaOssKey()const;
void setLoaOssKey(const std::string& loaOssKey);
std::string getRegisterNumber()const;
void setRegisterNumber(const std::string& registerNumber);
std::string getTmName()const;
void setTmName(const std::string& tmName);
std::string getPartnerCode()const;
void setPartnerCode(const std::string& partnerCode);
std::string getPhoneNum()const;
void setPhoneNum(const std::string& phoneNum);
std::string getRegisterName()const;
void setRegisterName(const std::string& registerName);
bool getIsBlackIcon()const;
void setIsBlackIcon(bool isBlackIcon);
std::string getBizId()const;
void setBizId(const std::string& bizId);
private:
std::string realUserName_;
std::string orderData_;
std::string channel_;
int type_;
std::string materialId_;
long userId_;
std::string tmComment_;
std::string tmNameType_;
std::string tmIcon_;
std::string uid_;
std::string renewInfoId_;
std::string rootCode_;
std::string loaOssKey_;
std::string registerNumber_;
std::string tmName_;
std::string partnerCode_;
std::string phoneNum_;
std::string registerName_;
bool isBlackIcon_;
std::string bizId_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_CHECKTRADEMARKORDERREQUEST_H_

55
trademark/include/alibabacloud/trademark/model/CheckTrademarkOrderResult.h Normal file
View File

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

51
trademark/include/alibabacloud/trademark/model/ConfirmAdditionalMaterialRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_TRADEMARK_MODEL_CONFIRMADDITIONALMATERIALREQUEST_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_CONFIRMADDITIONALMATERIALREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT ConfirmAdditionalMaterialRequest : public RpcServiceRequest
{
public:
ConfirmAdditionalMaterialRequest();
~ConfirmAdditionalMaterialRequest();
std::string getNote()const;
void setNote(const std::string& note);
std::string getBizId()const;
void setBizId(const std::string& bizId);
private:
std::string note_;
std::string bizId_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_CONFIRMADDITIONALMATERIALREQUEST_H_

55
trademark/include/alibabacloud/trademark/model/ConfirmAdditionalMaterialResult.h Normal file
View File

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

51
trademark/include/alibabacloud/trademark/model/ConfirmApplicantRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_TRADEMARK_MODEL_CONFIRMAPPLICANTREQUEST_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_CONFIRMAPPLICANTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT ConfirmApplicantRequest : public RpcServiceRequest
{
public:
ConfirmApplicantRequest();
~ConfirmApplicantRequest();
std::string getNote()const;
void setNote(const std::string& note);
std::string getBizId()const;
void setBizId(const std::string& bizId);
private:
std::string note_;
std::string bizId_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_CONFIRMAPPLICANTREQUEST_H_

55
trademark/include/alibabacloud/trademark/model/ConfirmApplicantResult.h Normal file
View File

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

12
trademark/include/alibabacloud/trademark/model/CreateIntentionOrderRequest.h
View File

@@ -35,14 +35,14 @@ namespace AlibabaCloud
CreateIntentionOrderRequest();
~CreateIntentionOrderRequest();
std::string getChannel()const;
void setChannel(const std::string& channel);
std::string getIntentionBizId()const;
void setIntentionBizId(const std::string& intentionBizId);
std::string getChannel()const;
void setChannel(const std::string& channel);
std::string getIntentionBizId()const;
void setIntentionBizId(const std::string& intentionBizId);
private:
std::string channel_;
std::string intentionBizId_;
std::string channel_;
std::string intentionBizId_;
};
}

72
trademark/include/alibabacloud/trademark/model/DescirbeCombineTrademarkRequest.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_TRADEMARK_MODEL_DESCIRBECOMBINETRADEMARKREQUEST_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_DESCIRBECOMBINETRADEMARKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT DescirbeCombineTrademarkRequest : public RpcServiceRequest
{
public:
DescirbeCombineTrademarkRequest();
~DescirbeCombineTrademarkRequest();
std::string getOwnerName()const;
void setOwnerName(const std::string& ownerName);
std::string getClassification()const;
void setClassification(const std::string& classification);
std::string getRegistrationNumber()const;
void setRegistrationNumber(const std::string& registrationNumber);
bool getAccurateMatch()const;
void setAccurateMatch(bool accurateMatch);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getProducts()const;
void setProducts(const std::string& products);
std::string getSimilarGroups()const;
void setSimilarGroups(const std::string& similarGroups);
std::string getName()const;
void setName(const std::string& name);
int getPageSize()const;
void setPageSize(int pageSize);
private:
std::string ownerName_;
std::string classification_;
std::string registrationNumber_;
bool accurateMatch_;
int pageNumber_;
std::string products_;
std::string similarGroups_;
std::string name_;
int pageSize_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_DESCIRBECOMBINETRADEMARKREQUEST_H_

116
trademark/include/alibabacloud/trademark/model/DescirbeCombineTrademarkResult.h Normal file
View File

@@ -0,0 +1,116 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_TRADEMARK_MODEL_DESCIRBECOMBINETRADEMARKRESULT_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_DESCIRBECOMBINETRADEMARKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT DescirbeCombineTrademarkResult : public ServiceResult
{
public:
struct Trademark
{
struct AnnouncementListItem
{
std::string annTypeCode;
std::string annNumber;
std::string annDate;
std::string annTypeName;
std::string imageUrl;
std::string originalImageUrl;
};
struct ProcedureList
{
std::string procedureCode;
std::string procedureStep;
std::string procedureDate;
std::string procedureName;
std::string procedureResult;
};
std::string ownerName;
std::string priorityDate;
std::vector<Trademark::ProcedureList> procedures;
std::string image;
std::string regAnnNumber;
std::string intlRegDate;
std::string name;
std::string lastProcedureStatus;
std::string classification;
std::string ownerEnAddress;
std::string registrationType;
std::string firstAnnoNumber;
std::string registrationNumber;
std::vector<Trademark::AnnouncementListItem> announcementList;
std::string lawFinalStatus;
std::string status;
std::string indexId;
int onSale;
std::string agency;
std::string firstAnnoType;
std::string ownerAddress;
std::string preAnnNumber;
std::string similarGroup;
std::string ownerEnName;
std::string regAnnDate;
std::string applyDate;
std::string secondAnnoType;
std::string preAnnDate;
std::string secondAnnoNumber;
std::string productDescription;
std::string subsequentDesignationDate;
std::string share;
std::string exclusiveDateLimit;
};
DescirbeCombineTrademarkResult();
explicit DescirbeCombineTrademarkResult(const std::string &payload);
~DescirbeCombineTrademarkResult();
int getTotalItemNumber()const;
bool getPrePage()const;
int getPageSize()const;
std::vector<Trademark> getData()const;
int getCurrentPageNumber()const;
int getTotalPageNumber()const;
bool getNextPage()const;
protected:
void parse(const std::string &payload);
private:
int totalItemNumber_;
bool prePage_;
int pageSize_;
std::vector<Trademark> data_;
int currentPageNumber_;
int totalPageNumber_;
bool nextPage_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_DESCIRBECOMBINETRADEMARKRESULT_H_

6
trademark/include/alibabacloud/trademark/model/QueryIntentionDetailRequest.h
View File

@@ -35,11 +35,11 @@ namespace AlibabaCloud
QueryIntentionDetailRequest();
~QueryIntentionDetailRequest();
std::string getBizId()const;
void setBizId(const std::string& bizId);
std::string getBizId()const;
void setBizId(const std::string& bizId);
private:
std::string bizId_;
std::string bizId_;
};
}

20
trademark/include/alibabacloud/trademark/model/QueryIntentionDetailResult.h
View File

@@ -38,31 +38,35 @@ namespace AlibabaCloud
explicit QueryIntentionDetailResult(const std::string &payload);
~QueryIntentionDetailResult();
int getStatus()const;
std::string getRegisterNumber()const;
int getType()const;
std::string getDescription()const;
std::string getUserName()const;
std::string getRelationBizId()const;
long getCreateTime()const;
std::string getMobile()const;
std::string getRegisterNumber()const;
int getType()const;
std::string getUserId()const;
std::string getClassification()const;
long getCreateTime()const;
long getUpdateTime()const;
std::string getBizId()const;
std::string getMobile()const;
std::string getPartnerMobile()const;
protected:
void parse(const std::string &payload);
private:
int status_;
std::string registerNumber_;
int type_;
std::string description_;
std::string userName_;
std::string relationBizId_;
long createTime_;
std::string mobile_;
std::string registerNumber_;
int type_;
std::string userId_;
std::string classification_;
long createTime_;
long updateTime_;
std::string bizId_;
std::string mobile_;
std::string partnerMobile_;
};
}

36
trademark/include/alibabacloud/trademark/model/QueryIntentionListRequest.h
View File

@@ -35,26 +35,26 @@ namespace AlibabaCloud
QueryIntentionListRequest();
~QueryIntentionListRequest();
int getType()const;
void setType(int type);
int getPageNum()const;
void setPageNum(int pageNum);
std::string getSortFiled()const;
void setSortFiled(const std::string& sortFiled);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getSortOrder()const;
void setSortOrder(const std::string& sortOrder);
int getStatus()const;
void setStatus(int status);
int getType()const;
void setType(int type);
int getPageNum()const;
void setPageNum(int pageNum);
std::string getSortFiled()const;
void setSortFiled(const std::string& sortFiled);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getSortOrder()const;
void setSortOrder(const std::string& sortOrder);
int getStatus()const;
void setStatus(int status);
private:
int type_;
int pageNum_;
std::string sortFiled_;
int pageSize_;
std::string sortOrder_;
int status_;
int type_;
int pageNum_;
std::string sortFiled_;
int pageSize_;
std::string sortOrder_;
int status_;
};
}

51
trademark/include/alibabacloud/trademark/model/QueryIntentionPriceRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_TRADEMARK_MODEL_QUERYINTENTIONPRICEREQUEST_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_QUERYINTENTIONPRICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT QueryIntentionPriceRequest : public RpcServiceRequest
{
public:
QueryIntentionPriceRequest();
~QueryIntentionPriceRequest();
std::string getChannel()const;
void setChannel(const std::string& channel);
std::string getIntentionBizId()const;
void setIntentionBizId(const std::string& intentionBizId);
private:
std::string channel_;
std::string intentionBizId_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_QUERYINTENTIONPRICEREQUEST_H_

91
trademark/include/alibabacloud/trademark/model/QueryIntentionPriceResult.h Normal file
View File

@@ -0,0 +1,91 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_TRADEMARK_MODEL_QUERYINTENTIONPRICERESULT_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_QUERYINTENTIONPRICERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT QueryIntentionPriceResult : public ServiceResult
{
public:
struct TmProduces
{
struct FirstClassification
{
std::string classificationCode;
std::string classificationName;
};
struct ThirdClassifications
{
std::string classificationCode;
std::string classificationName;
};
int status;
std::string materialId;
FirstClassification firstClassification;
std::string tmNumber;
long createTime;
float orderPrice;
std::string loaUrl;
std::string tmIcon;
int supplementStatus;
int type;
long supplementId;
std::string note;
float totalPrice;
std::string tmName;
long updateTime;
float servicePrice;
std::string materialName;
std::string bizId;
std::vector<TmProduces::ThirdClassifications> thirdClassification;
};
QueryIntentionPriceResult();
explicit QueryIntentionPriceResult(const std::string &payload);
~QueryIntentionPriceResult();
int getCurrentPageNum()const;
int getPageSize()const;
int getTotalPageNum()const;
std::vector<TmProduces> getData()const;
int getTotalItemNum()const;
protected:
void parse(const std::string &payload);
private:
int currentPageNum_;
int pageSize_;
int totalPageNum_;
std::vector<TmProduces> data_;
int totalItemNum_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_QUERYINTENTIONPRICERESULT_H_

3
trademark/include/alibabacloud/trademark/model/QueryMaterialRequest.h
View File

@@ -35,10 +35,13 @@ namespace AlibabaCloud
QueryMaterialRequest();
~QueryMaterialRequest();
bool getQueryUnconfirmedInfo()const;
void setQueryUnconfirmedInfo(bool queryUnconfirmedInfo);
long getId()const;
void setId(long id);
private:
bool queryUnconfirmedInfo_;
long id_;
};

4
trademark/include/alibabacloud/trademark/model/QueryMaterialResult.h
View File

@@ -45,10 +45,12 @@ namespace AlibabaCloud
std::string getName()const;
int getLoaStatus()const;
std::string getTown()const;
std::vector<std::string> getReviewAdditionalFiles()const;
std::string getContactNumber()const;
std::string getLegalNoticeUrl()const;
std::string getContactAddress()const;
int getStatus()const;
std::string getReviewApplicationFile()const;
std::string getCity()const;
std::string getProvince()const;
std::string getEAddress()const;
@@ -75,10 +77,12 @@ namespace AlibabaCloud
std::string name_;
int loaStatus_;
std::string town_;
std::vector<std::string> reviewAdditionalFiles_;
std::string contactNumber_;
std::string legalNoticeUrl_;
std::string contactAddress_;
int status_;
std::string reviewApplicationFile_;
std::string city_;
std::string province_;
std::string eAddress_;

51
trademark/include/alibabacloud/trademark/model/QueryOfficialFileCustomListRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_TRADEMARK_MODEL_QUERYOFFICIALFILECUSTOMLISTREQUEST_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_QUERYOFFICIALFILECUSTOMLISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT QueryOfficialFileCustomListRequest : public RpcServiceRequest
{
public:
QueryOfficialFileCustomListRequest();
~QueryOfficialFileCustomListRequest();
int getPageSize()const;
void setPageSize(int pageSize);
int getPageNum()const;
void setPageNum(int pageNum);
private:
int pageSize_;
int pageNum_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_QUERYOFFICIALFILECUSTOMLISTREQUEST_H_

69
trademark/include/alibabacloud/trademark/model/QueryOfficialFileCustomListResult.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_TRADEMARK_MODEL_QUERYOFFICIALFILECUSTOMLISTRESULT_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_QUERYOFFICIALFILECUSTOMLISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT QueryOfficialFileCustomListResult : public ServiceResult
{
public:
struct CustomList
{
std::string status;
long startAcceptTime;
long createTime;
long endAcceptTime;
long expireTime;
std::string downloadUrl;
std::string remark;
};
QueryOfficialFileCustomListResult();
explicit QueryOfficialFileCustomListResult(const std::string &payload);
~QueryOfficialFileCustomListResult();
int getCurrentPageNum()const;
int getPageSize()const;
int getTotalPageNum()const;
std::vector<CustomList> getData()const;
int getTotalItemNum()const;
protected:
void parse(const std::string &payload);
private:
int currentPageNum_;
int pageSize_;
int totalPageNum_;
std::vector<CustomList> data_;
int totalItemNum_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_QUERYOFFICIALFILECUSTOMLISTRESULT_H_

6
trademark/include/alibabacloud/trademark/model/QueryTaskListRequest.h
View File

@@ -37,9 +37,15 @@ namespace AlibabaCloud
std::string getBizType()const;
void setBizType(const std::string& bizType);
int getPageSize()const;
void setPageSize(int pageSize);
int getPageNum()const;
void setPageNum(int pageNum);
private:
std::string bizType_;
int pageSize_;
int pageNum_;
};
}

11
trademark/include/alibabacloud/trademark/model/QueryTaskListResult.h
View File

@@ -36,7 +36,10 @@ namespace AlibabaCloud
{
std::string errMsg;
std::string taskType;
std::string fileName;
long createTime;
std::string taskStatus;
long completeTime;
std::string result;
};
@@ -44,12 +47,20 @@ namespace AlibabaCloud
QueryTaskListResult();
explicit QueryTaskListResult(const std::string &payload);
~QueryTaskListResult();
int getCurrentPageNum()const;
int getPageSize()const;
int getTotalPageNum()const;
std::vector<TaskList> getData()const;
int getTotalItemNum()const;
protected:
void parse(const std::string &payload);
private:
int currentPageNum_;
int pageSize_;
int totalPageNum_;
std::vector<TaskList> data_;
int totalItemNum_;
};
}

3
trademark/include/alibabacloud/trademark/model/QueryTradeIntentionUserListResult.h
View File

@@ -36,10 +36,11 @@ namespace AlibabaCloud
{
int status;
std::string registerNumber;
int type;
std::string userName;
std::string description;
std::string classification;
int mobile;
std::string mobile;
std::string bizId;
};

36
trademark/include/alibabacloud/trademark/model/QueryTradeMarkApplicationDetailResult.h
View File

@@ -40,27 +40,29 @@ namespace AlibabaCloud
struct MaterialDetail
{
std::string cardNumber;
std::string contactAddress;
int status;
std::string eName;
std::string address;
std::string loaUrl;
std::string city;
std::string passportUrl;
std::string name;
std::string town;
std::vector<std::string> reviewAdditionalFiles;
std::string contactNumber;
std::string legalNoticeUrl;
std::string contactAddress;
int status;
std::string reviewApplicationFile;
std::string city;
std::string province;
std::string eAddress;
std::string name;
std::string idCardUrl;
std::string businessLicenceUrl;
int type;
std::string expirationDate;
std::string contactZipcode;
std::string town;
std::string contactNumber;
std::string contactEmail;
std::string country;
int region;
std::string legalNoticeUrl;
std::string contactName;
};
struct FirstClassification
@@ -77,6 +79,14 @@ namespace AlibabaCloud
std::string engAddress;
std::string name;
};
struct ReviewOfficialFiles
{
std::string reviewPart;
std::string reviewAudit;
std::string reviewPass;
std::string reviewKeep;
std::vector<std::string> reviewSupplements;
};
struct ThirdClassifications
{
std::string code;
@@ -110,6 +120,7 @@ namespace AlibabaCloud
std::string getLoaUrl()const;
std::vector<std::string> getReceiptUrl()const;
std::string getTmIcon()const;
std::string getPartnerCode()const;
std::string getAcceptUrl()const;
std::string getSendSbjLogistics()const;
int getTmNameType()const;
@@ -117,6 +128,7 @@ namespace AlibabaCloud
std::string getGrayIconUrl()const;
float getServicePrice()const;
AdminUploads getAdminUploads()const;
std::string getNotAcceptUrl()const;
std::vector<ThirdClassifications> getThirdClassification()const;
std::string getExtendInfo()const;
int getStatus()const;
@@ -126,8 +138,11 @@ namespace AlibabaCloud
std::string getTmNumber()const;
long getCreateTime()const;
float getOrderPrice()const;
std::vector<std::string> getFlags()const;
std::string getOrderId()const;
std::string getPartnerName()const;
std::vector<SupplementsItem> getSupplements()const;
ReviewOfficialFiles getReviewOfficialFiles()const;
int getType()const;
std::string getRecvUserLogistics()const;
std::string getNote()const;
@@ -135,6 +150,7 @@ namespace AlibabaCloud
std::string getTmName()const;
long getUpdateTime()const;
std::string getBizId()const;
std::string getPartnerMobile()const;
protected:
void parse(const std::string &payload);
@@ -144,6 +160,7 @@ namespace AlibabaCloud
std::string loaUrl_;
std::vector<std::string> receiptUrl_;
std::string tmIcon_;
std::string partnerCode_;
std::string acceptUrl_;
std::string sendSbjLogistics_;
int tmNameType_;
@@ -151,6 +168,7 @@ namespace AlibabaCloud
std::string grayIconUrl_;
float servicePrice_;
AdminUploads adminUploads_;
std::string notAcceptUrl_;
std::vector<ThirdClassifications> thirdClassification_;
std::string extendInfo_;
int status_;
@@ -160,8 +178,11 @@ namespace AlibabaCloud
std::string tmNumber_;
long createTime_;
float orderPrice_;
std::vector<std::string> flags_;
std::string orderId_;
std::string partnerName_;
std::vector<SupplementsItem> supplements_;
ReviewOfficialFiles reviewOfficialFiles_;
int type_;
std::string recvUserLogistics_;
std::string note_;
@@ -169,6 +190,7 @@ namespace AlibabaCloud
std::string tmName_;
long updateTime_;
std::string bizId_;
std::string partnerMobile_;
};
}

1
trademark/include/alibabacloud/trademark/model/QueryTradeMarkApplicationLogsResult.h
View File

@@ -35,6 +35,7 @@ namespace AlibabaCloud
struct DataItem
{
long operateTime;
std::string extendContent;
std::string note;
std::string bizId;
int operateType;

24
trademark/include/alibabacloud/trademark/model/QueryTradeMarkApplicationsByIntentionRequest.h
View File

@@ -35,20 +35,20 @@ namespace AlibabaCloud
QueryTradeMarkApplicationsByIntentionRequest();
~QueryTradeMarkApplicationsByIntentionRequest();
std::string getChannel()const;
void setChannel(const std::string& channel);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getIntentionBizId()const;
void setIntentionBizId(const std::string& intentionBizId);
int getPageNum()const;
void setPageNum(int pageNum);
std::string getChannel()const;
void setChannel(const std::string& channel);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getIntentionBizId()const;
void setIntentionBizId(const std::string& intentionBizId);
int getPageNum()const;
void setPageNum(int pageNum);
private:
std::string channel_;
int pageSize_;
std::string intentionBizId_;
int pageNum_;
std::string channel_;
int pageSize_;
std::string intentionBizId_;
int pageNum_;
};
}

1
trademark/include/alibabacloud/trademark/model/QueryTradeProduceDetailResult.h
View File

@@ -41,6 +41,7 @@ namespace AlibabaCloud
float refundAmount;
std::string operateNote;
float finalAmount;
int source;
std::string preOrderId;
float paidAmount;
bool allowCancel;

1
trademark/include/alibabacloud/trademark/model/QueryTradeProduceListResult.h
View File

@@ -40,6 +40,7 @@ namespace AlibabaCloud
std::string operateNote;
int failReason;
int finalAmount;
int source;
std::string preOrderId;
bool allowCancel;
std::string registerNumber;

51
trademark/include/alibabacloud/trademark/model/RefuseAdditionalMaterialRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_TRADEMARK_MODEL_REFUSEADDITIONALMATERIALREQUEST_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_REFUSEADDITIONALMATERIALREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT RefuseAdditionalMaterialRequest : public RpcServiceRequest
{
public:
RefuseAdditionalMaterialRequest();
~RefuseAdditionalMaterialRequest();
std::string getNote()const;
void setNote(const std::string& note);
std::string getBizId()const;
void setBizId(const std::string& bizId);
private:
std::string note_;
std::string bizId_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_REFUSEADDITIONALMATERIALREQUEST_H_

55
trademark/include/alibabacloud/trademark/model/RefuseAdditionalMaterialResult.h Normal file
View File

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

51
trademark/include/alibabacloud/trademark/model/RefuseApplicantRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_TRADEMARK_MODEL_REFUSEAPPLICANTREQUEST_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_REFUSEAPPLICANTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT RefuseApplicantRequest : public RpcServiceRequest
{
public:
RefuseApplicantRequest();
~RefuseApplicantRequest();
std::string getNote()const;
void setNote(const std::string& note);
std::string getBizId()const;
void setBizId(const std::string& bizId);
private:
std::string note_;
std::string bizId_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_REFUSEAPPLICANTREQUEST_H_

55
trademark/include/alibabacloud/trademark/model/RefuseApplicantResult.h Normal file
View File

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

51
trademark/include/alibabacloud/trademark/model/RejectApplicantRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_TRADEMARK_MODEL_REJECTAPPLICANTREQUEST_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_REJECTAPPLICANTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT RejectApplicantRequest : public RpcServiceRequest
{
public:
RejectApplicantRequest();
~RejectApplicantRequest();
std::string getNote()const;
void setNote(const std::string& note);
std::string getInstanceId()const;
void setInstanceId(const std::string& instanceId);
private:
std::string note_;
std::string instanceId_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_REJECTAPPLICANTREQUEST_H_

49
trademark/include/alibabacloud/trademark/model/RejectApplicantResult.h Normal file
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.
*/
#ifndef ALIBABACLOUD_TRADEMARK_MODEL_REJECTAPPLICANTRESULT_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_REJECTAPPLICANTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT RejectApplicantResult : public ServiceResult
{
public:
RejectApplicantResult();
explicit RejectApplicantResult(const std::string &payload);
~RejectApplicantResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_REJECTAPPLICANTRESULT_H_

51
trademark/include/alibabacloud/trademark/model/SaveTaskForOfficialFileCustomRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_TRADEMARK_MODEL_SAVETASKFOROFFICIALFILECUSTOMREQUEST_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_SAVETASKFOROFFICIALFILECUSTOMREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT SaveTaskForOfficialFileCustomRequest : public RpcServiceRequest
{
public:
SaveTaskForOfficialFileCustomRequest();
~SaveTaskForOfficialFileCustomRequest();
long getEndAcceptTime()const;
void setEndAcceptTime(long endAcceptTime);
long getStartAcceptTime()const;
void setStartAcceptTime(long startAcceptTime);
private:
long endAcceptTime_;
long startAcceptTime_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_SAVETASKFOROFFICIALFILECUSTOMREQUEST_H_

51
trademark/include/alibabacloud/trademark/model/SaveTaskForOfficialFileCustomResult.h Normal file
View File

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

111
trademark/include/alibabacloud/trademark/model/SaveTradeMarkReviewMaterialDetailRequest.h Normal file
View File

@@ -0,0 +1,111 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_TRADEMARK_MODEL_SAVETRADEMARKREVIEWMATERIALDETAILREQUEST_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_SAVETRADEMARKREVIEWMATERIALDETAILREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT SaveTradeMarkReviewMaterialDetailRequest : public RpcServiceRequest
{
public:
SaveTradeMarkReviewMaterialDetailRequest();
~SaveTradeMarkReviewMaterialDetailRequest();
std::string getContactEmail()const;
void setContactEmail(const std::string& contactEmail);
std::string getEngName()const;
void setEngName(const std::string& engName);
std::string getCountry()const;
void setCountry(const std::string& country);
std::string getLegalNoticeOssKey()const;
void setLegalNoticeOssKey(const std::string& legalNoticeOssKey);
std::string getContactNumber()const;
void setContactNumber(const std::string& contactNumber);
std::string getEngAddress()const;
void setEngAddress(const std::string& engAddress);
int getType()const;
void setType(int type);
std::string getContactName()const;
void setContactName(const std::string& contactName);
std::string getPassportOssKey()const;
void setPassportOssKey(const std::string& passportOssKey);
std::string getProvince()const;
void setProvince(const std::string& province);
int getSubmitType()const;
void setSubmitType(int submitType);
std::string getLoaOssKey()const;
void setLoaOssKey(const std::string& loaOssKey);
std::string getContactAddress()const;
void setContactAddress(const std::string& contactAddress);
std::string getAddress()const;
void setAddress(const std::string& address);
std::string getIdCardOssKey()const;
void setIdCardOssKey(const std::string& idCardOssKey);
std::string getApplicationOssKey()const;
void setApplicationOssKey(const std::string& applicationOssKey);
std::string getBusinessLicenceOssKey()const;
void setBusinessLicenceOssKey(const std::string& businessLicenceOssKey);
std::string getBizId()const;
void setBizId(const std::string& bizId);
std::string getName()const;
void setName(const std::string& name);
std::string getAdditionalOssKeyList()const;
void setAdditionalOssKeyList(const std::string& additionalOssKeyList);
std::string getCardNumber()const;
void setCardNumber(const std::string& cardNumber);
int getRegion()const;
void setRegion(int region);
private:
std::string contactEmail_;
std::string engName_;
std::string country_;
std::string legalNoticeOssKey_;
std::string contactNumber_;
std::string engAddress_;
int type_;
std::string contactName_;
std::string passportOssKey_;
std::string province_;
int submitType_;
std::string loaOssKey_;
std::string contactAddress_;
std::string address_;
std::string idCardOssKey_;
std::string applicationOssKey_;
std::string businessLicenceOssKey_;
std::string bizId_;
std::string name_;
std::string additionalOssKeyList_;
std::string cardNumber_;
int region_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_SAVETRADEMARKREVIEWMATERIALDETAILREQUEST_H_

53
trademark/include/alibabacloud/trademark/model/SaveTradeMarkReviewMaterialDetailResult.h Normal file
View File

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

93
trademark/include/alibabacloud/trademark/model/SearchTmOnsalesRequest.h Normal file
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.
*/
#ifndef ALIBABACLOUD_TRADEMARK_MODEL_SEARCHTMONSALESREQUEST_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_SEARCHTMONSALESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT SearchTmOnsalesRequest : public RpcServiceRequest
{
public:
SearchTmOnsalesRequest();
~SearchTmOnsalesRequest();
std::string getTmName()const;
void setTmName(const std::string& tmName);
std::string getProductCode()const;
void setProductCode(const std::string& productCode);
std::string getTopSearch()const;
void setTopSearch(const std::string& topSearch);
int getRegLeft()const;
void setRegLeft(int regLeft);
std::string getClassification()const;
void setClassification(const std::string& classification);
int getPageNum()const;
void setPageNum(int pageNum);
long getOrderPriceLeft()const;
void setOrderPriceLeft(long orderPriceLeft);
bool getQueryAll()const;
void setQueryAll(bool queryAll);
std::string getSortName()const;
void setSortName(const std::string& sortName);
long getOrderPriceRight()const;
void setOrderPriceRight(long orderPriceRight);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getSortOrder()const;
void setSortOrder(const std::string& sortOrder);
std::string getTag()const;
void setTag(const std::string& tag);
std::string getKeyword()const;
void setKeyword(const std::string& keyword);
std::string getRegisterNumber()const;
void setRegisterNumber(const std::string& registerNumber);
int getRegRight()const;
void setRegRight(int regRight);
private:
std::string tmName_;
std::string productCode_;
std::string topSearch_;
int regLeft_;
std::string classification_;
int pageNum_;
long orderPriceLeft_;
bool queryAll_;
std::string sortName_;
long orderPriceRight_;
int pageSize_;
std::string sortOrder_;
std::string tag_;
std::string keyword_;
std::string registerNumber_;
int regRight_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_SEARCHTMONSALESREQUEST_H_

72
trademark/include/alibabacloud/trademark/model/SearchTmOnsalesResult.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_TRADEMARK_MODEL_SEARCHTMONSALESRESULT_H_
#define ALIBABACLOUD_TRADEMARK_MODEL_SEARCHTMONSALESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/trademark/TrademarkExport.h>
namespace AlibabaCloud
{
namespace Trademark
{
namespace Model
{
class ALIBABACLOUD_TRADEMARK_EXPORT SearchTmOnsalesResult : public ServiceResult
{
public:
struct Trademark
{
long status;
std::string uid;
std::string trademarkName;
std::string productCode;
std::string classification;
long orderPrice;
std::string productDesc;
std::string registrationNumber;
std::string icon;
std::string partnerCode;
};
SearchTmOnsalesResult();
explicit SearchTmOnsalesResult(const std::string &payload);
~SearchTmOnsalesResult();
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<Trademark> getTrademarks()const;
int getTotalPageNumber()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<Trademark> trademarks_;
int totalPageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_TRADEMARK_MODEL_SEARCHTMONSALESRESULT_H_

18
trademark/include/alibabacloud/trademark/model/WriteCommunicationLogRequest.h
View File

@@ -35,17 +35,17 @@ namespace AlibabaCloud
WriteCommunicationLogRequest();
~WriteCommunicationLogRequest();
std::string getNote()const;
void setNote(const std::string& note);
std::string getTargetId()const;
void setTargetId(const std::string& targetId);
std::string getBizId()const;
void setBizId(const std::string& bizId);
std::string getNote()const;
void setNote(const std::string& note);
std::string getTargetId()const;
void setTargetId(const std::string& targetId);
std::string getBizId()const;
void setBizId(const std::string& bizId);
private:
std::string note_;
std::string targetId_;
std::string bizId_;
std::string note_;
std::string targetId_;
std::string bizId_;
};
}

18
trademark/include/alibabacloud/trademark/model/WriteIntentionCommunicationLogRequest.h
View File

@@ -35,17 +35,17 @@ namespace AlibabaCloud
WriteIntentionCommunicationLogRequest();
~WriteIntentionCommunicationLogRequest();
std::string getNote()const;
void setNote(const std::string& note);
bool getReject()const;
void setReject(bool reject);
std::string getBizId()const;
void setBizId(const std::string& bizId);
std::string getNote()const;
void setNote(const std::string& note);
bool getReject()const;
void setReject(bool reject);
std::string getBizId()const;
void setBizId(const std::string& bizId);
private:
std::string note_;
bool reject_;
std::string bizId_;
std::string note_;
bool reject_;
std::string bizId_;
};
}

468
trademark/src/TrademarkClient.cc
View File

@@ -51,6 +51,42 @@ TrademarkClient::TrademarkClient(const std::string & accessKeyId, const std::str
TrademarkClient::~TrademarkClient()
{}
TrademarkClient::AcceptPartnerNotificationOutcome TrademarkClient::acceptPartnerNotification(const AcceptPartnerNotificationRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AcceptPartnerNotificationOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AcceptPartnerNotificationOutcome(AcceptPartnerNotificationResult(outcome.result()));
else
return AcceptPartnerNotificationOutcome(outcome.error());
}
void TrademarkClient::acceptPartnerNotificationAsync(const AcceptPartnerNotificationRequest& request, const AcceptPartnerNotificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, acceptPartnerNotification(request), context);
};
asyncExecute(new Runnable(fn));
}
TrademarkClient::AcceptPartnerNotificationOutcomeCallable TrademarkClient::acceptPartnerNotificationCallable(const AcceptPartnerNotificationRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AcceptPartnerNotificationOutcome()>>(
[this, request]()
{
return this->acceptPartnerNotification(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
TrademarkClient::ApplyNotaryPostOutcome TrademarkClient::applyNotaryPost(const ApplyNotaryPostRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -195,6 +231,42 @@ TrademarkClient::CheckLoaFillOutcomeCallable TrademarkClient::checkLoaFillCallab
return task->get_future();
}
TrademarkClient::CheckTrademarkOrderOutcome TrademarkClient::checkTrademarkOrder(const CheckTrademarkOrderRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CheckTrademarkOrderOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CheckTrademarkOrderOutcome(CheckTrademarkOrderResult(outcome.result()));
else
return CheckTrademarkOrderOutcome(outcome.error());
}
void TrademarkClient::checkTrademarkOrderAsync(const CheckTrademarkOrderRequest& request, const CheckTrademarkOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, checkTrademarkOrder(request), context);
};
asyncExecute(new Runnable(fn));
}
TrademarkClient::CheckTrademarkOrderOutcomeCallable TrademarkClient::checkTrademarkOrderCallable(const CheckTrademarkOrderRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CheckTrademarkOrderOutcome()>>(
[this, request]()
{
return this->checkTrademarkOrder(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
TrademarkClient::CombineLoaOutcome TrademarkClient::combineLoa(const CombineLoaRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -231,6 +303,78 @@ TrademarkClient::CombineLoaOutcomeCallable TrademarkClient::combineLoaCallable(c
return task->get_future();
}
TrademarkClient::ConfirmAdditionalMaterialOutcome TrademarkClient::confirmAdditionalMaterial(const ConfirmAdditionalMaterialRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ConfirmAdditionalMaterialOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ConfirmAdditionalMaterialOutcome(ConfirmAdditionalMaterialResult(outcome.result()));
else
return ConfirmAdditionalMaterialOutcome(outcome.error());
}
void TrademarkClient::confirmAdditionalMaterialAsync(const ConfirmAdditionalMaterialRequest& request, const ConfirmAdditionalMaterialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, confirmAdditionalMaterial(request), context);
};
asyncExecute(new Runnable(fn));
}
TrademarkClient::ConfirmAdditionalMaterialOutcomeCallable TrademarkClient::confirmAdditionalMaterialCallable(const ConfirmAdditionalMaterialRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ConfirmAdditionalMaterialOutcome()>>(
[this, request]()
{
return this->confirmAdditionalMaterial(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
TrademarkClient::ConfirmApplicantOutcome TrademarkClient::confirmApplicant(const ConfirmApplicantRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ConfirmApplicantOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ConfirmApplicantOutcome(ConfirmApplicantResult(outcome.result()));
else
return ConfirmApplicantOutcome(outcome.error());
}
void TrademarkClient::confirmApplicantAsync(const ConfirmApplicantRequest& request, const ConfirmApplicantAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, confirmApplicant(request), context);
};
asyncExecute(new Runnable(fn));
}
TrademarkClient::ConfirmApplicantOutcomeCallable TrademarkClient::confirmApplicantCallable(const ConfirmApplicantRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ConfirmApplicantOutcome()>>(
[this, request]()
{
return this->confirmApplicant(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
TrademarkClient::ConvertImageToGrayOutcome TrademarkClient::convertImageToGray(const ConvertImageToGrayRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -447,6 +591,42 @@ TrademarkClient::DenySupplementOutcomeCallable TrademarkClient::denySupplementCa
return task->get_future();
}
TrademarkClient::DescirbeCombineTrademarkOutcome TrademarkClient::descirbeCombineTrademark(const DescirbeCombineTrademarkRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescirbeCombineTrademarkOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescirbeCombineTrademarkOutcome(DescirbeCombineTrademarkResult(outcome.result()));
else
return DescirbeCombineTrademarkOutcome(outcome.error());
}
void TrademarkClient::descirbeCombineTrademarkAsync(const DescirbeCombineTrademarkRequest& request, const DescirbeCombineTrademarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, descirbeCombineTrademark(request), context);
};
asyncExecute(new Runnable(fn));
}
TrademarkClient::DescirbeCombineTrademarkOutcomeCallable TrademarkClient::descirbeCombineTrademarkCallable(const DescirbeCombineTrademarkRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescirbeCombineTrademarkOutcome()>>(
[this, request]()
{
return this->descirbeCombineTrademark(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
TrademarkClient::FillLogisticsOutcome TrademarkClient::fillLogistics(const FillLogisticsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -987,6 +1167,42 @@ TrademarkClient::QueryIntentionListOutcomeCallable TrademarkClient::queryIntenti
return task->get_future();
}
TrademarkClient::QueryIntentionPriceOutcome TrademarkClient::queryIntentionPrice(const QueryIntentionPriceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QueryIntentionPriceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QueryIntentionPriceOutcome(QueryIntentionPriceResult(outcome.result()));
else
return QueryIntentionPriceOutcome(outcome.error());
}
void TrademarkClient::queryIntentionPriceAsync(const QueryIntentionPriceRequest& request, const QueryIntentionPriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, queryIntentionPrice(request), context);
};
asyncExecute(new Runnable(fn));
}
TrademarkClient::QueryIntentionPriceOutcomeCallable TrademarkClient::queryIntentionPriceCallable(const QueryIntentionPriceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QueryIntentionPriceOutcome()>>(
[this, request]()
{
return this->queryIntentionPrice(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
TrademarkClient::QueryMaterialOutcome TrademarkClient::queryMaterial(const QueryMaterialRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1095,6 +1311,42 @@ TrademarkClient::QueryMonitorKeywordsOutcomeCallable TrademarkClient::queryMonit
return task->get_future();
}
TrademarkClient::QueryOfficialFileCustomListOutcome TrademarkClient::queryOfficialFileCustomList(const QueryOfficialFileCustomListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QueryOfficialFileCustomListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QueryOfficialFileCustomListOutcome(QueryOfficialFileCustomListResult(outcome.result()));
else
return QueryOfficialFileCustomListOutcome(outcome.error());
}
void TrademarkClient::queryOfficialFileCustomListAsync(const QueryOfficialFileCustomListRequest& request, const QueryOfficialFileCustomListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, queryOfficialFileCustomList(request), context);
};
asyncExecute(new Runnable(fn));
}
TrademarkClient::QueryOfficialFileCustomListOutcomeCallable TrademarkClient::queryOfficialFileCustomListCallable(const QueryOfficialFileCustomListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QueryOfficialFileCustomListOutcome()>>(
[this, request]()
{
return this->queryOfficialFileCustomList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
TrademarkClient::QueryOssResourcesOutcome TrademarkClient::queryOssResources(const QueryOssResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1635,6 +1887,114 @@ TrademarkClient::RefundProduceOutcomeCallable TrademarkClient::refundProduceCall
return task->get_future();
}
TrademarkClient::RefuseAdditionalMaterialOutcome TrademarkClient::refuseAdditionalMaterial(const RefuseAdditionalMaterialRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RefuseAdditionalMaterialOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RefuseAdditionalMaterialOutcome(RefuseAdditionalMaterialResult(outcome.result()));
else
return RefuseAdditionalMaterialOutcome(outcome.error());
}
void TrademarkClient::refuseAdditionalMaterialAsync(const RefuseAdditionalMaterialRequest& request, const RefuseAdditionalMaterialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, refuseAdditionalMaterial(request), context);
};
asyncExecute(new Runnable(fn));
}
TrademarkClient::RefuseAdditionalMaterialOutcomeCallable TrademarkClient::refuseAdditionalMaterialCallable(const RefuseAdditionalMaterialRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RefuseAdditionalMaterialOutcome()>>(
[this, request]()
{
return this->refuseAdditionalMaterial(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
TrademarkClient::RefuseApplicantOutcome TrademarkClient::refuseApplicant(const RefuseApplicantRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RefuseApplicantOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RefuseApplicantOutcome(RefuseApplicantResult(outcome.result()));
else
return RefuseApplicantOutcome(outcome.error());
}
void TrademarkClient::refuseApplicantAsync(const RefuseApplicantRequest& request, const RefuseApplicantAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, refuseApplicant(request), context);
};
asyncExecute(new Runnable(fn));
}
TrademarkClient::RefuseApplicantOutcomeCallable TrademarkClient::refuseApplicantCallable(const RefuseApplicantRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RefuseApplicantOutcome()>>(
[this, request]()
{
return this->refuseApplicant(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
TrademarkClient::RejectApplicantOutcome TrademarkClient::rejectApplicant(const RejectApplicantRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RejectApplicantOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RejectApplicantOutcome(RejectApplicantResult(outcome.result()));
else
return RejectApplicantOutcome(outcome.error());
}
void TrademarkClient::rejectApplicantAsync(const RejectApplicantRequest& request, const RejectApplicantAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, rejectApplicant(request), context);
};
asyncExecute(new Runnable(fn));
}
TrademarkClient::RejectApplicantOutcomeCallable TrademarkClient::rejectApplicantCallable(const RejectApplicantRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RejectApplicantOutcome()>>(
[this, request]()
{
return this->rejectApplicant(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
TrademarkClient::SaveTaskOutcome TrademarkClient::saveTask(const SaveTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1671,6 +2031,114 @@ TrademarkClient::SaveTaskOutcomeCallable TrademarkClient::saveTaskCallable(const
return task->get_future();
}
TrademarkClient::SaveTaskForOfficialFileCustomOutcome TrademarkClient::saveTaskForOfficialFileCustom(const SaveTaskForOfficialFileCustomRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SaveTaskForOfficialFileCustomOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SaveTaskForOfficialFileCustomOutcome(SaveTaskForOfficialFileCustomResult(outcome.result()));
else
return SaveTaskForOfficialFileCustomOutcome(outcome.error());
}
void TrademarkClient::saveTaskForOfficialFileCustomAsync(const SaveTaskForOfficialFileCustomRequest& request, const SaveTaskForOfficialFileCustomAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, saveTaskForOfficialFileCustom(request), context);
};
asyncExecute(new Runnable(fn));
}
TrademarkClient::SaveTaskForOfficialFileCustomOutcomeCallable TrademarkClient::saveTaskForOfficialFileCustomCallable(const SaveTaskForOfficialFileCustomRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SaveTaskForOfficialFileCustomOutcome()>>(
[this, request]()
{
return this->saveTaskForOfficialFileCustom(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
TrademarkClient::SaveTradeMarkReviewMaterialDetailOutcome TrademarkClient::saveTradeMarkReviewMaterialDetail(const SaveTradeMarkReviewMaterialDetailRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SaveTradeMarkReviewMaterialDetailOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SaveTradeMarkReviewMaterialDetailOutcome(SaveTradeMarkReviewMaterialDetailResult(outcome.result()));
else
return SaveTradeMarkReviewMaterialDetailOutcome(outcome.error());
}
void TrademarkClient::saveTradeMarkReviewMaterialDetailAsync(const SaveTradeMarkReviewMaterialDetailRequest& request, const SaveTradeMarkReviewMaterialDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, saveTradeMarkReviewMaterialDetail(request), context);
};
asyncExecute(new Runnable(fn));
}
TrademarkClient::SaveTradeMarkReviewMaterialDetailOutcomeCallable TrademarkClient::saveTradeMarkReviewMaterialDetailCallable(const SaveTradeMarkReviewMaterialDetailRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SaveTradeMarkReviewMaterialDetailOutcome()>>(
[this, request]()
{
return this->saveTradeMarkReviewMaterialDetail(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
TrademarkClient::SearchTmOnsalesOutcome TrademarkClient::searchTmOnsales(const SearchTmOnsalesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SearchTmOnsalesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SearchTmOnsalesOutcome(SearchTmOnsalesResult(outcome.result()));
else
return SearchTmOnsalesOutcome(outcome.error());
}
void TrademarkClient::searchTmOnsalesAsync(const SearchTmOnsalesRequest& request, const SearchTmOnsalesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, searchTmOnsales(request), context);
};
asyncExecute(new Runnable(fn));
}
TrademarkClient::SearchTmOnsalesOutcomeCallable TrademarkClient::searchTmOnsalesCallable(const SearchTmOnsalesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SearchTmOnsalesOutcome()>>(
[this, request]()
{
return this->searchTmOnsales(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
TrademarkClient::StartNotaryOutcome TrademarkClient::startNotary(const StartNotaryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

73
trademark/src/model/AcceptPartnerNotificationRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/trademark/model/AcceptPartnerNotificationRequest.h>
using AlibabaCloud::Trademark::Model::AcceptPartnerNotificationRequest;
AcceptPartnerNotificationRequest::AcceptPartnerNotificationRequest() :
RpcServiceRequest("trademark", "2018-07-24", "AcceptPartnerNotification")
{
setMethod(HttpRequest::Method::Post);
}
AcceptPartnerNotificationRequest::~AcceptPartnerNotificationRequest()
{}
std::string AcceptPartnerNotificationRequest::getMaterial()const
{
return material_;
}
void AcceptPartnerNotificationRequest::setMaterial(const std::string& material)
{
material_ = material;
setParameter("Material", material);
}
std::string AcceptPartnerNotificationRequest::getBizId()const
{
return bizId_;
}
void AcceptPartnerNotificationRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setParameter("BizId", bizId);
}
std::string AcceptPartnerNotificationRequest::getRemark()const
{
return remark_;
}
void AcceptPartnerNotificationRequest::setRemark(const std::string& remark)
{
remark_ = remark;
setParameter("Remark", remark);
}
std::string AcceptPartnerNotificationRequest::getOperation()const
{
return operation_;
}
void AcceptPartnerNotificationRequest::setOperation(const std::string& operation)
{
operation_ = operation;
setParameter("Operation", operation);
}

65
trademark/src/model/AcceptPartnerNotificationResult.cc Normal file
View File

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

12
trademark/src/model/ApplyNotaryPostRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::ApplyNotaryPostRequest;
ApplyNotaryPostRequest::ApplyNotaryPostRequest() :
RpcServiceRequest("trademark", "2018-07-24", "ApplyNotaryPost")
{}
{
setMethod(HttpRequest::Method::Post);
}
ApplyNotaryPostRequest::~ApplyNotaryPostRequest()
{}
@@ -33,7 +35,7 @@ std::string ApplyNotaryPostRequest::getReceiverName()const
void ApplyNotaryPostRequest::setReceiverName(const std::string& receiverName)
{
receiverName_ = receiverName;
setCoreParameter("ReceiverName", receiverName);
setParameter("ReceiverName", receiverName);
}
std::string ApplyNotaryPostRequest::getReceiverPhone()const
@@ -44,7 +46,7 @@ std::string ApplyNotaryPostRequest::getReceiverPhone()const
void ApplyNotaryPostRequest::setReceiverPhone(const std::string& receiverPhone)
{
receiverPhone_ = receiverPhone;
setCoreParameter("ReceiverPhone", receiverPhone);
setParameter("ReceiverPhone", receiverPhone);
}
long ApplyNotaryPostRequest::getNotaryOrderId()const
@@ -55,7 +57,7 @@ long ApplyNotaryPostRequest::getNotaryOrderId()const
void ApplyNotaryPostRequest::setNotaryOrderId(long notaryOrderId)
{
notaryOrderId_ = notaryOrderId;
setCoreParameter("NotaryOrderId", std::to_string(notaryOrderId));
setParameter("NotaryOrderId", std::to_string(notaryOrderId));
}
std::string ApplyNotaryPostRequest::getReceiverAddress()const
@@ -66,6 +68,6 @@ std::string ApplyNotaryPostRequest::getReceiverAddress()const
void ApplyNotaryPostRequest::setReceiverAddress(const std::string& receiverAddress)
{
receiverAddress_ = receiverAddress;
setCoreParameter("ReceiverAddress", receiverAddress);
setParameter("ReceiverAddress", receiverAddress);
}

10
trademark/src/model/BindMaterialRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::BindMaterialRequest;
BindMaterialRequest::BindMaterialRequest() :
RpcServiceRequest("trademark", "2018-07-24", "BindMaterial")
{}
{
setMethod(HttpRequest::Method::Post);
}
BindMaterialRequest::~BindMaterialRequest()
{}
@@ -33,7 +35,7 @@ std::string BindMaterialRequest::getBizId()const
void BindMaterialRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setCoreParameter("BizId", bizId);
setParameter("BizId", bizId);
}
std::string BindMaterialRequest::getMaterialId()const
@@ -44,7 +46,7 @@ std::string BindMaterialRequest::getMaterialId()const
void BindMaterialRequest::setMaterialId(const std::string& materialId)
{
materialId_ = materialId;
setCoreParameter("MaterialId", materialId);
setParameter("MaterialId", materialId);
}
std::string BindMaterialRequest::getLoaOssKey()const
@@ -55,6 +57,6 @@ std::string BindMaterialRequest::getLoaOssKey()const
void BindMaterialRequest::setLoaOssKey(const std::string& loaOssKey)
{
loaOssKey_ = loaOssKey;
setCoreParameter("LoaOssKey", loaOssKey);
setParameter("LoaOssKey", loaOssKey);
}

6
trademark/src/model/CancelTradeOrderRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::CancelTradeOrderRequest;
CancelTradeOrderRequest::CancelTradeOrderRequest() :
RpcServiceRequest("trademark", "2018-07-24", "CancelTradeOrder")
{}
{
setMethod(HttpRequest::Method::Post);
}
CancelTradeOrderRequest::~CancelTradeOrderRequest()
{}
@@ -33,6 +35,6 @@ std::string CancelTradeOrderRequest::getBizId()const
void CancelTradeOrderRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setCoreParameter("BizId", bizId);
setParameter("BizId", bizId);
}

8
trademark/src/model/CheckLoaFillRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::CheckLoaFillRequest;
CheckLoaFillRequest::CheckLoaFillRequest() :
RpcServiceRequest("trademark", "2018-07-24", "CheckLoaFill")
{}
{
setMethod(HttpRequest::Method::Post);
}
CheckLoaFillRequest::~CheckLoaFillRequest()
{}
@@ -33,7 +35,7 @@ std::string CheckLoaFillRequest::getOssKey()const
void CheckLoaFillRequest::setOssKey(const std::string& ossKey)
{
ossKey_ = ossKey;
setCoreParameter("OssKey", ossKey);
setParameter("OssKey", ossKey);
}
std::string CheckLoaFillRequest::getType()const
@@ -44,6 +46,6 @@ std::string CheckLoaFillRequest::getType()const
void CheckLoaFillRequest::setType(const std::string& type)
{
type_ = type;
setCoreParameter("Type", type);
setParameter("Type", type);
}

249
trademark/src/model/CheckTrademarkOrderRequest.cc Normal file
View File

@@ -0,0 +1,249 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/trademark/model/CheckTrademarkOrderRequest.h>
using AlibabaCloud::Trademark::Model::CheckTrademarkOrderRequest;
CheckTrademarkOrderRequest::CheckTrademarkOrderRequest() :
RpcServiceRequest("trademark", "2018-07-24", "CheckTrademarkOrder")
{
setMethod(HttpRequest::Method::Post);
}
CheckTrademarkOrderRequest::~CheckTrademarkOrderRequest()
{}
std::string CheckTrademarkOrderRequest::getRealUserName()const
{
return realUserName_;
}
void CheckTrademarkOrderRequest::setRealUserName(const std::string& realUserName)
{
realUserName_ = realUserName;
setParameter("RealUserName", realUserName);
}
std::string CheckTrademarkOrderRequest::getOrderData()const
{
return orderData_;
}
void CheckTrademarkOrderRequest::setOrderData(const std::string& orderData)
{
orderData_ = orderData;
setParameter("OrderData", orderData);
}
std::string CheckTrademarkOrderRequest::getChannel()const
{
return channel_;
}
void CheckTrademarkOrderRequest::setChannel(const std::string& channel)
{
channel_ = channel;
setParameter("Channel", channel);
}
int CheckTrademarkOrderRequest::getType()const
{
return type_;
}
void CheckTrademarkOrderRequest::setType(int type)
{
type_ = type;
setParameter("Type", std::to_string(type));
}
std::string CheckTrademarkOrderRequest::getMaterialId()const
{
return materialId_;
}
void CheckTrademarkOrderRequest::setMaterialId(const std::string& materialId)
{
materialId_ = materialId;
setParameter("MaterialId", materialId);
}
long CheckTrademarkOrderRequest::getUserId()const
{
return userId_;
}
void CheckTrademarkOrderRequest::setUserId(long userId)
{
userId_ = userId;
setParameter("UserId", std::to_string(userId));
}
std::string CheckTrademarkOrderRequest::getTmComment()const
{
return tmComment_;
}
void CheckTrademarkOrderRequest::setTmComment(const std::string& tmComment)
{
tmComment_ = tmComment;
setParameter("TmComment", tmComment);
}
std::string CheckTrademarkOrderRequest::getTmNameType()const
{
return tmNameType_;
}
void CheckTrademarkOrderRequest::setTmNameType(const std::string& tmNameType)
{
tmNameType_ = tmNameType;
setParameter("TmNameType", tmNameType);
}
std::string CheckTrademarkOrderRequest::getTmIcon()const
{
return tmIcon_;
}
void CheckTrademarkOrderRequest::setTmIcon(const std::string& tmIcon)
{
tmIcon_ = tmIcon;
setParameter("TmIcon", tmIcon);
}
std::string CheckTrademarkOrderRequest::getUid()const
{
return uid_;
}
void CheckTrademarkOrderRequest::setUid(const std::string& uid)
{
uid_ = uid;
setParameter("Uid", uid);
}
std::string CheckTrademarkOrderRequest::getRenewInfoId()const
{
return renewInfoId_;
}
void CheckTrademarkOrderRequest::setRenewInfoId(const std::string& renewInfoId)
{
renewInfoId_ = renewInfoId;
setParameter("RenewInfoId", renewInfoId);
}
std::string CheckTrademarkOrderRequest::getRootCode()const
{
return rootCode_;
}
void CheckTrademarkOrderRequest::setRootCode(const std::string& rootCode)
{
rootCode_ = rootCode;
setParameter("RootCode", rootCode);
}
std::string CheckTrademarkOrderRequest::getLoaOssKey()const
{
return loaOssKey_;
}
void CheckTrademarkOrderRequest::setLoaOssKey(const std::string& loaOssKey)
{
loaOssKey_ = loaOssKey;
setParameter("LoaOssKey", loaOssKey);
}
std::string CheckTrademarkOrderRequest::getRegisterNumber()const
{
return registerNumber_;
}
void CheckTrademarkOrderRequest::setRegisterNumber(const std::string& registerNumber)
{
registerNumber_ = registerNumber;
setParameter("RegisterNumber", registerNumber);
}
std::string CheckTrademarkOrderRequest::getTmName()const
{
return tmName_;
}
void CheckTrademarkOrderRequest::setTmName(const std::string& tmName)
{
tmName_ = tmName;
setParameter("TmName", tmName);
}
std::string CheckTrademarkOrderRequest::getPartnerCode()const
{
return partnerCode_;
}
void CheckTrademarkOrderRequest::setPartnerCode(const std::string& partnerCode)
{
partnerCode_ = partnerCode;
setParameter("PartnerCode", partnerCode);
}
std::string CheckTrademarkOrderRequest::getPhoneNum()const
{
return phoneNum_;
}
void CheckTrademarkOrderRequest::setPhoneNum(const std::string& phoneNum)
{
phoneNum_ = phoneNum;
setParameter("PhoneNum", phoneNum);
}
std::string CheckTrademarkOrderRequest::getRegisterName()const
{
return registerName_;
}
void CheckTrademarkOrderRequest::setRegisterName(const std::string& registerName)
{
registerName_ = registerName;
setParameter("RegisterName", registerName);
}
bool CheckTrademarkOrderRequest::getIsBlackIcon()const
{
return isBlackIcon_;
}
void CheckTrademarkOrderRequest::setIsBlackIcon(bool isBlackIcon)
{
isBlackIcon_ = isBlackIcon;
setParameter("IsBlackIcon", isBlackIcon ? "true" : "false");
}
std::string CheckTrademarkOrderRequest::getBizId()const
{
return bizId_;
}
void CheckTrademarkOrderRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setParameter("BizId", bizId);
}

65
trademark/src/model/CheckTrademarkOrderResult.cc Normal file
View File

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

16
trademark/src/model/CombineLoaRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::CombineLoaRequest;
CombineLoaRequest::CombineLoaRequest() :
RpcServiceRequest("trademark", "2018-07-24", "CombineLoa")
{}
{
setMethod(HttpRequest::Method::Post);
}
CombineLoaRequest::~CombineLoaRequest()
{}
@@ -33,7 +35,7 @@ std::string CombineLoaRequest::getMaterialName()const
void CombineLoaRequest::setMaterialName(const std::string& materialName)
{
materialName_ = materialName;
setCoreParameter("MaterialName", materialName);
setParameter("MaterialName", materialName);
}
std::string CombineLoaRequest::getAddress()const
@@ -44,7 +46,7 @@ std::string CombineLoaRequest::getAddress()const
void CombineLoaRequest::setAddress(const std::string& address)
{
address_ = address;
setCoreParameter("Address", address);
setParameter("Address", address);
}
std::string CombineLoaRequest::getMaterialId()const
@@ -55,7 +57,7 @@ std::string CombineLoaRequest::getMaterialId()const
void CombineLoaRequest::setMaterialId(const std::string& materialId)
{
materialId_ = materialId;
setCoreParameter("MaterialId", materialId);
setParameter("MaterialId", materialId);
}
std::string CombineLoaRequest::getTrademarkName()const
@@ -66,7 +68,7 @@ std::string CombineLoaRequest::getTrademarkName()const
void CombineLoaRequest::setTrademarkName(const std::string& trademarkName)
{
trademarkName_ = trademarkName;
setCoreParameter("TrademarkName", trademarkName);
setParameter("TrademarkName", trademarkName);
}
std::string CombineLoaRequest::getNationality()const
@@ -77,7 +79,7 @@ std::string CombineLoaRequest::getNationality()const
void CombineLoaRequest::setNationality(const std::string& nationality)
{
nationality_ = nationality;
setCoreParameter("Nationality", nationality);
setParameter("Nationality", nationality);
}
std::string CombineLoaRequest::getTmProduceType()const
@@ -88,6 +90,6 @@ std::string CombineLoaRequest::getTmProduceType()const
void CombineLoaRequest::setTmProduceType(const std::string& tmProduceType)
{
tmProduceType_ = tmProduceType;
setCoreParameter("TmProduceType", tmProduceType);
setParameter("TmProduceType", tmProduceType);
}

51
trademark/src/model/ConfirmAdditionalMaterialRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/trademark/model/ConfirmAdditionalMaterialRequest.h>
using AlibabaCloud::Trademark::Model::ConfirmAdditionalMaterialRequest;
ConfirmAdditionalMaterialRequest::ConfirmAdditionalMaterialRequest() :
RpcServiceRequest("trademark", "2018-07-24", "ConfirmAdditionalMaterial")
{
setMethod(HttpRequest::Method::Post);
}
ConfirmAdditionalMaterialRequest::~ConfirmAdditionalMaterialRequest()
{}
std::string ConfirmAdditionalMaterialRequest::getNote()const
{
return note_;
}
void ConfirmAdditionalMaterialRequest::setNote(const std::string& note)
{
note_ = note;
setParameter("Note", note);
}
std::string ConfirmAdditionalMaterialRequest::getBizId()const
{
return bizId_;
}
void ConfirmAdditionalMaterialRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setParameter("BizId", bizId);
}

65
trademark/src/model/ConfirmAdditionalMaterialResult.cc Normal file
View File

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

51
trademark/src/model/ConfirmApplicantRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/trademark/model/ConfirmApplicantRequest.h>
using AlibabaCloud::Trademark::Model::ConfirmApplicantRequest;
ConfirmApplicantRequest::ConfirmApplicantRequest() :
RpcServiceRequest("trademark", "2018-07-24", "ConfirmApplicant")
{
setMethod(HttpRequest::Method::Post);
}
ConfirmApplicantRequest::~ConfirmApplicantRequest()
{}
std::string ConfirmApplicantRequest::getNote()const
{
return note_;
}
void ConfirmApplicantRequest::setNote(const std::string& note)
{
note_ = note;
setParameter("Note", note);
}
std::string ConfirmApplicantRequest::getBizId()const
{
return bizId_;
}
void ConfirmApplicantRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setParameter("BizId", bizId);
}

65
trademark/src/model/ConfirmApplicantResult.cc Normal file
View File

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

6
trademark/src/model/ConvertImageToGrayRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::ConvertImageToGrayRequest;
ConvertImageToGrayRequest::ConvertImageToGrayRequest() :
RpcServiceRequest("trademark", "2018-07-24", "ConvertImageToGray")
{}
{
setMethod(HttpRequest::Method::Post);
}
ConvertImageToGrayRequest::~ConvertImageToGrayRequest()
{}
@@ -33,6 +35,6 @@ std::string ConvertImageToGrayRequest::getOssKey()const
void ConvertImageToGrayRequest::setOssKey(const std::string& ossKey)
{
ossKey_ = ossKey;
setCoreParameter("OssKey", ossKey);
setParameter("OssKey", ossKey);
}

48
trademark/src/model/CreateIntentionOrderRequest.cc
View File

@@ -20,30 +20,32 @@ using AlibabaCloud::Trademark::Model::CreateIntentionOrderRequest;
CreateIntentionOrderRequest::CreateIntentionOrderRequest() :
RpcServiceRequest("trademark", "2018-07-24", "CreateIntentionOrder")
{}
{
setMethod(HttpRequest::Method::Post);
}
CreateIntentionOrderRequest::~CreateIntentionOrderRequest()
{}
std::string CreateIntentionOrderRequest::getChannel()const
{
return channel_;
}
void CreateIntentionOrderRequest::setChannel(const std::string& channel)
{
channel_ = channel;
setCoreParameter("Channel", channel);
}
std::string CreateIntentionOrderRequest::getIntentionBizId()const
{
return intentionBizId_;
}
void CreateIntentionOrderRequest::setIntentionBizId(const std::string& intentionBizId)
{
intentionBizId_ = intentionBizId;
setCoreParameter("IntentionBizId", intentionBizId);
}
std::string CreateIntentionOrderRequest::getChannel()const
{
return channel_;
}
void CreateIntentionOrderRequest::setChannel(const std::string& channel)
{
channel_ = channel;
setParameter("Channel", channel);
}
std::string CreateIntentionOrderRequest::getIntentionBizId()const
{
return intentionBizId_;
}
void CreateIntentionOrderRequest::setIntentionBizId(const std::string& intentionBizId)
{
intentionBizId_ = intentionBizId;
setParameter("IntentionBizId", intentionBizId);
}

44
trademark/src/model/CreateTrademarkOrderRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::CreateTrademarkOrderRequest;
CreateTrademarkOrderRequest::CreateTrademarkOrderRequest() :
RpcServiceRequest("trademark", "2018-07-24", "CreateTrademarkOrder")
{}
{
setMethod(HttpRequest::Method::Post);
}
CreateTrademarkOrderRequest::~CreateTrademarkOrderRequest()
{}
@@ -33,7 +35,7 @@ std::string CreateTrademarkOrderRequest::getRealUserName()const
void CreateTrademarkOrderRequest::setRealUserName(const std::string& realUserName)
{
realUserName_ = realUserName;
setCoreParameter("RealUserName", realUserName);
setParameter("RealUserName", realUserName);
}
std::string CreateTrademarkOrderRequest::getOrderData()const
@@ -44,7 +46,7 @@ std::string CreateTrademarkOrderRequest::getOrderData()const
void CreateTrademarkOrderRequest::setOrderData(const std::string& orderData)
{
orderData_ = orderData;
setCoreParameter("OrderData", orderData);
setParameter("OrderData", orderData);
}
std::string CreateTrademarkOrderRequest::getChannel()const
@@ -55,7 +57,7 @@ std::string CreateTrademarkOrderRequest::getChannel()const
void CreateTrademarkOrderRequest::setChannel(const std::string& channel)
{
channel_ = channel;
setCoreParameter("Channel", channel);
setParameter("Channel", channel);
}
int CreateTrademarkOrderRequest::getType()const
@@ -66,7 +68,7 @@ int CreateTrademarkOrderRequest::getType()const
void CreateTrademarkOrderRequest::setType(int type)
{
type_ = type;
setCoreParameter("Type", std::to_string(type));
setParameter("Type", std::to_string(type));
}
std::string CreateTrademarkOrderRequest::getMaterialId()const
@@ -77,7 +79,7 @@ std::string CreateTrademarkOrderRequest::getMaterialId()const
void CreateTrademarkOrderRequest::setMaterialId(const std::string& materialId)
{
materialId_ = materialId;
setCoreParameter("MaterialId", materialId);
setParameter("MaterialId", materialId);
}
long CreateTrademarkOrderRequest::getUserId()const
@@ -88,7 +90,7 @@ long CreateTrademarkOrderRequest::getUserId()const
void CreateTrademarkOrderRequest::setUserId(long userId)
{
userId_ = userId;
setCoreParameter("UserId", std::to_string(userId));
setParameter("UserId", std::to_string(userId));
}
std::string CreateTrademarkOrderRequest::getTmComment()const
@@ -99,7 +101,7 @@ std::string CreateTrademarkOrderRequest::getTmComment()const
void CreateTrademarkOrderRequest::setTmComment(const std::string& tmComment)
{
tmComment_ = tmComment;
setCoreParameter("TmComment", tmComment);
setParameter("TmComment", tmComment);
}
std::string CreateTrademarkOrderRequest::getTmNameType()const
@@ -110,7 +112,7 @@ std::string CreateTrademarkOrderRequest::getTmNameType()const
void CreateTrademarkOrderRequest::setTmNameType(const std::string& tmNameType)
{
tmNameType_ = tmNameType;
setCoreParameter("TmNameType", tmNameType);
setParameter("TmNameType", tmNameType);
}
std::string CreateTrademarkOrderRequest::getTmIcon()const
@@ -121,7 +123,7 @@ std::string CreateTrademarkOrderRequest::getTmIcon()const
void CreateTrademarkOrderRequest::setTmIcon(const std::string& tmIcon)
{
tmIcon_ = tmIcon;
setCoreParameter("TmIcon", tmIcon);
setParameter("TmIcon", tmIcon);
}
std::string CreateTrademarkOrderRequest::getUid()const
@@ -132,7 +134,7 @@ std::string CreateTrademarkOrderRequest::getUid()const
void CreateTrademarkOrderRequest::setUid(const std::string& uid)
{
uid_ = uid;
setCoreParameter("Uid", uid);
setParameter("Uid", uid);
}
std::string CreateTrademarkOrderRequest::getRenewInfoId()const
@@ -143,7 +145,7 @@ std::string CreateTrademarkOrderRequest::getRenewInfoId()const
void CreateTrademarkOrderRequest::setRenewInfoId(const std::string& renewInfoId)
{
renewInfoId_ = renewInfoId;
setCoreParameter("RenewInfoId", renewInfoId);
setParameter("RenewInfoId", renewInfoId);
}
std::string CreateTrademarkOrderRequest::getRootCode()const
@@ -154,7 +156,7 @@ std::string CreateTrademarkOrderRequest::getRootCode()const
void CreateTrademarkOrderRequest::setRootCode(const std::string& rootCode)
{
rootCode_ = rootCode;
setCoreParameter("RootCode", rootCode);
setParameter("RootCode", rootCode);
}
std::string CreateTrademarkOrderRequest::getLoaOssKey()const
@@ -165,7 +167,7 @@ std::string CreateTrademarkOrderRequest::getLoaOssKey()const
void CreateTrademarkOrderRequest::setLoaOssKey(const std::string& loaOssKey)
{
loaOssKey_ = loaOssKey;
setCoreParameter("LoaOssKey", loaOssKey);
setParameter("LoaOssKey", loaOssKey);
}
std::string CreateTrademarkOrderRequest::getRegisterNumber()const
@@ -176,7 +178,7 @@ std::string CreateTrademarkOrderRequest::getRegisterNumber()const
void CreateTrademarkOrderRequest::setRegisterNumber(const std::string& registerNumber)
{
registerNumber_ = registerNumber;
setCoreParameter("RegisterNumber", registerNumber);
setParameter("RegisterNumber", registerNumber);
}
std::string CreateTrademarkOrderRequest::getTmName()const
@@ -187,7 +189,7 @@ std::string CreateTrademarkOrderRequest::getTmName()const
void CreateTrademarkOrderRequest::setTmName(const std::string& tmName)
{
tmName_ = tmName;
setCoreParameter("TmName", tmName);
setParameter("TmName", tmName);
}
std::string CreateTrademarkOrderRequest::getPartnerCode()const
@@ -198,7 +200,7 @@ std::string CreateTrademarkOrderRequest::getPartnerCode()const
void CreateTrademarkOrderRequest::setPartnerCode(const std::string& partnerCode)
{
partnerCode_ = partnerCode;
setCoreParameter("PartnerCode", partnerCode);
setParameter("PartnerCode", partnerCode);
}
std::string CreateTrademarkOrderRequest::getPhoneNum()const
@@ -209,7 +211,7 @@ std::string CreateTrademarkOrderRequest::getPhoneNum()const
void CreateTrademarkOrderRequest::setPhoneNum(const std::string& phoneNum)
{
phoneNum_ = phoneNum;
setCoreParameter("PhoneNum", phoneNum);
setParameter("PhoneNum", phoneNum);
}
std::string CreateTrademarkOrderRequest::getRegisterName()const
@@ -220,7 +222,7 @@ std::string CreateTrademarkOrderRequest::getRegisterName()const
void CreateTrademarkOrderRequest::setRegisterName(const std::string& registerName)
{
registerName_ = registerName;
setCoreParameter("RegisterName", registerName);
setParameter("RegisterName", registerName);
}
bool CreateTrademarkOrderRequest::getIsBlackIcon()const
@@ -231,7 +233,7 @@ bool CreateTrademarkOrderRequest::getIsBlackIcon()const
void CreateTrademarkOrderRequest::setIsBlackIcon(bool isBlackIcon)
{
isBlackIcon_ = isBlackIcon;
setCoreParameter("IsBlackIcon", isBlackIcon ? "true" : "false");
setParameter("IsBlackIcon", isBlackIcon ? "true" : "false");
}
std::string CreateTrademarkOrderRequest::getBizId()const
@@ -242,6 +244,6 @@ std::string CreateTrademarkOrderRequest::getBizId()const
void CreateTrademarkOrderRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setCoreParameter("BizId", bizId);
setParameter("BizId", bizId);
}

6
trademark/src/model/DeleteMaterialRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::DeleteMaterialRequest;
DeleteMaterialRequest::DeleteMaterialRequest() :
RpcServiceRequest("trademark", "2018-07-24", "DeleteMaterial")
{}
{
setMethod(HttpRequest::Method::Post);
}
DeleteMaterialRequest::~DeleteMaterialRequest()
{}
@@ -33,6 +35,6 @@ long DeleteMaterialRequest::getId()const
void DeleteMaterialRequest::setId(long id)
{
id_ = id;
setCoreParameter("Id", std::to_string(id));
setParameter("Id", std::to_string(id));
}

6
trademark/src/model/DeleteTmMonitorRuleRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::DeleteTmMonitorRuleRequest;
DeleteTmMonitorRuleRequest::DeleteTmMonitorRuleRequest() :
RpcServiceRequest("trademark", "2018-07-24", "DeleteTmMonitorRule")
{}
{
setMethod(HttpRequest::Method::Post);
}
DeleteTmMonitorRuleRequest::~DeleteTmMonitorRuleRequest()
{}
@@ -33,6 +35,6 @@ long DeleteTmMonitorRuleRequest::getId()const
void DeleteTmMonitorRuleRequest::setId(long id)
{
id_ = id;
setCoreParameter("Id", std::to_string(id));
setParameter("Id", std::to_string(id));
}

6
trademark/src/model/DenySupplementRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::DenySupplementRequest;
DenySupplementRequest::DenySupplementRequest() :
RpcServiceRequest("trademark", "2018-07-24", "DenySupplement")
{}
{
setMethod(HttpRequest::Method::Post);
}
DenySupplementRequest::~DenySupplementRequest()
{}
@@ -33,6 +35,6 @@ long DenySupplementRequest::getId()const
void DenySupplementRequest::setId(long id)
{
id_ = id;
setCoreParameter("Id", std::to_string(id));
setParameter("Id", std::to_string(id));
}

128
trademark/src/model/DescirbeCombineTrademarkRequest.cc Normal file
View File

@@ -0,0 +1,128 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/trademark/model/DescirbeCombineTrademarkRequest.h>
using AlibabaCloud::Trademark::Model::DescirbeCombineTrademarkRequest;
DescirbeCombineTrademarkRequest::DescirbeCombineTrademarkRequest() :
RpcServiceRequest("trademark", "2018-07-24", "DescirbeCombineTrademark")
{
setMethod(HttpRequest::Method::Post);
}
DescirbeCombineTrademarkRequest::~DescirbeCombineTrademarkRequest()
{}
std::string DescirbeCombineTrademarkRequest::getOwnerName()const
{
return ownerName_;
}
void DescirbeCombineTrademarkRequest::setOwnerName(const std::string& ownerName)
{
ownerName_ = ownerName;
setParameter("OwnerName", ownerName);
}
std::string DescirbeCombineTrademarkRequest::getClassification()const
{
return classification_;
}
void DescirbeCombineTrademarkRequest::setClassification(const std::string& classification)
{
classification_ = classification;
setParameter("Classification", classification);
}
std::string DescirbeCombineTrademarkRequest::getRegistrationNumber()const
{
return registrationNumber_;
}
void DescirbeCombineTrademarkRequest::setRegistrationNumber(const std::string& registrationNumber)
{
registrationNumber_ = registrationNumber;
setParameter("RegistrationNumber", registrationNumber);
}
bool DescirbeCombineTrademarkRequest::getAccurateMatch()const
{
return accurateMatch_;
}
void DescirbeCombineTrademarkRequest::setAccurateMatch(bool accurateMatch)
{
accurateMatch_ = accurateMatch;
setParameter("AccurateMatch", accurateMatch ? "true" : "false");
}
int DescirbeCombineTrademarkRequest::getPageNumber()const
{
return pageNumber_;
}
void DescirbeCombineTrademarkRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescirbeCombineTrademarkRequest::getProducts()const
{
return products_;
}
void DescirbeCombineTrademarkRequest::setProducts(const std::string& products)
{
products_ = products;
setParameter("Products", products);
}
std::string DescirbeCombineTrademarkRequest::getSimilarGroups()const
{
return similarGroups_;
}
void DescirbeCombineTrademarkRequest::setSimilarGroups(const std::string& similarGroups)
{
similarGroups_ = similarGroups;
setParameter("SimilarGroups", similarGroups);
}
std::string DescirbeCombineTrademarkRequest::getName()const
{
return name_;
}
void DescirbeCombineTrademarkRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
int DescirbeCombineTrademarkRequest::getPageSize()const
{
return pageSize_;
}
void DescirbeCombineTrademarkRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}

193
trademark/src/model/DescirbeCombineTrademarkResult.cc Normal file
View File

@@ -0,0 +1,193 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/trademark/model/DescirbeCombineTrademarkResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Trademark;
using namespace AlibabaCloud::Trademark::Model;
DescirbeCombineTrademarkResult::DescirbeCombineTrademarkResult() :
ServiceResult()
{}
DescirbeCombineTrademarkResult::DescirbeCombineTrademarkResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescirbeCombineTrademarkResult::~DescirbeCombineTrademarkResult()
{}
void DescirbeCombineTrademarkResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDataNode = value["Data"]["Trademark"];
for (auto valueDataTrademark : allDataNode)
{
Trademark dataObject;
if(!valueDataTrademark["IndexId"].isNull())
dataObject.indexId = valueDataTrademark["IndexId"].asString();
if(!valueDataTrademark["Name"].isNull())
dataObject.name = valueDataTrademark["Name"].asString();
if(!valueDataTrademark["RegistrationNumber"].isNull())
dataObject.registrationNumber = valueDataTrademark["RegistrationNumber"].asString();
if(!valueDataTrademark["Classification"].isNull())
dataObject.classification = valueDataTrademark["Classification"].asString();
if(!valueDataTrademark["ApplyDate"].isNull())
dataObject.applyDate = valueDataTrademark["ApplyDate"].asString();
if(!valueDataTrademark["OwnerName"].isNull())
dataObject.ownerName = valueDataTrademark["OwnerName"].asString();
if(!valueDataTrademark["OwnerEnName"].isNull())
dataObject.ownerEnName = valueDataTrademark["OwnerEnName"].asString();
if(!valueDataTrademark["Image"].isNull())
dataObject.image = valueDataTrademark["Image"].asString();
if(!valueDataTrademark["PreAnnNumber"].isNull())
dataObject.preAnnNumber = valueDataTrademark["PreAnnNumber"].asString();
if(!valueDataTrademark["RegAnnNumber"].isNull())
dataObject.regAnnNumber = valueDataTrademark["RegAnnNumber"].asString();
if(!valueDataTrademark["PreAnnDate"].isNull())
dataObject.preAnnDate = valueDataTrademark["PreAnnDate"].asString();
if(!valueDataTrademark["RegAnnDate"].isNull())
dataObject.regAnnDate = valueDataTrademark["RegAnnDate"].asString();
if(!valueDataTrademark["LawFinalStatus"].isNull())
dataObject.lawFinalStatus = valueDataTrademark["LawFinalStatus"].asString();
if(!valueDataTrademark["LastProcedureStatus"].isNull())
dataObject.lastProcedureStatus = valueDataTrademark["LastProcedureStatus"].asString();
if(!valueDataTrademark["Share"].isNull())
dataObject.share = valueDataTrademark["Share"].asString();
if(!valueDataTrademark["OwnerAddress"].isNull())
dataObject.ownerAddress = valueDataTrademark["OwnerAddress"].asString();
if(!valueDataTrademark["OwnerEnAddress"].isNull())
dataObject.ownerEnAddress = valueDataTrademark["OwnerEnAddress"].asString();
if(!valueDataTrademark["ExclusiveDateLimit"].isNull())
dataObject.exclusiveDateLimit = valueDataTrademark["ExclusiveDateLimit"].asString();
if(!valueDataTrademark["Agency"].isNull())
dataObject.agency = valueDataTrademark["Agency"].asString();
if(!valueDataTrademark["ProductDescription"].isNull())
dataObject.productDescription = valueDataTrademark["ProductDescription"].asString();
if(!valueDataTrademark["SimilarGroup"].isNull())
dataObject.similarGroup = valueDataTrademark["SimilarGroup"].asString();
if(!valueDataTrademark["RegistrationType"].isNull())
dataObject.registrationType = valueDataTrademark["RegistrationType"].asString();
if(!valueDataTrademark["OnSale"].isNull())
dataObject.onSale = std::stoi(valueDataTrademark["OnSale"].asString());
if(!valueDataTrademark["Status"].isNull())
dataObject.status = valueDataTrademark["Status"].asString();
if(!valueDataTrademark["PriorityDate"].isNull())
dataObject.priorityDate = valueDataTrademark["PriorityDate"].asString();
if(!valueDataTrademark["IntlRegDate"].isNull())
dataObject.intlRegDate = valueDataTrademark["IntlRegDate"].asString();
if(!valueDataTrademark["SubsequentDesignationDate"].isNull())
dataObject.subsequentDesignationDate = valueDataTrademark["SubsequentDesignationDate"].asString();
if(!valueDataTrademark["FirstAnnoNumber"].isNull())
dataObject.firstAnnoNumber = valueDataTrademark["FirstAnnoNumber"].asString();
if(!valueDataTrademark["FirstAnnoType"].isNull())
dataObject.firstAnnoType = valueDataTrademark["FirstAnnoType"].asString();
if(!valueDataTrademark["SecondAnnoNumber"].isNull())
dataObject.secondAnnoNumber = valueDataTrademark["SecondAnnoNumber"].asString();
if(!valueDataTrademark["SecondAnnoType"].isNull())
dataObject.secondAnnoType = valueDataTrademark["SecondAnnoType"].asString();
auto allAnnouncementListNode = allDataNode["AnnouncementList"]["AnnouncementListItem"];
for (auto allDataNodeAnnouncementListAnnouncementListItem : allAnnouncementListNode)
{
Trademark::AnnouncementListItem announcementListObject;
if(!allDataNodeAnnouncementListAnnouncementListItem["AnnNumber"].isNull())
announcementListObject.annNumber = allDataNodeAnnouncementListAnnouncementListItem["AnnNumber"].asString();
if(!allDataNodeAnnouncementListAnnouncementListItem["AnnTypeCode"].isNull())
announcementListObject.annTypeCode = allDataNodeAnnouncementListAnnouncementListItem["AnnTypeCode"].asString();
if(!allDataNodeAnnouncementListAnnouncementListItem["AnnTypeName"].isNull())
announcementListObject.annTypeName = allDataNodeAnnouncementListAnnouncementListItem["AnnTypeName"].asString();
if(!allDataNodeAnnouncementListAnnouncementListItem["AnnDate"].isNull())
announcementListObject.annDate = allDataNodeAnnouncementListAnnouncementListItem["AnnDate"].asString();
if(!allDataNodeAnnouncementListAnnouncementListItem["ImageUrl"].isNull())
announcementListObject.imageUrl = allDataNodeAnnouncementListAnnouncementListItem["ImageUrl"].asString();
if(!allDataNodeAnnouncementListAnnouncementListItem["OriginalImageUrl"].isNull())
announcementListObject.originalImageUrl = allDataNodeAnnouncementListAnnouncementListItem["OriginalImageUrl"].asString();
dataObject.announcementList.push_back(announcementListObject);
}
auto allProceduresNode = allDataNode["Procedures"]["ProcedureList"];
for (auto allDataNodeProceduresProcedureList : allProceduresNode)
{
Trademark::ProcedureList proceduresObject;
if(!allDataNodeProceduresProcedureList["ProcedureCode"].isNull())
proceduresObject.procedureCode = allDataNodeProceduresProcedureList["ProcedureCode"].asString();
if(!allDataNodeProceduresProcedureList["ProcedureName"].isNull())
proceduresObject.procedureName = allDataNodeProceduresProcedureList["ProcedureName"].asString();
if(!allDataNodeProceduresProcedureList["ProcedureStep"].isNull())
proceduresObject.procedureStep = allDataNodeProceduresProcedureList["ProcedureStep"].asString();
if(!allDataNodeProceduresProcedureList["ProcedureResult"].isNull())
proceduresObject.procedureResult = allDataNodeProceduresProcedureList["ProcedureResult"].asString();
if(!allDataNodeProceduresProcedureList["ProcedureDate"].isNull())
proceduresObject.procedureDate = allDataNodeProceduresProcedureList["ProcedureDate"].asString();
dataObject.procedures.push_back(proceduresObject);
}
data_.push_back(dataObject);
}
if(!value["TotalItemNumber"].isNull())
totalItemNumber_ = std::stoi(value["TotalItemNumber"].asString());
if(!value["CurrentPageNumber"].isNull())
currentPageNumber_ = std::stoi(value["CurrentPageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalPageNumber"].isNull())
totalPageNumber_ = std::stoi(value["TotalPageNumber"].asString());
if(!value["PrePage"].isNull())
prePage_ = value["PrePage"].asString() == "true";
if(!value["NextPage"].isNull())
nextPage_ = value["NextPage"].asString() == "true";
}
int DescirbeCombineTrademarkResult::getTotalItemNumber()const
{
return totalItemNumber_;
}
bool DescirbeCombineTrademarkResult::getPrePage()const
{
return prePage_;
}
int DescirbeCombineTrademarkResult::getPageSize()const
{
return pageSize_;
}
std::vector<DescirbeCombineTrademarkResult::Trademark> DescirbeCombineTrademarkResult::getData()const
{
return data_;
}
int DescirbeCombineTrademarkResult::getCurrentPageNumber()const
{
return currentPageNumber_;
}
int DescirbeCombineTrademarkResult::getTotalPageNumber()const
{
return totalPageNumber_;
}
bool DescirbeCombineTrademarkResult::getNextPage()const
{
return nextPage_;
}

8
trademark/src/model/FillLogisticsRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::FillLogisticsRequest;
FillLogisticsRequest::FillLogisticsRequest() :
RpcServiceRequest("trademark", "2018-07-24", "FillLogistics")
{}
{
setMethod(HttpRequest::Method::Post);
}
FillLogisticsRequest::~FillLogisticsRequest()
{}
@@ -33,7 +35,7 @@ std::string FillLogisticsRequest::getBizId()const
void FillLogisticsRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setCoreParameter("BizId", bizId);
setParameter("BizId", bizId);
}
std::string FillLogisticsRequest::getLogistics()const
@@ -44,6 +46,6 @@ std::string FillLogisticsRequest::getLogistics()const
void FillLogisticsRequest::setLogistics(const std::string& logistics)
{
logistics_ = logistics;
setCoreParameter("Logistics", logistics);
setParameter("Logistics", logistics);
}

6
trademark/src/model/FilterUnavailableCodesRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::FilterUnavailableCodesRequest;
FilterUnavailableCodesRequest::FilterUnavailableCodesRequest() :
RpcServiceRequest("trademark", "2018-07-24", "FilterUnavailableCodes")
{}
{
setMethod(HttpRequest::Method::Post);
}
FilterUnavailableCodesRequest::~FilterUnavailableCodesRequest()
{}
@@ -33,6 +35,6 @@ std::string FilterUnavailableCodesRequest::getCodes()const
void FilterUnavailableCodesRequest::setCodes(const std::string& codes)
{
codes_ = codes;
setCoreParameter("Codes", codes);
setParameter("Codes", codes);
}

10
trademark/src/model/GenerateQrCodeRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::GenerateQrCodeRequest;
GenerateQrCodeRequest::GenerateQrCodeRequest() :
RpcServiceRequest("trademark", "2018-07-24", "GenerateQrCode")
{}
{
setMethod(HttpRequest::Method::Post);
}
GenerateQrCodeRequest::~GenerateQrCodeRequest()
{}
@@ -33,7 +35,7 @@ std::string GenerateQrCodeRequest::getOssKey()const
void GenerateQrCodeRequest::setOssKey(const std::string& ossKey)
{
ossKey_ = ossKey;
setCoreParameter("OssKey", ossKey);
setParameter("OssKey", ossKey);
}
std::string GenerateQrCodeRequest::getFieldKey()const
@@ -44,7 +46,7 @@ std::string GenerateQrCodeRequest::getFieldKey()const
void GenerateQrCodeRequest::setFieldKey(const std::string& fieldKey)
{
fieldKey_ = fieldKey;
setCoreParameter("FieldKey", fieldKey);
setParameter("FieldKey", fieldKey);
}
std::string GenerateQrCodeRequest::getUuid()const
@@ -55,6 +57,6 @@ std::string GenerateQrCodeRequest::getUuid()const
void GenerateQrCodeRequest::setUuid(const std::string& uuid)
{
uuid_ = uuid;
setCoreParameter("Uuid", uuid);
setParameter("Uuid", uuid);
}

8
trademark/src/model/GenerateUploadFilePolicyRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::GenerateUploadFilePolicyRequest;
GenerateUploadFilePolicyRequest::GenerateUploadFilePolicyRequest() :
RpcServiceRequest("trademark", "2018-07-24", "GenerateUploadFilePolicy")
{}
{
setMethod(HttpRequest::Method::Post);
}
GenerateUploadFilePolicyRequest::~GenerateUploadFilePolicyRequest()
{}
@@ -33,7 +35,7 @@ std::string GenerateUploadFilePolicyRequest::getFileType()const
void GenerateUploadFilePolicyRequest::setFileType(const std::string& fileType)
{
fileType_ = fileType;
setCoreParameter("FileType", fileType);
setParameter("FileType", fileType);
}
std::string GenerateUploadFilePolicyRequest::getBizId()const
@@ -44,6 +46,6 @@ std::string GenerateUploadFilePolicyRequest::getBizId()const
void GenerateUploadFilePolicyRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setCoreParameter("BizId", bizId);
setParameter("BizId", bizId);
}

6
trademark/src/model/GetNotaryOrderRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::GetNotaryOrderRequest;
GetNotaryOrderRequest::GetNotaryOrderRequest() :
RpcServiceRequest("trademark", "2018-07-24", "GetNotaryOrder")
{}
{
setMethod(HttpRequest::Method::Post);
}
GetNotaryOrderRequest::~GetNotaryOrderRequest()
{}
@@ -33,6 +35,6 @@ long GetNotaryOrderRequest::getNotaryOrderId()const
void GetNotaryOrderRequest::setNotaryOrderId(long notaryOrderId)
{
notaryOrderId_ = notaryOrderId;
setCoreParameter("NotaryOrderId", std::to_string(notaryOrderId));
setParameter("NotaryOrderId", std::to_string(notaryOrderId));
}

46
trademark/src/model/InsertMaterialRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::InsertMaterialRequest;
InsertMaterialRequest::InsertMaterialRequest() :
RpcServiceRequest("trademark", "2018-07-24", "InsertMaterial")
{}
{
setMethod(HttpRequest::Method::Post);
}
InsertMaterialRequest::~InsertMaterialRequest()
{}
@@ -33,7 +35,7 @@ std::string InsertMaterialRequest::getContactEmail()const
void InsertMaterialRequest::setContactEmail(const std::string& contactEmail)
{
contactEmail_ = contactEmail;
setCoreParameter("ContactEmail", contactEmail);
setParameter("ContactEmail", contactEmail);
}
std::string InsertMaterialRequest::getEAddress()const
@@ -44,7 +46,7 @@ std::string InsertMaterialRequest::getEAddress()const
void InsertMaterialRequest::setEAddress(const std::string& eAddress)
{
eAddress_ = eAddress;
setCoreParameter("EAddress", eAddress);
setParameter("EAddress", eAddress);
}
std::string InsertMaterialRequest::getCountry()const
@@ -55,7 +57,7 @@ std::string InsertMaterialRequest::getCountry()const
void InsertMaterialRequest::setCountry(const std::string& country)
{
country_ = country;
setCoreParameter("Country", country);
setParameter("Country", country);
}
std::string InsertMaterialRequest::getLegalNoticeOssKey()const
@@ -66,7 +68,7 @@ std::string InsertMaterialRequest::getLegalNoticeOssKey()const
void InsertMaterialRequest::setLegalNoticeOssKey(const std::string& legalNoticeOssKey)
{
legalNoticeOssKey_ = legalNoticeOssKey;
setCoreParameter("LegalNoticeOssKey", legalNoticeOssKey);
setParameter("LegalNoticeOssKey", legalNoticeOssKey);
}
std::string InsertMaterialRequest::getContactNumber()const
@@ -77,7 +79,7 @@ std::string InsertMaterialRequest::getContactNumber()const
void InsertMaterialRequest::setContactNumber(const std::string& contactNumber)
{
contactNumber_ = contactNumber;
setCoreParameter("ContactNumber", contactNumber);
setParameter("ContactNumber", contactNumber);
}
std::string InsertMaterialRequest::getCity()const
@@ -88,7 +90,7 @@ std::string InsertMaterialRequest::getCity()const
void InsertMaterialRequest::setCity(const std::string& city)
{
city_ = city;
setCoreParameter("City", city);
setParameter("City", city);
}
int InsertMaterialRequest::getType()const
@@ -99,7 +101,7 @@ int InsertMaterialRequest::getType()const
void InsertMaterialRequest::setType(int type)
{
type_ = type;
setCoreParameter("Type", std::to_string(type));
setParameter("Type", std::to_string(type));
}
std::string InsertMaterialRequest::getContactName()const
@@ -110,7 +112,7 @@ std::string InsertMaterialRequest::getContactName()const
void InsertMaterialRequest::setContactName(const std::string& contactName)
{
contactName_ = contactName;
setCoreParameter("ContactName", contactName);
setParameter("ContactName", contactName);
}
std::string InsertMaterialRequest::getPassportOssKey()const
@@ -121,7 +123,7 @@ std::string InsertMaterialRequest::getPassportOssKey()const
void InsertMaterialRequest::setPassportOssKey(const std::string& passportOssKey)
{
passportOssKey_ = passportOssKey;
setCoreParameter("PassportOssKey", passportOssKey);
setParameter("PassportOssKey", passportOssKey);
}
std::string InsertMaterialRequest::getProvince()const
@@ -132,7 +134,7 @@ std::string InsertMaterialRequest::getProvince()const
void InsertMaterialRequest::setProvince(const std::string& province)
{
province_ = province;
setCoreParameter("Province", province);
setParameter("Province", province);
}
std::string InsertMaterialRequest::getLoaOssKey()const
@@ -143,7 +145,7 @@ std::string InsertMaterialRequest::getLoaOssKey()const
void InsertMaterialRequest::setLoaOssKey(const std::string& loaOssKey)
{
loaOssKey_ = loaOssKey;
setCoreParameter("LoaOssKey", loaOssKey);
setParameter("LoaOssKey", loaOssKey);
}
std::string InsertMaterialRequest::getContactAddress()const
@@ -154,7 +156,7 @@ std::string InsertMaterialRequest::getContactAddress()const
void InsertMaterialRequest::setContactAddress(const std::string& contactAddress)
{
contactAddress_ = contactAddress;
setCoreParameter("ContactAddress", contactAddress);
setParameter("ContactAddress", contactAddress);
}
std::string InsertMaterialRequest::getAddress()const
@@ -165,7 +167,7 @@ std::string InsertMaterialRequest::getAddress()const
void InsertMaterialRequest::setAddress(const std::string& address)
{
address_ = address;
setCoreParameter("Address", address);
setParameter("Address", address);
}
std::string InsertMaterialRequest::getTown()const
@@ -176,7 +178,7 @@ std::string InsertMaterialRequest::getTown()const
void InsertMaterialRequest::setTown(const std::string& town)
{
town_ = town;
setCoreParameter("Town", town);
setParameter("Town", town);
}
std::string InsertMaterialRequest::getIdCardOssKey()const
@@ -187,7 +189,7 @@ std::string InsertMaterialRequest::getIdCardOssKey()const
void InsertMaterialRequest::setIdCardOssKey(const std::string& idCardOssKey)
{
idCardOssKey_ = idCardOssKey;
setCoreParameter("IdCardOssKey", idCardOssKey);
setParameter("IdCardOssKey", idCardOssKey);
}
std::string InsertMaterialRequest::getContactZipcode()const
@@ -198,7 +200,7 @@ std::string InsertMaterialRequest::getContactZipcode()const
void InsertMaterialRequest::setContactZipcode(const std::string& contactZipcode)
{
contactZipcode_ = contactZipcode;
setCoreParameter("ContactZipcode", contactZipcode);
setParameter("ContactZipcode", contactZipcode);
}
std::string InsertMaterialRequest::getEName()const
@@ -209,7 +211,7 @@ std::string InsertMaterialRequest::getEName()const
void InsertMaterialRequest::setEName(const std::string& eName)
{
eName_ = eName;
setCoreParameter("EName", eName);
setParameter("EName", eName);
}
std::string InsertMaterialRequest::getBusinessLicenceOssKey()const
@@ -220,7 +222,7 @@ std::string InsertMaterialRequest::getBusinessLicenceOssKey()const
void InsertMaterialRequest::setBusinessLicenceOssKey(const std::string& businessLicenceOssKey)
{
businessLicenceOssKey_ = businessLicenceOssKey;
setCoreParameter("BusinessLicenceOssKey", businessLicenceOssKey);
setParameter("BusinessLicenceOssKey", businessLicenceOssKey);
}
std::string InsertMaterialRequest::getName()const
@@ -231,7 +233,7 @@ std::string InsertMaterialRequest::getName()const
void InsertMaterialRequest::setName(const std::string& name)
{
name_ = name;
setCoreParameter("Name", name);
setParameter("Name", name);
}
std::string InsertMaterialRequest::getCardNumber()const
@@ -242,7 +244,7 @@ std::string InsertMaterialRequest::getCardNumber()const
void InsertMaterialRequest::setCardNumber(const std::string& cardNumber)
{
cardNumber_ = cardNumber;
setCoreParameter("CardNumber", cardNumber);
setParameter("CardNumber", cardNumber);
}
int InsertMaterialRequest::getRegion()const
@@ -253,6 +255,6 @@ int InsertMaterialRequest::getRegion()const
void InsertMaterialRequest::setRegion(int region)
{
region_ = region;
setCoreParameter("Region", std::to_string(region));
setParameter("Region", std::to_string(region));
}

14
trademark/src/model/InsertRenewInfoRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::InsertRenewInfoRequest;
InsertRenewInfoRequest::InsertRenewInfoRequest() :
RpcServiceRequest("trademark", "2018-07-24", "InsertRenewInfo")
{}
{
setMethod(HttpRequest::Method::Post);
}
InsertRenewInfoRequest::~InsertRenewInfoRequest()
{}
@@ -33,7 +35,7 @@ std::string InsertRenewInfoRequest::getEngName()const
void InsertRenewInfoRequest::setEngName(const std::string& engName)
{
engName_ = engName;
setCoreParameter("EngName", engName);
setParameter("EngName", engName);
}
std::string InsertRenewInfoRequest::getAddress()const
@@ -44,7 +46,7 @@ std::string InsertRenewInfoRequest::getAddress()const
void InsertRenewInfoRequest::setAddress(const std::string& address)
{
address_ = address;
setCoreParameter("Address", address);
setParameter("Address", address);
}
long InsertRenewInfoRequest::getRegisterTime()const
@@ -55,7 +57,7 @@ long InsertRenewInfoRequest::getRegisterTime()const
void InsertRenewInfoRequest::setRegisterTime(long registerTime)
{
registerTime_ = registerTime;
setCoreParameter("RegisterTime", std::to_string(registerTime));
setParameter("RegisterTime", std::to_string(registerTime));
}
std::string InsertRenewInfoRequest::getEngAddress()const
@@ -66,7 +68,7 @@ std::string InsertRenewInfoRequest::getEngAddress()const
void InsertRenewInfoRequest::setEngAddress(const std::string& engAddress)
{
engAddress_ = engAddress;
setCoreParameter("EngAddress", engAddress);
setParameter("EngAddress", engAddress);
}
std::string InsertRenewInfoRequest::getName()const
@@ -77,6 +79,6 @@ std::string InsertRenewInfoRequest::getName()const
void InsertRenewInfoRequest::setName(const std::string& name)
{
name_ = name;
setCoreParameter("Name", name);
setParameter("Name", name);
}

20
trademark/src/model/InsertTmMonitorRuleRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::InsertTmMonitorRuleRequest;
InsertTmMonitorRuleRequest::InsertTmMonitorRuleRequest() :
RpcServiceRequest("trademark", "2018-07-24", "InsertTmMonitorRule")
{}
{
setMethod(HttpRequest::Method::Post);
}
InsertTmMonitorRuleRequest::~InsertTmMonitorRuleRequest()
{}
@@ -33,7 +35,7 @@ std::string InsertTmMonitorRuleRequest::getStartApplyDate()const
void InsertTmMonitorRuleRequest::setStartApplyDate(const std::string& startApplyDate)
{
startApplyDate_ = startApplyDate;
setCoreParameter("StartApplyDate", startApplyDate);
setParameter("StartApplyDate", startApplyDate);
}
int InsertTmMonitorRuleRequest::getRuleType()const
@@ -44,7 +46,7 @@ int InsertTmMonitorRuleRequest::getRuleType()const
void InsertTmMonitorRuleRequest::setRuleType(int ruleType)
{
ruleType_ = ruleType;
setCoreParameter("RuleType", std::to_string(ruleType));
setParameter("RuleType", std::to_string(ruleType));
}
std::string InsertTmMonitorRuleRequest::getRuleSource()const
@@ -55,7 +57,7 @@ std::string InsertTmMonitorRuleRequest::getRuleSource()const
void InsertTmMonitorRuleRequest::setRuleSource(const std::string& ruleSource)
{
ruleSource_ = ruleSource;
setCoreParameter("RuleSource", ruleSource);
setParameter("RuleSource", ruleSource);
}
std::string InsertTmMonitorRuleRequest::getRuleName()const
@@ -66,7 +68,7 @@ std::string InsertTmMonitorRuleRequest::getRuleName()const
void InsertTmMonitorRuleRequest::setRuleName(const std::string& ruleName)
{
ruleName_ = ruleName;
setCoreParameter("RuleName", ruleName);
setParameter("RuleName", ruleName);
}
std::string InsertTmMonitorRuleRequest::getClassification()const
@@ -77,7 +79,7 @@ std::string InsertTmMonitorRuleRequest::getClassification()const
void InsertTmMonitorRuleRequest::setClassification(const std::string& classification)
{
classification_ = classification;
setCoreParameter("Classification", classification);
setParameter("Classification", classification);
}
std::string InsertTmMonitorRuleRequest::getNotifyStatus()const
@@ -88,7 +90,7 @@ std::string InsertTmMonitorRuleRequest::getNotifyStatus()const
void InsertTmMonitorRuleRequest::setNotifyStatus(const std::string& notifyStatus)
{
notifyStatus_ = notifyStatus;
setCoreParameter("NotifyStatus", notifyStatus);
setParameter("NotifyStatus", notifyStatus);
}
std::string InsertTmMonitorRuleRequest::getEndApplyDate()const
@@ -99,7 +101,7 @@ std::string InsertTmMonitorRuleRequest::getEndApplyDate()const
void InsertTmMonitorRuleRequest::setEndApplyDate(const std::string& endApplyDate)
{
endApplyDate_ = endApplyDate;
setCoreParameter("EndApplyDate", endApplyDate);
setParameter("EndApplyDate", endApplyDate);
}
std::string InsertTmMonitorRuleRequest::getRuleKeyword()const
@@ -110,6 +112,6 @@ std::string InsertTmMonitorRuleRequest::getRuleKeyword()const
void InsertTmMonitorRuleRequest::setRuleKeyword(const std::string& ruleKeyword)
{
ruleKeyword_ = ruleKeyword;
setCoreParameter("RuleKeyword", ruleKeyword);
setParameter("RuleKeyword", ruleKeyword);
}

20
trademark/src/model/InsertTradeIntentionUserRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::InsertTradeIntentionUserRequest;
InsertTradeIntentionUserRequest::InsertTradeIntentionUserRequest() :
RpcServiceRequest("trademark", "2018-07-24", "InsertTradeIntentionUser")
{}
{
setMethod(HttpRequest::Method::Post);
}
InsertTradeIntentionUserRequest::~InsertTradeIntentionUserRequest()
{}
@@ -33,7 +35,7 @@ std::string InsertTradeIntentionUserRequest::getMobile()const
void InsertTradeIntentionUserRequest::setMobile(const std::string& mobile)
{
mobile_ = mobile;
setCoreParameter("Mobile", mobile);
setParameter("Mobile", mobile);
}
std::string InsertTradeIntentionUserRequest::getDescription()const
@@ -44,7 +46,7 @@ std::string InsertTradeIntentionUserRequest::getDescription()const
void InsertTradeIntentionUserRequest::setDescription(const std::string& description)
{
description_ = description;
setCoreParameter("Description", description);
setParameter("Description", description);
}
std::string InsertTradeIntentionUserRequest::getPartnerCode()const
@@ -55,7 +57,7 @@ std::string InsertTradeIntentionUserRequest::getPartnerCode()const
void InsertTradeIntentionUserRequest::setPartnerCode(const std::string& partnerCode)
{
partnerCode_ = partnerCode;
setCoreParameter("PartnerCode", partnerCode);
setParameter("PartnerCode", partnerCode);
}
std::string InsertTradeIntentionUserRequest::getClassification()const
@@ -66,7 +68,7 @@ std::string InsertTradeIntentionUserRequest::getClassification()const
void InsertTradeIntentionUserRequest::setClassification(const std::string& classification)
{
classification_ = classification;
setCoreParameter("Classification", classification);
setParameter("Classification", classification);
}
int InsertTradeIntentionUserRequest::getType()const
@@ -77,7 +79,7 @@ int InsertTradeIntentionUserRequest::getType()const
void InsertTradeIntentionUserRequest::setType(int type)
{
type_ = type;
setCoreParameter("Type", std::to_string(type));
setParameter("Type", std::to_string(type));
}
std::string InsertTradeIntentionUserRequest::getVcode()const
@@ -88,7 +90,7 @@ std::string InsertTradeIntentionUserRequest::getVcode()const
void InsertTradeIntentionUserRequest::setVcode(const std::string& vcode)
{
vcode_ = vcode;
setCoreParameter("Vcode", vcode);
setParameter("Vcode", vcode);
}
std::string InsertTradeIntentionUserRequest::getRegisterNumber()const
@@ -99,7 +101,7 @@ std::string InsertTradeIntentionUserRequest::getRegisterNumber()const
void InsertTradeIntentionUserRequest::setRegisterNumber(const std::string& registerNumber)
{
registerNumber_ = registerNumber;
setCoreParameter("RegisterNumber", registerNumber);
setParameter("RegisterNumber", registerNumber);
}
std::string InsertTradeIntentionUserRequest::getUserName()const
@@ -110,6 +112,6 @@ std::string InsertTradeIntentionUserRequest::getUserName()const
void InsertTradeIntentionUserRequest::setUserName(const std::string& userName)
{
userName_ = userName;
setCoreParameter("UserName", userName);
setParameter("UserName", userName);
}

14
trademark/src/model/ListNotaryInfosRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::ListNotaryInfosRequest;
ListNotaryInfosRequest::ListNotaryInfosRequest() :
RpcServiceRequest("trademark", "2018-07-24", "ListNotaryInfos")
{}
{
setMethod(HttpRequest::Method::Post);
}
ListNotaryInfosRequest::~ListNotaryInfosRequest()
{}
@@ -33,7 +35,7 @@ std::string ListNotaryInfosRequest::getBizOrderNo()const
void ListNotaryInfosRequest::setBizOrderNo(const std::string& bizOrderNo)
{
bizOrderNo_ = bizOrderNo;
setCoreParameter("BizOrderNo", bizOrderNo);
setParameter("BizOrderNo", bizOrderNo);
}
int ListNotaryInfosRequest::getNotaryType()const
@@ -44,7 +46,7 @@ int ListNotaryInfosRequest::getNotaryType()const
void ListNotaryInfosRequest::setNotaryType(int notaryType)
{
notaryType_ = notaryType;
setCoreParameter("NotaryType", std::to_string(notaryType));
setParameter("NotaryType", std::to_string(notaryType));
}
int ListNotaryInfosRequest::getPageSize()const
@@ -55,7 +57,7 @@ int ListNotaryInfosRequest::getPageSize()const
void ListNotaryInfosRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
setParameter("PageSize", std::to_string(pageSize));
}
int ListNotaryInfosRequest::getPageNum()const
@@ -66,7 +68,7 @@ int ListNotaryInfosRequest::getPageNum()const
void ListNotaryInfosRequest::setPageNum(int pageNum)
{
pageNum_ = pageNum;
setCoreParameter("PageNum", std::to_string(pageNum));
setParameter("PageNum", std::to_string(pageNum));
}
std::string ListNotaryInfosRequest::getToken()const
@@ -77,6 +79,6 @@ std::string ListNotaryInfosRequest::getToken()const
void ListNotaryInfosRequest::setToken(const std::string& token)
{
token_ = token;
setCoreParameter("Token", token);
setParameter("Token", token);
}

24
trademark/src/model/ListNotaryOrdersRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::ListNotaryOrdersRequest;
ListNotaryOrdersRequest::ListNotaryOrdersRequest() :
RpcServiceRequest("trademark", "2018-07-24", "ListNotaryOrders")
{}
{
setMethod(HttpRequest::Method::Post);
}
ListNotaryOrdersRequest::~ListNotaryOrdersRequest()
{}
@@ -33,7 +35,7 @@ long ListNotaryOrdersRequest::getStartOrderDate()const
void ListNotaryOrdersRequest::setStartOrderDate(long startOrderDate)
{
startOrderDate_ = startOrderDate;
setCoreParameter("StartOrderDate", std::to_string(startOrderDate));
setParameter("StartOrderDate", std::to_string(startOrderDate));
}
int ListNotaryOrdersRequest::getNotaryType()const
@@ -44,7 +46,7 @@ int ListNotaryOrdersRequest::getNotaryType()const
void ListNotaryOrdersRequest::setNotaryType(int notaryType)
{
notaryType_ = notaryType;
setCoreParameter("NotaryType", std::to_string(notaryType));
setParameter("NotaryType", std::to_string(notaryType));
}
int ListNotaryOrdersRequest::getPageNum()const
@@ -55,7 +57,7 @@ int ListNotaryOrdersRequest::getPageNum()const
void ListNotaryOrdersRequest::setPageNum(int pageNum)
{
pageNum_ = pageNum;
setCoreParameter("PageNum", std::to_string(pageNum));
setParameter("PageNum", std::to_string(pageNum));
}
int ListNotaryOrdersRequest::getSortKeyType()const
@@ -66,7 +68,7 @@ int ListNotaryOrdersRequest::getSortKeyType()const
void ListNotaryOrdersRequest::setSortKeyType(int sortKeyType)
{
sortKeyType_ = sortKeyType;
setCoreParameter("SortKeyType", std::to_string(sortKeyType));
setParameter("SortKeyType", std::to_string(sortKeyType));
}
std::string ListNotaryOrdersRequest::getSortByType()const
@@ -77,7 +79,7 @@ std::string ListNotaryOrdersRequest::getSortByType()const
void ListNotaryOrdersRequest::setSortByType(const std::string& sortByType)
{
sortByType_ = sortByType;
setCoreParameter("SortByType", sortByType);
setParameter("SortByType", sortByType);
}
int ListNotaryOrdersRequest::getPageSize()const
@@ -88,7 +90,7 @@ int ListNotaryOrdersRequest::getPageSize()const
void ListNotaryOrdersRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
setParameter("PageSize", std::to_string(pageSize));
}
std::string ListNotaryOrdersRequest::getBizId()const
@@ -99,7 +101,7 @@ std::string ListNotaryOrdersRequest::getBizId()const
void ListNotaryOrdersRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setCoreParameter("BizId", bizId);
setParameter("BizId", bizId);
}
long ListNotaryOrdersRequest::getEndOrderDate()const
@@ -110,7 +112,7 @@ long ListNotaryOrdersRequest::getEndOrderDate()const
void ListNotaryOrdersRequest::setEndOrderDate(long endOrderDate)
{
endOrderDate_ = endOrderDate;
setCoreParameter("EndOrderDate", std::to_string(endOrderDate));
setParameter("EndOrderDate", std::to_string(endOrderDate));
}
std::string ListNotaryOrdersRequest::getAliyunOrderId()const
@@ -121,7 +123,7 @@ std::string ListNotaryOrdersRequest::getAliyunOrderId()const
void ListNotaryOrdersRequest::setAliyunOrderId(const std::string& aliyunOrderId)
{
aliyunOrderId_ = aliyunOrderId;
setCoreParameter("AliyunOrderId", aliyunOrderId);
setParameter("AliyunOrderId", aliyunOrderId);
}
int ListNotaryOrdersRequest::getNotaryStatus()const
@@ -132,6 +134,6 @@ int ListNotaryOrdersRequest::getNotaryStatus()const
void ListNotaryOrdersRequest::setNotaryStatus(int notaryStatus)
{
notaryStatus_ = notaryStatus;
setCoreParameter("NotaryStatus", std::to_string(notaryStatus));
setParameter("NotaryStatus", std::to_string(notaryStatus));
}

12
trademark/src/model/QueryCommunicationLogsRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::QueryCommunicationLogsRequest;
QueryCommunicationLogsRequest::QueryCommunicationLogsRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QueryCommunicationLogs")
{}
{
setMethod(HttpRequest::Method::Post);
}
QueryCommunicationLogsRequest::~QueryCommunicationLogsRequest()
{}
@@ -33,7 +35,7 @@ std::string QueryCommunicationLogsRequest::getBizId()const
void QueryCommunicationLogsRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setCoreParameter("BizId", bizId);
setParameter("BizId", bizId);
}
int QueryCommunicationLogsRequest::getPageSize()const
@@ -44,7 +46,7 @@ int QueryCommunicationLogsRequest::getPageSize()const
void QueryCommunicationLogsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
setParameter("PageSize", std::to_string(pageSize));
}
int QueryCommunicationLogsRequest::getType()const
@@ -55,7 +57,7 @@ int QueryCommunicationLogsRequest::getType()const
void QueryCommunicationLogsRequest::setType(int type)
{
type_ = type;
setCoreParameter("Type", std::to_string(type));
setParameter("Type", std::to_string(type));
}
int QueryCommunicationLogsRequest::getPageNum()const
@@ -66,6 +68,6 @@ int QueryCommunicationLogsRequest::getPageNum()const
void QueryCommunicationLogsRequest::setPageNum(int pageNum)
{
pageNum_ = pageNum;
setCoreParameter("PageNum", std::to_string(pageNum));
setParameter("PageNum", std::to_string(pageNum));
}

10
trademark/src/model/QueryCredentialsInfoRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::QueryCredentialsInfoRequest;
QueryCredentialsInfoRequest::QueryCredentialsInfoRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QueryCredentialsInfo")
{}
{
setMethod(HttpRequest::Method::Post);
}
QueryCredentialsInfoRequest::~QueryCredentialsInfoRequest()
{}
@@ -33,7 +35,7 @@ std::string QueryCredentialsInfoRequest::getOssKey()const
void QueryCredentialsInfoRequest::setOssKey(const std::string& ossKey)
{
ossKey_ = ossKey;
setCoreParameter("OssKey", ossKey);
setBodyParameter("OssKey", ossKey);
}
std::string QueryCredentialsInfoRequest::getMaterialType()const
@@ -44,7 +46,7 @@ std::string QueryCredentialsInfoRequest::getMaterialType()const
void QueryCredentialsInfoRequest::setMaterialType(const std::string& materialType)
{
materialType_ = materialType;
setCoreParameter("MaterialType", materialType);
setBodyParameter("MaterialType", materialType);
}
std::string QueryCredentialsInfoRequest::getCompanyName()const
@@ -55,6 +57,6 @@ std::string QueryCredentialsInfoRequest::getCompanyName()const
void QueryCredentialsInfoRequest::setCompanyName(const std::string& companyName)
{
companyName_ = companyName;
setCoreParameter("CompanyName", companyName);
setParameter("CompanyName", companyName);
}

26
trademark/src/model/QueryIntentionDetailRequest.cc
View File

@@ -20,19 +20,21 @@ using AlibabaCloud::Trademark::Model::QueryIntentionDetailRequest;
QueryIntentionDetailRequest::QueryIntentionDetailRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QueryIntentionDetail")
{}
{
setMethod(HttpRequest::Method::Post);
}
QueryIntentionDetailRequest::~QueryIntentionDetailRequest()
{}
std::string QueryIntentionDetailRequest::getBizId()const
{
return bizId_;
}
void QueryIntentionDetailRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setCoreParameter("BizId", bizId);
}
std::string QueryIntentionDetailRequest::getBizId()const
{
return bizId_;
}
void QueryIntentionDetailRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setParameter("BizId", bizId);
}

48
trademark/src/model/QueryIntentionDetailResult.cc
View File

@@ -61,6 +61,10 @@ void QueryIntentionDetailResult::parse(const std::string &payload)
mobile_ = value["Mobile"].asString();
if(!value["UserName"].isNull())
userName_ = value["UserName"].asString();
if(!value["RelationBizId"].isNull())
relationBizId_ = value["RelationBizId"].asString();
if(!value["PartnerMobile"].isNull())
partnerMobile_ = value["PartnerMobile"].asString();
}
@@ -69,16 +73,6 @@ int QueryIntentionDetailResult::getStatus()const
return status_;
}
std::string QueryIntentionDetailResult::getRegisterNumber()const
{
return registerNumber_;
}
int QueryIntentionDetailResult::getType()const
{
return type_;
}
std::string QueryIntentionDetailResult::getDescription()const
{
return description_;
@@ -89,6 +83,31 @@ std::string QueryIntentionDetailResult::getUserName()const
return userName_;
}
std::string QueryIntentionDetailResult::getRelationBizId()const
{
return relationBizId_;
}
long QueryIntentionDetailResult::getCreateTime()const
{
return createTime_;
}
std::string QueryIntentionDetailResult::getMobile()const
{
return mobile_;
}
std::string QueryIntentionDetailResult::getRegisterNumber()const
{
return registerNumber_;
}
int QueryIntentionDetailResult::getType()const
{
return type_;
}
std::string QueryIntentionDetailResult::getUserId()const
{
return userId_;
@@ -99,11 +118,6 @@ std::string QueryIntentionDetailResult::getClassification()const
return classification_;
}
long QueryIntentionDetailResult::getCreateTime()const
{
return createTime_;
}
long QueryIntentionDetailResult::getUpdateTime()const
{
return updateTime_;
@@ -114,8 +128,8 @@ std::string QueryIntentionDetailResult::getBizId()const
return bizId_;
}
std::string QueryIntentionDetailResult::getMobile()const
std::string QueryIntentionDetailResult::getPartnerMobile()const
{
return mobile_;
return partnerMobile_;
}

136
trademark/src/model/QueryIntentionListRequest.cc
View File

@@ -20,74 +20,76 @@ using AlibabaCloud::Trademark::Model::QueryIntentionListRequest;
QueryIntentionListRequest::QueryIntentionListRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QueryIntentionList")
{}
{
setMethod(HttpRequest::Method::Post);
}
QueryIntentionListRequest::~QueryIntentionListRequest()
{}
int QueryIntentionListRequest::getType()const
{
return type_;
}
void QueryIntentionListRequest::setType(int type)
{
type_ = type;
setCoreParameter("Type", std::to_string(type));
}
int QueryIntentionListRequest::getPageNum()const
{
return pageNum_;
}
void QueryIntentionListRequest::setPageNum(int pageNum)
{
pageNum_ = pageNum;
setCoreParameter("PageNum", std::to_string(pageNum));
}
std::string QueryIntentionListRequest::getSortFiled()const
{
return sortFiled_;
}
void QueryIntentionListRequest::setSortFiled(const std::string& sortFiled)
{
sortFiled_ = sortFiled;
setCoreParameter("SortFiled", sortFiled);
}
int QueryIntentionListRequest::getPageSize()const
{
return pageSize_;
}
void QueryIntentionListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string QueryIntentionListRequest::getSortOrder()const
{
return sortOrder_;
}
void QueryIntentionListRequest::setSortOrder(const std::string& sortOrder)
{
sortOrder_ = sortOrder;
setCoreParameter("SortOrder", sortOrder);
}
int QueryIntentionListRequest::getStatus()const
{
return status_;
}
void QueryIntentionListRequest::setStatus(int status)
{
status_ = status;
setCoreParameter("Status", std::to_string(status));
}
int QueryIntentionListRequest::getType()const
{
return type_;
}
void QueryIntentionListRequest::setType(int type)
{
type_ = type;
setParameter("Type", std::to_string(type));
}
int QueryIntentionListRequest::getPageNum()const
{
return pageNum_;
}
void QueryIntentionListRequest::setPageNum(int pageNum)
{
pageNum_ = pageNum;
setParameter("PageNum", std::to_string(pageNum));
}
std::string QueryIntentionListRequest::getSortFiled()const
{
return sortFiled_;
}
void QueryIntentionListRequest::setSortFiled(const std::string& sortFiled)
{
sortFiled_ = sortFiled;
setParameter("SortFiled", sortFiled);
}
int QueryIntentionListRequest::getPageSize()const
{
return pageSize_;
}
void QueryIntentionListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string QueryIntentionListRequest::getSortOrder()const
{
return sortOrder_;
}
void QueryIntentionListRequest::setSortOrder(const std::string& sortOrder)
{
sortOrder_ = sortOrder;
setParameter("SortOrder", sortOrder);
}
int QueryIntentionListRequest::getStatus()const
{
return status_;
}
void QueryIntentionListRequest::setStatus(int status)
{
status_ = status;
setParameter("Status", std::to_string(status));
}

51
trademark/src/model/QueryIntentionPriceRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/trademark/model/QueryIntentionPriceRequest.h>
using AlibabaCloud::Trademark::Model::QueryIntentionPriceRequest;
QueryIntentionPriceRequest::QueryIntentionPriceRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QueryIntentionPrice")
{
setMethod(HttpRequest::Method::Post);
}
QueryIntentionPriceRequest::~QueryIntentionPriceRequest()
{}
std::string QueryIntentionPriceRequest::getChannel()const
{
return channel_;
}
void QueryIntentionPriceRequest::setChannel(const std::string& channel)
{
channel_ = channel;
setParameter("Channel", channel);
}
std::string QueryIntentionPriceRequest::getIntentionBizId()const
{
return intentionBizId_;
}
void QueryIntentionPriceRequest::setIntentionBizId(const std::string& intentionBizId)
{
intentionBizId_ = intentionBizId;
setParameter("IntentionBizId", intentionBizId);
}

132
trademark/src/model/QueryIntentionPriceResult.cc Normal file
View File

@@ -0,0 +1,132 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/trademark/model/QueryIntentionPriceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Trademark;
using namespace AlibabaCloud::Trademark::Model;
QueryIntentionPriceResult::QueryIntentionPriceResult() :
ServiceResult()
{}
QueryIntentionPriceResult::QueryIntentionPriceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
QueryIntentionPriceResult::~QueryIntentionPriceResult()
{}
void QueryIntentionPriceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDataNode = value["Data"]["TmProduces"];
for (auto valueDataTmProduces : allDataNode)
{
TmProduces dataObject;
if(!valueDataTmProduces["BizId"].isNull())
dataObject.bizId = valueDataTmProduces["BizId"].asString();
if(!valueDataTmProduces["MaterialName"].isNull())
dataObject.materialName = valueDataTmProduces["MaterialName"].asString();
if(!valueDataTmProduces["TmIcon"].isNull())
dataObject.tmIcon = valueDataTmProduces["TmIcon"].asString();
if(!valueDataTmProduces["TmName"].isNull())
dataObject.tmName = valueDataTmProduces["TmName"].asString();
if(!valueDataTmProduces["TmNumber"].isNull())
dataObject.tmNumber = valueDataTmProduces["TmNumber"].asString();
if(!valueDataTmProduces["CreateTime"].isNull())
dataObject.createTime = std::stol(valueDataTmProduces["CreateTime"].asString());
if(!valueDataTmProduces["Type"].isNull())
dataObject.type = std::stoi(valueDataTmProduces["Type"].asString());
if(!valueDataTmProduces["Status"].isNull())
dataObject.status = std::stoi(valueDataTmProduces["Status"].asString());
if(!valueDataTmProduces["OrderPrice"].isNull())
dataObject.orderPrice = std::stof(valueDataTmProduces["OrderPrice"].asString());
if(!valueDataTmProduces["MaterialId"].isNull())
dataObject.materialId = valueDataTmProduces["MaterialId"].asString();
if(!valueDataTmProduces["LoaUrl"].isNull())
dataObject.loaUrl = valueDataTmProduces["LoaUrl"].asString();
if(!valueDataTmProduces["Note"].isNull())
dataObject.note = valueDataTmProduces["Note"].asString();
if(!valueDataTmProduces["UpdateTime"].isNull())
dataObject.updateTime = std::stol(valueDataTmProduces["UpdateTime"].asString());
if(!valueDataTmProduces["SupplementStatus"].isNull())
dataObject.supplementStatus = std::stoi(valueDataTmProduces["SupplementStatus"].asString());
if(!valueDataTmProduces["SupplementId"].isNull())
dataObject.supplementId = std::stol(valueDataTmProduces["SupplementId"].asString());
if(!valueDataTmProduces["TotalPrice"].isNull())
dataObject.totalPrice = std::stof(valueDataTmProduces["TotalPrice"].asString());
if(!valueDataTmProduces["ServicePrice"].isNull())
dataObject.servicePrice = std::stof(valueDataTmProduces["ServicePrice"].asString());
auto allThirdClassificationNode = allDataNode["ThirdClassification"]["ThirdClassifications"];
for (auto allDataNodeThirdClassificationThirdClassifications : allThirdClassificationNode)
{
TmProduces::ThirdClassifications thirdClassificationObject;
if(!allDataNodeThirdClassificationThirdClassifications["ClassificationCode"].isNull())
thirdClassificationObject.classificationCode = allDataNodeThirdClassificationThirdClassifications["ClassificationCode"].asString();
if(!allDataNodeThirdClassificationThirdClassifications["ClassificationName"].isNull())
thirdClassificationObject.classificationName = allDataNodeThirdClassificationThirdClassifications["ClassificationName"].asString();
dataObject.thirdClassification.push_back(thirdClassificationObject);
}
auto firstClassificationNode = value["FirstClassification"];
if(!firstClassificationNode["ClassificationCode"].isNull())
dataObject.firstClassification.classificationCode = firstClassificationNode["ClassificationCode"].asString();
if(!firstClassificationNode["ClassificationName"].isNull())
dataObject.firstClassification.classificationName = firstClassificationNode["ClassificationName"].asString();
data_.push_back(dataObject);
}
if(!value["TotalItemNum"].isNull())
totalItemNum_ = std::stoi(value["TotalItemNum"].asString());
if(!value["CurrentPageNum"].isNull())
currentPageNum_ = std::stoi(value["CurrentPageNum"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalPageNum"].isNull())
totalPageNum_ = std::stoi(value["TotalPageNum"].asString());
}
int QueryIntentionPriceResult::getCurrentPageNum()const
{
return currentPageNum_;
}
int QueryIntentionPriceResult::getPageSize()const
{
return pageSize_;
}
int QueryIntentionPriceResult::getTotalPageNum()const
{
return totalPageNum_;
}
std::vector<QueryIntentionPriceResult::TmProduces> QueryIntentionPriceResult::getData()const
{
return data_;
}
int QueryIntentionPriceResult::getTotalItemNum()const
{
return totalItemNum_;
}

18
trademark/src/model/QueryMaterialListRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::QueryMaterialListRequest;
QueryMaterialListRequest::QueryMaterialListRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QueryMaterialList")
{}
{
setMethod(HttpRequest::Method::Post);
}
QueryMaterialListRequest::~QueryMaterialListRequest()
{}
@@ -33,7 +35,7 @@ int QueryMaterialListRequest::getType()const
void QueryMaterialListRequest::setType(int type)
{
type_ = type;
setCoreParameter("Type", std::to_string(type));
setParameter("Type", std::to_string(type));
}
int QueryMaterialListRequest::getPageNum()const
@@ -44,7 +46,7 @@ int QueryMaterialListRequest::getPageNum()const
void QueryMaterialListRequest::setPageNum(int pageNum)
{
pageNum_ = pageNum;
setCoreParameter("PageNum", std::to_string(pageNum));
setParameter("PageNum", std::to_string(pageNum));
}
std::string QueryMaterialListRequest::getName()const
@@ -55,7 +57,7 @@ std::string QueryMaterialListRequest::getName()const
void QueryMaterialListRequest::setName(const std::string& name)
{
name_ = name;
setCoreParameter("Name", name);
setParameter("Name", name);
}
int QueryMaterialListRequest::getPageSize()const
@@ -66,7 +68,7 @@ int QueryMaterialListRequest::getPageSize()const
void QueryMaterialListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
setParameter("PageSize", std::to_string(pageSize));
}
std::string QueryMaterialListRequest::getCardNumber()const
@@ -77,7 +79,7 @@ std::string QueryMaterialListRequest::getCardNumber()const
void QueryMaterialListRequest::setCardNumber(const std::string& cardNumber)
{
cardNumber_ = cardNumber;
setCoreParameter("CardNumber", cardNumber);
setParameter("CardNumber", cardNumber);
}
int QueryMaterialListRequest::getRegion()const
@@ -88,7 +90,7 @@ int QueryMaterialListRequest::getRegion()const
void QueryMaterialListRequest::setRegion(int region)
{
region_ = region;
setCoreParameter("Region", std::to_string(region));
setParameter("Region", std::to_string(region));
}
int QueryMaterialListRequest::getStatus()const
@@ -99,6 +101,6 @@ int QueryMaterialListRequest::getStatus()const
void QueryMaterialListRequest::setStatus(int status)
{
status_ = status;
setCoreParameter("Status", std::to_string(status));
setParameter("Status", std::to_string(status));
}

17
trademark/src/model/QueryMaterialRequest.cc
View File

@@ -20,11 +20,24 @@ using AlibabaCloud::Trademark::Model::QueryMaterialRequest;
QueryMaterialRequest::QueryMaterialRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QueryMaterial")
{}
{
setMethod(HttpRequest::Method::Post);
}
QueryMaterialRequest::~QueryMaterialRequest()
{}
bool QueryMaterialRequest::getQueryUnconfirmedInfo()const
{
return queryUnconfirmedInfo_;
}
void QueryMaterialRequest::setQueryUnconfirmedInfo(bool queryUnconfirmedInfo)
{
queryUnconfirmedInfo_ = queryUnconfirmedInfo;
setParameter("QueryUnconfirmedInfo", queryUnconfirmedInfo ? "true" : "false");
}
long QueryMaterialRequest::getId()const
{
return id_;
@@ -33,6 +46,6 @@ long QueryMaterialRequest::getId()const
void QueryMaterialRequest::setId(long id)
{
id_ = id;
setCoreParameter("Id", std::to_string(id));
setParameter("Id", std::to_string(id));
}

15
trademark/src/model/QueryMaterialResult.cc
View File

@@ -39,6 +39,9 @@ void QueryMaterialResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allReviewAdditionalFiles = value["ReviewAdditionalFiles"]["ReviewAdditionalFile"];
for (const auto &item : allReviewAdditionalFiles)
reviewAdditionalFiles_.push_back(item.asString());
if(!value["Type"].isNull())
type_ = std::stoi(value["Type"].asString());
if(!value["Region"].isNull())
@@ -91,6 +94,8 @@ void QueryMaterialResult::parse(const std::string &payload)
note_ = value["Note"].asString();
if(!value["Country"].isNull())
country_ = value["Country"].asString();
if(!value["ReviewApplicationFile"].isNull())
reviewApplicationFile_ = value["ReviewApplicationFile"].asString();
}
@@ -134,6 +139,11 @@ std::string QueryMaterialResult::getTown()const
return town_;
}
std::vector<std::string> QueryMaterialResult::getReviewAdditionalFiles()const
{
return reviewAdditionalFiles_;
}
std::string QueryMaterialResult::getContactNumber()const
{
return contactNumber_;
@@ -154,6 +164,11 @@ int QueryMaterialResult::getStatus()const
return status_;
}
std::string QueryMaterialResult::getReviewApplicationFile()const
{
return reviewApplicationFile_;
}
std::string QueryMaterialResult::getCity()const
{
return city_;

11
trademark/src/model/QueryMonitorKeywordsRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::QueryMonitorKeywordsRequest;
QueryMonitorKeywordsRequest::QueryMonitorKeywordsRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QueryMonitorKeywords")
{}
{
setMethod(HttpRequest::Method::Post);
}
QueryMonitorKeywordsRequest::~QueryMonitorKeywordsRequest()
{}
@@ -33,8 +35,9 @@ std::vector<std::string> QueryMonitorKeywordsRequest::getKeywords()const
void QueryMonitorKeywordsRequest::setKeywords(const std::vector<std::string>& keywords)
{
keywords_ = keywords;
for(int i = 0; i!= keywords.size(); i++)
setCoreParameter("Keywords."+ std::to_string(i), keywords.at(i));
for(int dep1 = 0; dep1!= keywords.size(); dep1++) {
setParameter("Keywords."+ std::to_string(dep1), keywords.at(dep1));
}
}
int QueryMonitorKeywordsRequest::getRuleType()const
@@ -45,6 +48,6 @@ int QueryMonitorKeywordsRequest::getRuleType()const
void QueryMonitorKeywordsRequest::setRuleType(int ruleType)
{
ruleType_ = ruleType;
setCoreParameter("RuleType", std::to_string(ruleType));
setParameter("RuleType", std::to_string(ruleType));
}

51
trademark/src/model/QueryOfficialFileCustomListRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/trademark/model/QueryOfficialFileCustomListRequest.h>
using AlibabaCloud::Trademark::Model::QueryOfficialFileCustomListRequest;
QueryOfficialFileCustomListRequest::QueryOfficialFileCustomListRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QueryOfficialFileCustomList")
{
setMethod(HttpRequest::Method::Post);
}
QueryOfficialFileCustomListRequest::~QueryOfficialFileCustomListRequest()
{}
int QueryOfficialFileCustomListRequest::getPageSize()const
{
return pageSize_;
}
void QueryOfficialFileCustomListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
int QueryOfficialFileCustomListRequest::getPageNum()const
{
return pageNum_;
}
void QueryOfficialFileCustomListRequest::setPageNum(int pageNum)
{
pageNum_ = pageNum;
setParameter("PageNum", std::to_string(pageNum));
}

97
trademark/src/model/QueryOfficialFileCustomListResult.cc Normal file
View File

@@ -0,0 +1,97 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/trademark/model/QueryOfficialFileCustomListResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Trademark;
using namespace AlibabaCloud::Trademark::Model;
QueryOfficialFileCustomListResult::QueryOfficialFileCustomListResult() :
ServiceResult()
{}
QueryOfficialFileCustomListResult::QueryOfficialFileCustomListResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
QueryOfficialFileCustomListResult::~QueryOfficialFileCustomListResult()
{}
void QueryOfficialFileCustomListResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDataNode = value["Data"]["CustomList"];
for (auto valueDataCustomList : allDataNode)
{
CustomList dataObject;
if(!valueDataCustomList["Status"].isNull())
dataObject.status = valueDataCustomList["Status"].asString();
if(!valueDataCustomList["CreateTime"].isNull())
dataObject.createTime = std::stol(valueDataCustomList["CreateTime"].asString());
if(!valueDataCustomList["StartAcceptTime"].isNull())
dataObject.startAcceptTime = std::stol(valueDataCustomList["StartAcceptTime"].asString());
if(!valueDataCustomList["EndAcceptTime"].isNull())
dataObject.endAcceptTime = std::stol(valueDataCustomList["EndAcceptTime"].asString());
if(!valueDataCustomList["ExpireTime"].isNull())
dataObject.expireTime = std::stol(valueDataCustomList["ExpireTime"].asString());
if(!valueDataCustomList["DownloadUrl"].isNull())
dataObject.downloadUrl = valueDataCustomList["DownloadUrl"].asString();
if(!valueDataCustomList["Remark"].isNull())
dataObject.remark = valueDataCustomList["Remark"].asString();
data_.push_back(dataObject);
}
if(!value["TotalItemNum"].isNull())
totalItemNum_ = std::stoi(value["TotalItemNum"].asString());
if(!value["CurrentPageNum"].isNull())
currentPageNum_ = std::stoi(value["CurrentPageNum"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalPageNum"].isNull())
totalPageNum_ = std::stoi(value["TotalPageNum"].asString());
}
int QueryOfficialFileCustomListResult::getCurrentPageNum()const
{
return currentPageNum_;
}
int QueryOfficialFileCustomListResult::getPageSize()const
{
return pageSize_;
}
int QueryOfficialFileCustomListResult::getTotalPageNum()const
{
return totalPageNum_;
}
std::vector<QueryOfficialFileCustomListResult::CustomList> QueryOfficialFileCustomListResult::getData()const
{
return data_;
}
int QueryOfficialFileCustomListResult::getTotalItemNum()const
{
return totalItemNum_;
}

6
trademark/src/model/QueryOssResourcesRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::QueryOssResourcesRequest;
QueryOssResourcesRequest::QueryOssResourcesRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QueryOssResources")
{}
{
setMethod(HttpRequest::Method::Post);
}
QueryOssResourcesRequest::~QueryOssResourcesRequest()
{}
@@ -33,6 +35,6 @@ std::string QueryOssResourcesRequest::getBizId()const
void QueryOssResourcesRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setCoreParameter("BizId", bizId);
setParameter("BizId", bizId);
}

10
trademark/src/model/QueryQrCodeUploadStatusRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::QueryQrCodeUploadStatusRequest;
QueryQrCodeUploadStatusRequest::QueryQrCodeUploadStatusRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QueryQrCodeUploadStatus")
{}
{
setMethod(HttpRequest::Method::Post);
}
QueryQrCodeUploadStatusRequest::~QueryQrCodeUploadStatusRequest()
{}
@@ -33,7 +35,7 @@ std::string QueryQrCodeUploadStatusRequest::getOssKey()const
void QueryQrCodeUploadStatusRequest::setOssKey(const std::string& ossKey)
{
ossKey_ = ossKey;
setCoreParameter("OssKey", ossKey);
setParameter("OssKey", ossKey);
}
std::string QueryQrCodeUploadStatusRequest::getFieldKey()const
@@ -44,7 +46,7 @@ std::string QueryQrCodeUploadStatusRequest::getFieldKey()const
void QueryQrCodeUploadStatusRequest::setFieldKey(const std::string& fieldKey)
{
fieldKey_ = fieldKey;
setCoreParameter("FieldKey", fieldKey);
setParameter("FieldKey", fieldKey);
}
std::string QueryQrCodeUploadStatusRequest::getUuid()const
@@ -55,6 +57,6 @@ std::string QueryQrCodeUploadStatusRequest::getUuid()const
void QueryQrCodeUploadStatusRequest::setUuid(const std::string& uuid)
{
uuid_ = uuid;
setCoreParameter("Uuid", uuid);
setParameter("Uuid", uuid);
}

6
trademark/src/model/QuerySupplementDetailRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::QuerySupplementDetailRequest;
QuerySupplementDetailRequest::QuerySupplementDetailRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QuerySupplementDetail")
{}
{
setMethod(HttpRequest::Method::Post);
}
QuerySupplementDetailRequest::~QuerySupplementDetailRequest()
{}
@@ -33,6 +35,6 @@ long QuerySupplementDetailRequest::getId()const
void QuerySupplementDetailRequest::setId(long id)
{
id_ = id;
setCoreParameter("Id", std::to_string(id));
setParameter("Id", std::to_string(id));
}

28
trademark/src/model/QueryTaskListRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::QueryTaskListRequest;
QueryTaskListRequest::QueryTaskListRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QueryTaskList")
{}
{
setMethod(HttpRequest::Method::Post);
}
QueryTaskListRequest::~QueryTaskListRequest()
{}
@@ -33,6 +35,28 @@ std::string QueryTaskListRequest::getBizType()const
void QueryTaskListRequest::setBizType(const std::string& bizType)
{
bizType_ = bizType;
setCoreParameter("BizType", bizType);
setParameter("BizType", bizType);
}
int QueryTaskListRequest::getPageSize()const
{
return pageSize_;
}
void QueryTaskListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
int QueryTaskListRequest::getPageNum()const
{
return pageNum_;
}
void QueryTaskListRequest::setPageNum(int pageNum)
{
pageNum_ = pageNum;
setParameter("PageNum", std::to_string(pageNum));
}

34
trademark/src/model/QueryTaskListResult.cc
View File

@@ -51,13 +51,47 @@ void QueryTaskListResult::parse(const std::string &payload)
dataObject.errMsg = valueDataTaskList["ErrMsg"].asString();
if(!valueDataTaskList["Result"].isNull())
dataObject.result = valueDataTaskList["Result"].asString();
if(!valueDataTaskList["FileName"].isNull())
dataObject.fileName = valueDataTaskList["FileName"].asString();
if(!valueDataTaskList["CreateTime"].isNull())
dataObject.createTime = std::stol(valueDataTaskList["CreateTime"].asString());
if(!valueDataTaskList["CompleteTime"].isNull())
dataObject.completeTime = std::stol(valueDataTaskList["CompleteTime"].asString());
data_.push_back(dataObject);
}
if(!value["TotalItemNum"].isNull())
totalItemNum_ = std::stoi(value["TotalItemNum"].asString());
if(!value["CurrentPageNum"].isNull())
currentPageNum_ = std::stoi(value["CurrentPageNum"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalPageNum"].isNull())
totalPageNum_ = std::stoi(value["TotalPageNum"].asString());
}
int QueryTaskListResult::getCurrentPageNum()const
{
return currentPageNum_;
}
int QueryTaskListResult::getPageSize()const
{
return pageSize_;
}
int QueryTaskListResult::getTotalPageNum()const
{
return totalPageNum_;
}
std::vector<QueryTaskListResult::TaskList> QueryTaskListResult::getData()const
{
return data_;
}
int QueryTaskListResult::getTotalItemNum()const
{
return totalItemNum_;
}

16
trademark/src/model/QueryTradeIntentionUserListRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::QueryTradeIntentionUserListRequest;
QueryTradeIntentionUserListRequest::QueryTradeIntentionUserListRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QueryTradeIntentionUserList")
{}
{
setMethod(HttpRequest::Method::Post);
}
QueryTradeIntentionUserListRequest::~QueryTradeIntentionUserListRequest()
{}
@@ -33,7 +35,7 @@ int QueryTradeIntentionUserListRequest::getPageNum()const
void QueryTradeIntentionUserListRequest::setPageNum(int pageNum)
{
pageNum_ = pageNum;
setCoreParameter("PageNum", std::to_string(pageNum));
setParameter("PageNum", std::to_string(pageNum));
}
int QueryTradeIntentionUserListRequest::getPageSize()const
@@ -44,7 +46,7 @@ int QueryTradeIntentionUserListRequest::getPageSize()const
void QueryTradeIntentionUserListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
setParameter("PageSize", std::to_string(pageSize));
}
std::string QueryTradeIntentionUserListRequest::getBizId()const
@@ -55,7 +57,7 @@ std::string QueryTradeIntentionUserListRequest::getBizId()const
void QueryTradeIntentionUserListRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setCoreParameter("BizId", bizId);
setParameter("BizId", bizId);
}
long QueryTradeIntentionUserListRequest::getEnd()const
@@ -66,7 +68,7 @@ long QueryTradeIntentionUserListRequest::getEnd()const
void QueryTradeIntentionUserListRequest::setEnd(long end)
{
end_ = end;
setCoreParameter("End", std::to_string(end));
setParameter("End", std::to_string(end));
}
long QueryTradeIntentionUserListRequest::getBegin()const
@@ -77,7 +79,7 @@ long QueryTradeIntentionUserListRequest::getBegin()const
void QueryTradeIntentionUserListRequest::setBegin(long begin)
{
begin_ = begin;
setCoreParameter("Begin", std::to_string(begin));
setParameter("Begin", std::to_string(begin));
}
int QueryTradeIntentionUserListRequest::getStatus()const
@@ -88,6 +90,6 @@ int QueryTradeIntentionUserListRequest::getStatus()const
void QueryTradeIntentionUserListRequest::setStatus(int status)
{
status_ = status;
setCoreParameter("Status", std::to_string(status));
setParameter("Status", std::to_string(status));
}

4
trademark/src/model/QueryTradeIntentionUserListResult.cc
View File

@@ -48,7 +48,7 @@ void QueryTradeIntentionUserListResult::parse(const std::string &payload)
if(!valueDataTrademark["Classification"].isNull())
dataObject.classification = valueDataTrademark["Classification"].asString();
if(!valueDataTrademark["Mobile"].isNull())
dataObject.mobile = std::stoi(valueDataTrademark["Mobile"].asString());
dataObject.mobile = valueDataTrademark["Mobile"].asString();
if(!valueDataTrademark["UserName"].isNull())
dataObject.userName = valueDataTrademark["UserName"].asString();
if(!valueDataTrademark["BizId"].isNull())
@@ -57,6 +57,8 @@ void QueryTradeIntentionUserListResult::parse(const std::string &payload)
dataObject.description = valueDataTrademark["Description"].asString();
if(!valueDataTrademark["Status"].isNull())
dataObject.status = std::stoi(valueDataTrademark["Status"].asString());
if(!valueDataTrademark["Type"].isNull())
dataObject.type = std::stoi(valueDataTrademark["Type"].asString());
data_.push_back(dataObject);
}
if(!value["TotalItemNum"].isNull())

6
trademark/src/model/QueryTradeMarkApplicationDetailRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::QueryTradeMarkApplicationDetailRequest;
QueryTradeMarkApplicationDetailRequest::QueryTradeMarkApplicationDetailRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QueryTradeMarkApplicationDetail")
{}
{
setMethod(HttpRequest::Method::Post);
}
QueryTradeMarkApplicationDetailRequest::~QueryTradeMarkApplicationDetailRequest()
{}
@@ -33,6 +35,6 @@ std::string QueryTradeMarkApplicationDetailRequest::getBizId()const
void QueryTradeMarkApplicationDetailRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setCoreParameter("BizId", bizId);
setParameter("BizId", bizId);
}

58
trademark/src/model/QueryTradeMarkApplicationDetailResult.cc
View File

@@ -138,6 +138,11 @@ void QueryTradeMarkApplicationDetailResult::parse(const std::string &payload)
materialDetail_.contactName = materialDetailNode["ContactName"].asString();
if(!materialDetailNode["LegalNoticeUrl"].isNull())
materialDetail_.legalNoticeUrl = materialDetailNode["LegalNoticeUrl"].asString();
if(!materialDetailNode["ReviewApplicationFile"].isNull())
materialDetail_.reviewApplicationFile = materialDetailNode["ReviewApplicationFile"].asString();
auto allReviewAdditionalFiles = materialDetailNode["ReviewAdditionalFiles"]["ReviewAdditionalFile"];
for (auto value : allReviewAdditionalFiles)
materialDetail_.reviewAdditionalFiles.push_back(value.asString());
auto firstClassificationNode = value["FirstClassification"];
if(!firstClassificationNode["Code"].isNull())
firstClassification_.code = firstClassificationNode["Code"].asString();
@@ -156,12 +161,27 @@ void QueryTradeMarkApplicationDetailResult::parse(const std::string &payload)
renewResponse_.registerTime = std::stol(renewResponseNode["RegisterTime"].asString());
if(!renewResponseNode["SubmitSbjtime"].isNull())
renewResponse_.submitSbjtime = std::stol(renewResponseNode["SubmitSbjtime"].asString());
auto reviewOfficialFilesNode = value["ReviewOfficialFiles"];
if(!reviewOfficialFilesNode["ReviewAudit"].isNull())
reviewOfficialFiles_.reviewAudit = reviewOfficialFilesNode["ReviewAudit"].asString();
if(!reviewOfficialFilesNode["ReviewPass"].isNull())
reviewOfficialFiles_.reviewPass = reviewOfficialFilesNode["ReviewPass"].asString();
if(!reviewOfficialFilesNode["ReviewKeep"].isNull())
reviewOfficialFiles_.reviewKeep = reviewOfficialFilesNode["ReviewKeep"].asString();
if(!reviewOfficialFilesNode["ReviewPart"].isNull())
reviewOfficialFiles_.reviewPart = reviewOfficialFilesNode["ReviewPart"].asString();
auto allReviewSupplements = reviewOfficialFilesNode["ReviewSupplements"]["ReviewSupplement"];
for (auto value : allReviewSupplements)
reviewOfficialFiles_.reviewSupplements.push_back(value.asString());
auto allReceiptUrl = value["ReceiptUrl"]["ReceiptUrl"];
for (const auto &item : allReceiptUrl)
receiptUrl_.push_back(item.asString());
auto allJudgeResultUrl = value["JudgeResultUrl"]["JudgeResultUrl"];
for (const auto &item : allJudgeResultUrl)
judgeResultUrl_.push_back(item.asString());
auto allFlags = value["Flags"]["Flag"];
for (const auto &item : allFlags)
flags_.push_back(item.asString());
if(!value["Status"].isNull())
status_ = std::stoi(value["Status"].asString());
if(!value["LoaUrl"].isNull())
@@ -206,6 +226,14 @@ void QueryTradeMarkApplicationDetailResult::parse(const std::string &payload)
totalPrice_ = std::stof(value["TotalPrice"].asString());
if(!value["ServicePrice"].isNull())
servicePrice_ = std::stof(value["ServicePrice"].asString());
if(!value["PartnerCode"].isNull())
partnerCode_ = value["PartnerCode"].asString();
if(!value["PartnerMobile"].isNull())
partnerMobile_ = value["PartnerMobile"].asString();
if(!value["NotAcceptUrl"].isNull())
notAcceptUrl_ = value["NotAcceptUrl"].asString();
if(!value["PartnerName"].isNull())
partnerName_ = value["PartnerName"].asString();
}
@@ -234,6 +262,11 @@ std::string QueryTradeMarkApplicationDetailResult::getTmIcon()const
return tmIcon_;
}
std::string QueryTradeMarkApplicationDetailResult::getPartnerCode()const
{
return partnerCode_;
}
std::string QueryTradeMarkApplicationDetailResult::getAcceptUrl()const
{
return acceptUrl_;
@@ -269,6 +302,11 @@ QueryTradeMarkApplicationDetailResult::AdminUploads QueryTradeMarkApplicationDet
return adminUploads_;
}
std::string QueryTradeMarkApplicationDetailResult::getNotAcceptUrl()const
{
return notAcceptUrl_;
}
std::vector<QueryTradeMarkApplicationDetailResult::ThirdClassifications> QueryTradeMarkApplicationDetailResult::getThirdClassification()const
{
return thirdClassification_;
@@ -314,16 +352,31 @@ float QueryTradeMarkApplicationDetailResult::getOrderPrice()const
return orderPrice_;
}
std::vector<std::string> QueryTradeMarkApplicationDetailResult::getFlags()const
{
return flags_;
}
std::string QueryTradeMarkApplicationDetailResult::getOrderId()const
{
return orderId_;
}
std::string QueryTradeMarkApplicationDetailResult::getPartnerName()const
{
return partnerName_;
}
std::vector<QueryTradeMarkApplicationDetailResult::SupplementsItem> QueryTradeMarkApplicationDetailResult::getSupplements()const
{
return supplements_;
}
QueryTradeMarkApplicationDetailResult::ReviewOfficialFiles QueryTradeMarkApplicationDetailResult::getReviewOfficialFiles()const
{
return reviewOfficialFiles_;
}
int QueryTradeMarkApplicationDetailResult::getType()const
{
return type_;
@@ -359,3 +412,8 @@ std::string QueryTradeMarkApplicationDetailResult::getBizId()const
return bizId_;
}
std::string QueryTradeMarkApplicationDetailResult::getPartnerMobile()const
{
return partnerMobile_;
}

6
trademark/src/model/QueryTradeMarkApplicationLogsRequest.cc
View File

@@ -20,7 +20,9 @@ using AlibabaCloud::Trademark::Model::QueryTradeMarkApplicationLogsRequest;
QueryTradeMarkApplicationLogsRequest::QueryTradeMarkApplicationLogsRequest() :
RpcServiceRequest("trademark", "2018-07-24", "QueryTradeMarkApplicationLogs")
{}
{
setMethod(HttpRequest::Method::Post);
}
QueryTradeMarkApplicationLogsRequest::~QueryTradeMarkApplicationLogsRequest()
{}
@@ -33,6 +35,6 @@ std::string QueryTradeMarkApplicationLogsRequest::getBizId()const
void QueryTradeMarkApplicationLogsRequest::setBizId(const std::string& bizId)
{
bizId_ = bizId;
setCoreParameter("BizId", bizId);
setParameter("BizId", bizId);
}

Some files were not shown because too many files have changed in this diff Show More