Fix DescribeInstances clusterId.

CHANGELOG

@@ -1,3 +1,24 @@
+2021-12-07 Version: 1.36.970
+- Fix DescribeInstances clusterId.
+
+2021-12-07 Version: 1.36.969
+- Add MetaTag APIs.
+
+2021-12-07 Version: 1.36.968
+- Add MetaTag APIs.
+
+2021-12-06 Version: 1.36.967
+- Support Bond Eni.
+
+2021-12-06 Version: 1.36.966
+- Support Bond Eni.
+
+2021-12-06 Version: 1.36.965
+- Generated 2020-05-18 for `dataworks-public`.
+
+2021-12-06 Version: 1.36.964
+- Modify the input parameter Action of DescribeCenInterRegionBandwidthLimits to be required.
+
 2021-12-03 Version: 1.36.963
 - Add EventRule Content Filter.
 - Add MetricRule Labels.

VERSION

@@ -1 +1 @@
-1.36.963
+1.36.970

cbn/include/alibabacloud/cbn/model/DescribeCenInterRegionBandwidthLimitsResult.h

@@ -34,8 +34,8 @@ namespace AlibabaCloud
 			public:
 				struct CenInterRegionBandwidthLimit
 				{
-					std::string status;
 					std::string transitRouterAttachmentId;
+					std::string status;
 					std::string geographicSpanId;
 					std::string oppositeRegionId;
 					std::string cenId;

cbn/src/model/DescribeCenInterRegionBandwidthLimitsResult.cc

@@ -43,30 +43,30 @@ void DescribeCenInterRegionBandwidthLimitsResult::parse(const std::string &paylo
 	for (auto valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit : allCenInterRegionBandwidthLimitsNode)
 	{
 		CenInterRegionBandwidthLimit cenInterRegionBandwidthLimitsObject;
-		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["CenId"].isNull())
-			cenInterRegionBandwidthLimitsObject.cenId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["CenId"].asString();
-		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["LocalRegionId"].isNull())
-			cenInterRegionBandwidthLimitsObject.localRegionId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["LocalRegionId"].asString();
+		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["TransitRouterAttachmentId"].isNull())
+			cenInterRegionBandwidthLimitsObject.transitRouterAttachmentId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["TransitRouterAttachmentId"].asString();
+		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["Status"].isNull())
+			cenInterRegionBandwidthLimitsObject.status = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["Status"].asString();
+		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["BandwidthPackageId"].isNull())
+			cenInterRegionBandwidthLimitsObject.bandwidthPackageId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["BandwidthPackageId"].asString();
 		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["OppositeRegionId"].isNull())
 			cenInterRegionBandwidthLimitsObject.oppositeRegionId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["OppositeRegionId"].asString();
 		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["GeographicSpanId"].isNull())
 			cenInterRegionBandwidthLimitsObject.geographicSpanId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["GeographicSpanId"].asString();
+		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["CenId"].isNull())
+			cenInterRegionBandwidthLimitsObject.cenId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["CenId"].asString();
+		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["LocalRegionId"].isNull())
+			cenInterRegionBandwidthLimitsObject.localRegionId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["LocalRegionId"].asString();
 		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["BandwidthLimit"].isNull())
 			cenInterRegionBandwidthLimitsObject.bandwidthLimit = std::stol(valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["BandwidthLimit"].asString());
-		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["Status"].isNull())
-			cenInterRegionBandwidthLimitsObject.status = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["Status"].asString();
-		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["TransitRouterAttachmentId"].isNull())
-			cenInterRegionBandwidthLimitsObject.transitRouterAttachmentId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["TransitRouterAttachmentId"].asString();
-		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["BandwidthPackageId"].isNull())
-			cenInterRegionBandwidthLimitsObject.bandwidthPackageId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["BandwidthPackageId"].asString();
 		cenInterRegionBandwidthLimits_.push_back(cenInterRegionBandwidthLimitsObject);
 	}
-	if(!value["TotalCount"].isNull())
-		totalCount_ = std::stoi(value["TotalCount"].asString());
-	if(!value["PageNumber"].isNull())
-		pageNumber_ = std::stoi(value["PageNumber"].asString());
 	if(!value["PageSize"].isNull())
 		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
 
 }
 

dataworks-public/CMakeLists.txt

@@ -61,6 +61,8 @@ set(dataworks-public_public_header_model
 	include/alibabacloud/dataworks-public/model/CreateDataServiceGroupResult.h
 	include/alibabacloud/dataworks-public/model/CreateDataSourceRequest.h
 	include/alibabacloud/dataworks-public/model/CreateDataSourceResult.h
+	include/alibabacloud/dataworks-public/model/CreateExportMigrationRequest.h
+	include/alibabacloud/dataworks-public/model/CreateExportMigrationResult.h
 	include/alibabacloud/dataworks-public/model/CreateFileRequest.h
 	include/alibabacloud/dataworks-public/model/CreateFileResult.h
 	include/alibabacloud/dataworks-public/model/CreateFolderRequest.h
@@ -195,6 +197,8 @@ set(dataworks-public_public_header_model
 	include/alibabacloud/dataworks-public/model/GetFileVersionResult.h
 	include/alibabacloud/dataworks-public/model/GetFolderRequest.h
 	include/alibabacloud/dataworks-public/model/GetFolderResult.h
+	include/alibabacloud/dataworks-public/model/GetIDEEventDetailRequest.h
+	include/alibabacloud/dataworks-public/model/GetIDEEventDetailResult.h
 	include/alibabacloud/dataworks-public/model/GetInstanceRequest.h
 	include/alibabacloud/dataworks-public/model/GetInstanceResult.h
 	include/alibabacloud/dataworks-public/model/GetInstanceConsumeTimeRankRequest.h
@@ -241,6 +245,8 @@ set(dataworks-public_public_header_model
 	include/alibabacloud/dataworks-public/model/GetMetaTableThemeLevelResult.h
 	include/alibabacloud/dataworks-public/model/GetMigrationProcessRequest.h
 	include/alibabacloud/dataworks-public/model/GetMigrationProcessResult.h
+	include/alibabacloud/dataworks-public/model/GetMigrationSummaryRequest.h
+	include/alibabacloud/dataworks-public/model/GetMigrationSummaryResult.h
 	include/alibabacloud/dataworks-public/model/GetNodeRequest.h
 	include/alibabacloud/dataworks-public/model/GetNodeResult.h
 	include/alibabacloud/dataworks-public/model/GetNodeChildrenRequest.h
@@ -301,6 +307,8 @@ set(dataworks-public_public_header_model
 	include/alibabacloud/dataworks-public/model/ListDIProjectConfigResult.h
 	include/alibabacloud/dataworks-public/model/ListDISyncTasksRequest.h
 	include/alibabacloud/dataworks-public/model/ListDISyncTasksResult.h
+	include/alibabacloud/dataworks-public/model/ListDagsRequest.h
+	include/alibabacloud/dataworks-public/model/ListDagsResult.h
 	include/alibabacloud/dataworks-public/model/ListDataServiceApiAuthoritiesRequest.h
 	include/alibabacloud/dataworks-public/model/ListDataServiceApiAuthoritiesResult.h
 	include/alibabacloud/dataworks-public/model/ListDataServiceApisRequest.h
@@ -317,6 +325,8 @@ set(dataworks-public_public_header_model
 	include/alibabacloud/dataworks-public/model/ListDataServicePublishedApisResult.h
 	include/alibabacloud/dataworks-public/model/ListDataSourcesRequest.h
 	include/alibabacloud/dataworks-public/model/ListDataSourcesResult.h
+	include/alibabacloud/dataworks-public/model/ListDeploymentsRequest.h
+	include/alibabacloud/dataworks-public/model/ListDeploymentsResult.h
 	include/alibabacloud/dataworks-public/model/ListFileTypeRequest.h
 	include/alibabacloud/dataworks-public/model/ListFileTypeResult.h
 	include/alibabacloud/dataworks-public/model/ListFileVersionsRequest.h
@@ -447,6 +457,8 @@ set(dataworks-public_public_header_model
 	include/alibabacloud/dataworks-public/model/UpdateFileResult.h
 	include/alibabacloud/dataworks-public/model/UpdateFolderRequest.h
 	include/alibabacloud/dataworks-public/model/UpdateFolderResult.h
+	include/alibabacloud/dataworks-public/model/UpdateIDEEventResultRequest.h
+	include/alibabacloud/dataworks-public/model/UpdateIDEEventResultResult.h
 	include/alibabacloud/dataworks-public/model/UpdateMetaCategoryRequest.h
 	include/alibabacloud/dataworks-public/model/UpdateMetaCategoryResult.h
 	include/alibabacloud/dataworks-public/model/UpdateMetaTableRequest.h
@@ -518,6 +530,8 @@ set(dataworks-public_src
 	src/model/CreateDataServiceGroupResult.cc
 	src/model/CreateDataSourceRequest.cc
 	src/model/CreateDataSourceResult.cc
+	src/model/CreateExportMigrationRequest.cc
+	src/model/CreateExportMigrationResult.cc
 	src/model/CreateFileRequest.cc
 	src/model/CreateFileResult.cc
 	src/model/CreateFolderRequest.cc
@@ -652,6 +666,8 @@ set(dataworks-public_src
 	src/model/GetFileVersionResult.cc
 	src/model/GetFolderRequest.cc
 	src/model/GetFolderResult.cc
+	src/model/GetIDEEventDetailRequest.cc
+	src/model/GetIDEEventDetailResult.cc
 	src/model/GetInstanceRequest.cc
 	src/model/GetInstanceResult.cc
 	src/model/GetInstanceConsumeTimeRankRequest.cc
@@ -698,6 +714,8 @@ set(dataworks-public_src
 	src/model/GetMetaTableThemeLevelResult.cc
 	src/model/GetMigrationProcessRequest.cc
 	src/model/GetMigrationProcessResult.cc
+	src/model/GetMigrationSummaryRequest.cc
+	src/model/GetMigrationSummaryResult.cc
 	src/model/GetNodeRequest.cc
 	src/model/GetNodeResult.cc
 	src/model/GetNodeChildrenRequest.cc
@@ -758,6 +776,8 @@ set(dataworks-public_src
 	src/model/ListDIProjectConfigResult.cc
 	src/model/ListDISyncTasksRequest.cc
 	src/model/ListDISyncTasksResult.cc
+	src/model/ListDagsRequest.cc
+	src/model/ListDagsResult.cc
 	src/model/ListDataServiceApiAuthoritiesRequest.cc
 	src/model/ListDataServiceApiAuthoritiesResult.cc
 	src/model/ListDataServiceApisRequest.cc
@@ -774,6 +794,8 @@ set(dataworks-public_src
 	src/model/ListDataServicePublishedApisResult.cc
 	src/model/ListDataSourcesRequest.cc
 	src/model/ListDataSourcesResult.cc
+	src/model/ListDeploymentsRequest.cc
+	src/model/ListDeploymentsResult.cc
 	src/model/ListFileTypeRequest.cc
 	src/model/ListFileTypeResult.cc
 	src/model/ListFileVersionsRequest.cc
@@ -904,6 +926,8 @@ set(dataworks-public_src
 	src/model/UpdateFileResult.cc
 	src/model/UpdateFolderRequest.cc
 	src/model/UpdateFolderResult.cc
+	src/model/UpdateIDEEventResultRequest.cc
+	src/model/UpdateIDEEventResultResult.cc
 	src/model/UpdateMetaCategoryRequest.cc
 	src/model/UpdateMetaCategoryResult.cc
 	src/model/UpdateMetaTableRequest.cc

dataworks-public/include/alibabacloud/dataworks-public/Dataworks_publicClient.h

@@ -62,6 +62,8 @@
 #include "model/CreateDataServiceGroupResult.h"
 #include "model/CreateDataSourceRequest.h"
 #include "model/CreateDataSourceResult.h"
+#include "model/CreateExportMigrationRequest.h"
+#include "model/CreateExportMigrationResult.h"
 #include "model/CreateFileRequest.h"
 #include "model/CreateFileResult.h"
 #include "model/CreateFolderRequest.h"
@@ -196,6 +198,8 @@
 #include "model/GetFileVersionResult.h"
 #include "model/GetFolderRequest.h"
 #include "model/GetFolderResult.h"
+#include "model/GetIDEEventDetailRequest.h"
+#include "model/GetIDEEventDetailResult.h"
 #include "model/GetInstanceRequest.h"
 #include "model/GetInstanceResult.h"
 #include "model/GetInstanceConsumeTimeRankRequest.h"
@@ -242,6 +246,8 @@
 #include "model/GetMetaTableThemeLevelResult.h"
 #include "model/GetMigrationProcessRequest.h"
 #include "model/GetMigrationProcessResult.h"
+#include "model/GetMigrationSummaryRequest.h"
+#include "model/GetMigrationSummaryResult.h"
 #include "model/GetNodeRequest.h"
 #include "model/GetNodeResult.h"
 #include "model/GetNodeChildrenRequest.h"
@@ -302,6 +308,8 @@
 #include "model/ListDIProjectConfigResult.h"
 #include "model/ListDISyncTasksRequest.h"
 #include "model/ListDISyncTasksResult.h"
+#include "model/ListDagsRequest.h"
+#include "model/ListDagsResult.h"
 #include "model/ListDataServiceApiAuthoritiesRequest.h"
 #include "model/ListDataServiceApiAuthoritiesResult.h"
 #include "model/ListDataServiceApisRequest.h"
@@ -318,6 +326,8 @@
 #include "model/ListDataServicePublishedApisResult.h"
 #include "model/ListDataSourcesRequest.h"
 #include "model/ListDataSourcesResult.h"
+#include "model/ListDeploymentsRequest.h"
+#include "model/ListDeploymentsResult.h"
 #include "model/ListFileTypeRequest.h"
 #include "model/ListFileTypeResult.h"
 #include "model/ListFileVersionsRequest.h"
@@ -448,6 +458,8 @@
 #include "model/UpdateFileResult.h"
 #include "model/UpdateFolderRequest.h"
 #include "model/UpdateFolderResult.h"
+#include "model/UpdateIDEEventResultRequest.h"
+#include "model/UpdateIDEEventResultResult.h"
 #include "model/UpdateMetaCategoryRequest.h"
 #include "model/UpdateMetaCategoryResult.h"
 #include "model/UpdateMetaTableRequest.h"
@@ -545,6 +557,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateDataSourceResult> CreateDataSourceOutcome;
 			typedef std::future<CreateDataSourceOutcome> CreateDataSourceOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateDataSourceRequest&, const CreateDataSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDataSourceAsyncHandler;
+			typedef Outcome<Error, Model::CreateExportMigrationResult> CreateExportMigrationOutcome;
+			typedef std::future<CreateExportMigrationOutcome> CreateExportMigrationOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateExportMigrationRequest&, const CreateExportMigrationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateExportMigrationAsyncHandler;
 			typedef Outcome<Error, Model::CreateFileResult> CreateFileOutcome;
 			typedef std::future<CreateFileOutcome> CreateFileOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateFileRequest&, const CreateFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFileAsyncHandler;
@@ -746,6 +761,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetFolderResult> GetFolderOutcome;
 			typedef std::future<GetFolderOutcome> GetFolderOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::GetFolderRequest&, const GetFolderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFolderAsyncHandler;
+			typedef Outcome<Error, Model::GetIDEEventDetailResult> GetIDEEventDetailOutcome;
+			typedef std::future<GetIDEEventDetailOutcome> GetIDEEventDetailOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetIDEEventDetailRequest&, const GetIDEEventDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetIDEEventDetailAsyncHandler;
 			typedef Outcome<Error, Model::GetInstanceResult> GetInstanceOutcome;
 			typedef std::future<GetInstanceOutcome> GetInstanceOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::GetInstanceRequest&, const GetInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInstanceAsyncHandler;
@@ -815,6 +833,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetMigrationProcessResult> GetMigrationProcessOutcome;
 			typedef std::future<GetMigrationProcessOutcome> GetMigrationProcessOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMigrationProcessRequest&, const GetMigrationProcessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMigrationProcessAsyncHandler;
+			typedef Outcome<Error, Model::GetMigrationSummaryResult> GetMigrationSummaryOutcome;
+			typedef std::future<GetMigrationSummaryOutcome> GetMigrationSummaryOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMigrationSummaryRequest&, const GetMigrationSummaryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMigrationSummaryAsyncHandler;
 			typedef Outcome<Error, Model::GetNodeResult> GetNodeOutcome;
 			typedef std::future<GetNodeOutcome> GetNodeOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::GetNodeRequest&, const GetNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNodeAsyncHandler;
@@ -905,6 +926,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListDISyncTasksResult> ListDISyncTasksOutcome;
 			typedef std::future<ListDISyncTasksOutcome> ListDISyncTasksOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::ListDISyncTasksRequest&, const ListDISyncTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDISyncTasksAsyncHandler;
+			typedef Outcome<Error, Model::ListDagsResult> ListDagsOutcome;
+			typedef std::future<ListDagsOutcome> ListDagsOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListDagsRequest&, const ListDagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDagsAsyncHandler;
 			typedef Outcome<Error, Model::ListDataServiceApiAuthoritiesResult> ListDataServiceApiAuthoritiesOutcome;
 			typedef std::future<ListDataServiceApiAuthoritiesOutcome> ListDataServiceApiAuthoritiesOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::ListDataServiceApiAuthoritiesRequest&, const ListDataServiceApiAuthoritiesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDataServiceApiAuthoritiesAsyncHandler;
@@ -929,6 +953,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListDataSourcesResult> ListDataSourcesOutcome;
 			typedef std::future<ListDataSourcesOutcome> ListDataSourcesOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::ListDataSourcesRequest&, const ListDataSourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDataSourcesAsyncHandler;
+			typedef Outcome<Error, Model::ListDeploymentsResult> ListDeploymentsOutcome;
+			typedef std::future<ListDeploymentsOutcome> ListDeploymentsOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::ListDeploymentsRequest&, const ListDeploymentsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDeploymentsAsyncHandler;
 			typedef Outcome<Error, Model::ListFileTypeResult> ListFileTypeOutcome;
 			typedef std::future<ListFileTypeOutcome> ListFileTypeOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::ListFileTypeRequest&, const ListFileTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFileTypeAsyncHandler;
@@ -1124,6 +1151,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateFolderResult> UpdateFolderOutcome;
 			typedef std::future<UpdateFolderOutcome> UpdateFolderOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateFolderRequest&, const UpdateFolderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateFolderAsyncHandler;
+			typedef Outcome<Error, Model::UpdateIDEEventResultResult> UpdateIDEEventResultOutcome;
+			typedef std::future<UpdateIDEEventResultOutcome> UpdateIDEEventResultOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateIDEEventResultRequest&, const UpdateIDEEventResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateIDEEventResultAsyncHandler;
 			typedef Outcome<Error, Model::UpdateMetaCategoryResult> UpdateMetaCategoryOutcome;
 			typedef std::future<UpdateMetaCategoryOutcome> UpdateMetaCategoryOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateMetaCategoryRequest&, const UpdateMetaCategoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateMetaCategoryAsyncHandler;
@@ -1231,6 +1261,9 @@ namespace AlibabaCloud
 			CreateDataSourceOutcome createDataSource(const Model::CreateDataSourceRequest &request)const;
 			void createDataSourceAsync(const Model::CreateDataSourceRequest& request, const CreateDataSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDataSourceOutcomeCallable createDataSourceCallable(const Model::CreateDataSourceRequest& request) const;
+			CreateExportMigrationOutcome createExportMigration(const Model::CreateExportMigrationRequest &request)const;
+			void createExportMigrationAsync(const Model::CreateExportMigrationRequest& request, const CreateExportMigrationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateExportMigrationOutcomeCallable createExportMigrationCallable(const Model::CreateExportMigrationRequest& request) const;
 			CreateFileOutcome createFile(const Model::CreateFileRequest &request)const;
 			void createFileAsync(const Model::CreateFileRequest& request, const CreateFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateFileOutcomeCallable createFileCallable(const Model::CreateFileRequest& request) const;
@@ -1432,6 +1465,9 @@ namespace AlibabaCloud
 			GetFolderOutcome getFolder(const Model::GetFolderRequest &request)const;
 			void getFolderAsync(const Model::GetFolderRequest& request, const GetFolderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetFolderOutcomeCallable getFolderCallable(const Model::GetFolderRequest& request) const;
+			GetIDEEventDetailOutcome getIDEEventDetail(const Model::GetIDEEventDetailRequest &request)const;
+			void getIDEEventDetailAsync(const Model::GetIDEEventDetailRequest& request, const GetIDEEventDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetIDEEventDetailOutcomeCallable getIDEEventDetailCallable(const Model::GetIDEEventDetailRequest& request) const;
 			GetInstanceOutcome getInstance(const Model::GetInstanceRequest &request)const;
 			void getInstanceAsync(const Model::GetInstanceRequest& request, const GetInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetInstanceOutcomeCallable getInstanceCallable(const Model::GetInstanceRequest& request) const;
@@ -1501,6 +1537,9 @@ namespace AlibabaCloud
 			GetMigrationProcessOutcome getMigrationProcess(const Model::GetMigrationProcessRequest &request)const;
 			void getMigrationProcessAsync(const Model::GetMigrationProcessRequest& request, const GetMigrationProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetMigrationProcessOutcomeCallable getMigrationProcessCallable(const Model::GetMigrationProcessRequest& request) const;
+			GetMigrationSummaryOutcome getMigrationSummary(const Model::GetMigrationSummaryRequest &request)const;
+			void getMigrationSummaryAsync(const Model::GetMigrationSummaryRequest& request, const GetMigrationSummaryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMigrationSummaryOutcomeCallable getMigrationSummaryCallable(const Model::GetMigrationSummaryRequest& request) const;
 			GetNodeOutcome getNode(const Model::GetNodeRequest &request)const;
 			void getNodeAsync(const Model::GetNodeRequest& request, const GetNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetNodeOutcomeCallable getNodeCallable(const Model::GetNodeRequest& request) const;
@@ -1591,6 +1630,9 @@ namespace AlibabaCloud
 			ListDISyncTasksOutcome listDISyncTasks(const Model::ListDISyncTasksRequest &request)const;
 			void listDISyncTasksAsync(const Model::ListDISyncTasksRequest& request, const ListDISyncTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListDISyncTasksOutcomeCallable listDISyncTasksCallable(const Model::ListDISyncTasksRequest& request) const;
+			ListDagsOutcome listDags(const Model::ListDagsRequest &request)const;
+			void listDagsAsync(const Model::ListDagsRequest& request, const ListDagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListDagsOutcomeCallable listDagsCallable(const Model::ListDagsRequest& request) const;
 			ListDataServiceApiAuthoritiesOutcome listDataServiceApiAuthorities(const Model::ListDataServiceApiAuthoritiesRequest &request)const;
 			void listDataServiceApiAuthoritiesAsync(const Model::ListDataServiceApiAuthoritiesRequest& request, const ListDataServiceApiAuthoritiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListDataServiceApiAuthoritiesOutcomeCallable listDataServiceApiAuthoritiesCallable(const Model::ListDataServiceApiAuthoritiesRequest& request) const;
@@ -1615,6 +1657,9 @@ namespace AlibabaCloud
 			ListDataSourcesOutcome listDataSources(const Model::ListDataSourcesRequest &request)const;
 			void listDataSourcesAsync(const Model::ListDataSourcesRequest& request, const ListDataSourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListDataSourcesOutcomeCallable listDataSourcesCallable(const Model::ListDataSourcesRequest& request) const;
+			ListDeploymentsOutcome listDeployments(const Model::ListDeploymentsRequest &request)const;
+			void listDeploymentsAsync(const Model::ListDeploymentsRequest& request, const ListDeploymentsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListDeploymentsOutcomeCallable listDeploymentsCallable(const Model::ListDeploymentsRequest& request) const;
 			ListFileTypeOutcome listFileType(const Model::ListFileTypeRequest &request)const;
 			void listFileTypeAsync(const Model::ListFileTypeRequest& request, const ListFileTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListFileTypeOutcomeCallable listFileTypeCallable(const Model::ListFileTypeRequest& request) const;
@@ -1810,6 +1855,9 @@ namespace AlibabaCloud
 			UpdateFolderOutcome updateFolder(const Model::UpdateFolderRequest &request)const;
 			void updateFolderAsync(const Model::UpdateFolderRequest& request, const UpdateFolderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateFolderOutcomeCallable updateFolderCallable(const Model::UpdateFolderRequest& request) const;
+			UpdateIDEEventResultOutcome updateIDEEventResult(const Model::UpdateIDEEventResultRequest &request)const;
+			void updateIDEEventResultAsync(const Model::UpdateIDEEventResultRequest& request, const UpdateIDEEventResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateIDEEventResultOutcomeCallable updateIDEEventResultCallable(const Model::UpdateIDEEventResultRequest& request) const;
 			UpdateMetaCategoryOutcome updateMetaCategory(const Model::UpdateMetaCategoryRequest &request)const;
 			void updateMetaCategoryAsync(const Model::UpdateMetaCategoryRequest& request, const UpdateMetaCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateMetaCategoryOutcomeCallable updateMetaCategoryCallable(const Model::UpdateMetaCategoryRequest& request) const;

dataworks-public/include/alibabacloud/dataworks-public/model/CreateExportMigrationRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEEXPORTMIGRATIONREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEEXPORTMIGRATIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateExportMigrationRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateExportMigrationRequest();
+				~CreateExportMigrationRequest();
+
+				std::string getExportObjectStatus()const;
+				void setExportObjectStatus(const std::string& exportObjectStatus);
+				std::string getExportMode()const;
+				void setExportMode(const std::string& exportMode);
+				long getIncrementalSince()const;
+				void setIncrementalSince(long incrementalSince);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+
+            private:
+				std::string exportObjectStatus_;
+				std::string exportMode_;
+				long incrementalSince_;
+				std::string name_;
+				std::string description_;
+				long projectId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEEXPORTMIGRATIONREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateExportMigrationResult.h

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

dataworks-public/include/alibabacloud/dataworks-public/model/GetDagResult.h

@@ -35,17 +35,18 @@ namespace AlibabaCloud
 				struct Data
 				{
 					std::string status;
-					long gmtdate;
 					long modifyTime;
-					std::string type;
-					long finishTime;
 					long createTime;
 					long projectId;
 					long startTime;
 					std::string createUser;
 					long dagId;
-					std::string name;
 					long bizdate;
+					std::string name;
+					long gmtdate;
+					std::string type;
+					long opSeq;
+					long finishTime;
 				};
 
 

dataworks-public/include/alibabacloud/dataworks-public/model/GetIDEEventDetailRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETIDEEVENTDETAILREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETIDEEVENTDETAILREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT GetIDEEventDetailRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetIDEEventDetailRequest();
+				~GetIDEEventDetailRequest();
+
+				std::string getMessageId()const;
+				void setMessageId(const std::string& messageId);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+
+            private:
+				std::string messageId_;
+				long projectId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETIDEEVENTDETAILREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/GetIDEEventDetailResult.h

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_DATAWORKS_PUBLIC_MODEL_GETIDEEVENTDETAILRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETIDEEVENTDETAILRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT GetIDEEventDetailResult : public ServiceResult
+			{
+			public:
+				struct EventDetail
+				{
+					struct FileExecutionCommand
+					{
+						std::string dataSourceName;
+						long fileType;
+						std::string content;
+						long fileId;
+					};
+					struct DeletedFile
+					{
+						long parentFileId;
+						std::string owner;
+						long fileType;
+						std::string dataSourceName;
+						std::string content;
+						long currentVersion;
+						std::string fileName;
+						std::string useType;
+						long nodeId;
+						long fileId;
+						std::string folderId;
+						long businessId;
+					};
+					struct CommittedFile
+					{
+						struct FilePropertyContent
+						{
+							long parentFileId;
+							std::string owner;
+							std::string dataSourceName;
+							long currentVersion;
+							std::string folderId;
+							long businessId;
+						};
+						struct NodeConfiguration
+						{
+							struct Input
+							{
+								std::string input;
+								std::string parseType;
+							};
+							struct Output
+							{
+								std::string output;
+								std::string refTableName;
+							};
+							std::string cycleType;
+							std::vector<Input> inputList;
+							std::string dependentNodeIdList;
+							long resourceGroupId;
+							long autoRerunIntervalMillis;
+							std::string dependentType;
+							long autoRerunTimes;
+							std::string rerunMode;
+							std::string schedulerType;
+							std::string paraValue;
+							std::string cronExpress;
+							std::vector<Output> outputList;
+						};
+						std::string committor;
+						std::string comment;
+						long fileType;
+						std::string changeType;
+						std::string content;
+						FilePropertyContent filePropertyContent;
+						std::string fileName;
+						std::string useType;
+						long nodeId;
+						long fileId;
+						NodeConfiguration nodeConfiguration;
+					};
+					struct TableModel
+					{
+						struct Column
+						{
+							std::string columnName;
+							std::string comment;
+							std::string columnType;
+							bool isPartitionColumn;
+						};
+						long lifeCycle;
+						std::string tableName;
+						std::string comment;
+						std::string dataSourceName;
+						std::vector<Column> columns;
+						std::string env;
+						std::string location;
+					};
+					CommittedFile committedFile;
+					DeletedFile deletedFile;
+					FileExecutionCommand fileExecutionCommand;
+					TableModel tableModel;
+				};
+
+
+				GetIDEEventDetailResult();
+				explicit GetIDEEventDetailResult(const std::string &payload);
+				~GetIDEEventDetailResult();
+				EventDetail getEventDetail()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				EventDetail eventDetail_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETIDEEVENTDETAILRESULT_H_

dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceResult.h

@@ -40,11 +40,11 @@ namespace AlibabaCloud
 					std::string nodeName;
 					std::string paramValues;
 					long dagId;
-					long bizdate;
 					long beginRunningTime;
+					long bizdate;
 					long finishTime;
-					std::string dqcDescription;
 					std::string taskType;
+					std::string dqcDescription;
 					long businessId;
 					std::string status;
 					int taskRerunTime;
@@ -53,6 +53,7 @@ namespace AlibabaCloud
 					int dqcType;
 					long createTime;
 					std::string connection;
+					std::string createUser;
 					long relatedFlowId;
 					long cycTime;
 					long beginWaitTimeTime;

dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceStatusStatisticRequest.h

@@ -37,14 +37,20 @@ namespace AlibabaCloud
 
 				std::string getProjectEnv()const;
 				void setProjectEnv(const std::string& projectEnv);
+				std::string getDagType()const;
+				void setDagType(const std::string& dagType);
 				std::string getBizDate()const;
 				void setBizDate(const std::string& bizDate);
+				std::string getSchedulerType()const;
+				void setSchedulerType(const std::string& schedulerType);
 				long getProjectId()const;
 				void setProjectId(long projectId);
 
             private:
 				std::string projectEnv_;
+				std::string dagType_;
 				std::string bizDate_;
+				std::string schedulerType_;
 				long projectId_;
 
 			};

dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceStatusStatisticResult.h

@@ -35,11 +35,11 @@ namespace AlibabaCloud
 				struct StatusCount
 				{
 					int totalCount;
-					int runningCount;
 					int failureCount;
+					int runningCount;
 					int waitResCount;
-					int notRunCount;
 					int successCount;
+					int notRunCount;
 					int waitTimeCount;
 				};
 

dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesResult.h

@@ -41,6 +41,7 @@ namespace AlibabaCloud
 					std::string nodeName;
 					long createTime;
 					std::string paramValues;
+					std::string createUser;
 					long cycTime;
 					long beginWaitTimeTime;
 					long dagId;

dataworks-public/include/alibabacloud/dataworks-public/model/GetMetaTableColumnResult.h

@@ -43,6 +43,7 @@ namespace AlibabaCloud
 						bool isPartitionColumn;
 						int position;
 						bool isForeignKey;
+						long relationCount;
 						std::string caption;
 						bool isPrimaryKey;
 					};

dataworks-public/include/alibabacloud/dataworks-public/model/GetMetaTableLineageResult.h

@@ -38,6 +38,7 @@ namespace AlibabaCloud
 					{
 						std::string tableName;
 						std::string tableGuid;
+						long createTimestamp;
 					};
 					std::vector<DataEntityListItem> dataEntityList;
 					bool hasNext;

dataworks-public/include/alibabacloud/dataworks-public/model/GetMigrationSummaryRequest.h

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

dataworks-public/include/alibabacloud/dataworks-public/model/GetMigrationSummaryResult.h

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

dataworks-public/include/alibabacloud/dataworks-public/model/GetNodeChildrenResult.h

@@ -41,8 +41,8 @@ namespace AlibabaCloud
 						std::string ownerId;
 						std::string nodeName;
 						int priority;
-						long nodeId;
 						long projectId;
+						long nodeId;
 						std::string schedulerType;
 						std::string programType;
 						std::string cronExpress;

dataworks-public/include/alibabacloud/dataworks-public/model/GetNodeParentsResult.h

@@ -41,8 +41,8 @@ namespace AlibabaCloud
 						std::string ownerId;
 						std::string nodeName;
 						int priority;
-						long nodeId;
 						long projectId;
+						long nodeId;
 						std::string schedulerType;
 						std::string programType;
 						std::string cronExpress;

dataworks-public/include/alibabacloud/dataworks-public/model/GetQualityRuleResult.h

@@ -50,13 +50,13 @@ namespace AlibabaCloud
 					bool fixCheck;
 					int blockType;
 					std::string onDutyAccountName;
-					std::string templateName;
 					int predictType;
-					long id;
+					std::string templateName;
 					std::string methodName;
+					long id;
 					std::string property;
-					int templateId;
 					std::string ruleName;
+					int templateId;
 				};
 
 

dataworks-public/include/alibabacloud/dataworks-public/model/ListDagsRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDAGSREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDAGSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT ListDagsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListDagsRequest();
+				~ListDagsRequest();
+
+				std::string getProjectEnv()const;
+				void setProjectEnv(const std::string& projectEnv);
+				long getOpSeq()const;
+				void setOpSeq(long opSeq);
+
+            private:
+				std::string projectEnv_;
+				long opSeq_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDAGSREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/ListDagsResult.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDAGSRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDAGSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT ListDagsResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Dag
+					{
+						std::string status;
+						long modifyTime;
+						long createTime;
+						long projectId;
+						long startTime;
+						std::string createUser;
+						long dagId;
+						long bizdate;
+						std::string name;
+						long gmtdate;
+						std::string type;
+						long opSeq;
+						long finishTime;
+					};
+					std::vector<Dag> dags;
+				};
+
+
+				ListDagsResult();
+				explicit ListDagsResult(const std::string &payload);
+				~ListDagsResult();
+				int getHttpStatusCode()const;
+				Data getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				Data data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDAGSRESULT_H_

dataworks-public/include/alibabacloud/dataworks-public/model/ListDeploymentsRequest.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDEPLOYMENTSREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDEPLOYMENTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT ListDeploymentsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListDeploymentsRequest();
+				~ListDeploymentsRequest();
+
+				std::string getCreator()const;
+				void setCreator(const std::string& creator);
+				long getEndCreateTime()const;
+				void setEndCreateTime(long endCreateTime);
+				std::string getProjectIdentifier()const;
+				void setProjectIdentifier(const std::string& projectIdentifier);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getExecutor()const;
+				void setExecutor(const std::string& executor);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				long getEndExecuteTime()const;
+				void setEndExecuteTime(long endExecuteTime);
+				std::string getKeyword()const;
+				void setKeyword(const std::string& keyword);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+				int getStatus()const;
+				void setStatus(int status);
+
+            private:
+				std::string creator_;
+				long endCreateTime_;
+				std::string projectIdentifier_;
+				int pageNumber_;
+				std::string executor_;
+				int pageSize_;
+				long endExecuteTime_;
+				std::string keyword_;
+				long projectId_;
+				int status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDEPLOYMENTSREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/ListDeploymentsResult.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDEPLOYMENTSRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDEPLOYMENTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT ListDeploymentsResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Deployment
+					{
+						int status;
+						std::string executor;
+						long executeTime;
+						long createTime;
+						std::string creator;
+						long id;
+						std::string errorMessage;
+						std::string name;
+					};
+					long totalCount;
+					long pageSize;
+					long pageNumber;
+					std::vector<Deployment> deployments;
+				};
+
+
+				ListDeploymentsResult();
+				explicit ListDeploymentsResult(const std::string &payload);
+				~ListDeploymentsResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDEPLOYMENTSRESULT_H_

dataworks-public/include/alibabacloud/dataworks-public/model/ListInstancesResult.h

@@ -42,11 +42,11 @@ namespace AlibabaCloud
 						std::string nodeName;
 						std::string paramValues;
 						long dagId;
-						long bizdate;
 						long beginRunningTime;
+						long bizdate;
 						long finishTime;
-						std::string dqcDescription;
 						std::string taskType;
+						std::string dqcDescription;
 						long businessId;
 						std::string status;
 						int taskRerunTime;
@@ -55,6 +55,7 @@ namespace AlibabaCloud
 						int dqcType;
 						long createTime;
 						std::string connection;
+						std::string createUser;
 						long relatedFlowId;
 						long cycTime;
 						long beginWaitTimeTime;

dataworks-public/include/alibabacloud/dataworks-public/model/ListManualDagInstancesResult.h

@@ -41,6 +41,7 @@ namespace AlibabaCloud
 					std::string nodeName;
 					long createTime;
 					std::string paramValues;
+					std::string createUser;
 					long cycTime;
 					long beginWaitTimeTime;
 					long dagId;

dataworks-public/include/alibabacloud/dataworks-public/model/ListQualityResultsByEntityResult.h

@@ -40,44 +40,44 @@ namespace AlibabaCloud
 						{
 							int singleCheckResult;
 							float value;
-							std::string bizDate;
 							std::string discreteProperty;
+							std::string bizDate;
 							float threshold;
 						};
 						struct SampleValueItem
 						{
 							float value;
-							std::string bizDate;
 							std::string discreteProperty;
+							std::string bizDate;
 						};
 						std::string op;
 						std::vector<RuleChecksItem::SampleValueItem> sampleValue;
 						std::string taskId;
-						long endTime;
-						bool discreteCheck;
 						std::string checkerName;
-						float expectValue;
+						bool discreteCheck;
+						long endTime;
 						std::string projectName;
+						float expectValue;
 						std::vector<RuleChecksItem::ReferenceValueItem> referenceValue;
-						int ruleId;
 						float warningThreshold;
-						std::string whereCondition;
+						int ruleId;
 						long beginTime;
+						std::string whereCondition;
 						int checkResultStatus;
 						std::string matchExpression;
 						float upperValue;
 						bool isPrediction;
 						int checkResult;
 						std::string templateName;
-						std::string timeCost;
 						bool fixedCheck;
+						std::string timeCost;
 						std::string methodName;
 						std::string resultString;
 						std::string property;
 						std::string dateType;
 						long bizDate;
-						int templateId;
 						std::string ruleName;
+						int templateId;
 						std::string comment;
 						float criticalThreshold;
 						std::string externalId;
@@ -88,8 +88,8 @@ namespace AlibabaCloud
 						int entityId;
 						std::string tableName;
 						int blockType;
-						int id;
 						std::string actualExpression;
+						int id;
 						float lowerValue;
 					};
 					long totalCount;

dataworks-public/include/alibabacloud/dataworks-public/model/ListQualityResultsByRuleResult.h

@@ -40,44 +40,44 @@ namespace AlibabaCloud
 						{
 							int singleCheckResult;
 							float value;
-							std::string bizDate;
 							std::string discreteProperty;
+							std::string bizDate;
 							float threshold;
 						};
 						struct SampleValueItem
 						{
 							float value;
-							std::string bizDate;
 							std::string discreteProperty;
+							std::string bizDate;
 						};
 						std::string op;
 						std::vector<RuleChecksItem::SampleValueItem> sampleValue;
 						std::string taskId;
-						long endTime;
-						bool discreteCheck;
 						std::string checkerName;
-						float expectValue;
+						bool discreteCheck;
+						long endTime;
 						std::string projectName;
+						float expectValue;
 						std::vector<RuleChecksItem::ReferenceValueItem> referenceValue;
-						int ruleId;
 						float warningThreshold;
-						std::string whereCondition;
+						int ruleId;
 						long beginTime;
+						std::string whereCondition;
 						int checkResultStatus;
 						std::string matchExpression;
 						float upperValue;
 						bool isPrediction;
 						int checkResult;
 						std::string templateName;
-						std::string timeCost;
 						bool fixedCheck;
+						std::string timeCost;
 						std::string methodName;
 						std::string resultString;
 						std::string property;
 						std::string dateType;
 						long bizDate;
-						int templateId;
 						std::string ruleName;
+						int templateId;
 						std::string comment;
 						float criticalThreshold;
 						std::string externalId;
@@ -88,8 +88,8 @@ namespace AlibabaCloud
 						int entityId;
 						std::string tableName;
 						int blockType;
-						int id;
 						std::string actualExpression;
+						int id;
 						float lowerValue;
 					};
 					long totalCount;

dataworks-public/include/alibabacloud/dataworks-public/model/ListQualityRulesResult.h

@@ -49,6 +49,7 @@ namespace AlibabaCloud
 						std::string methodName;
 						std::string property;
 						int templateId;
+						std::string ruleName;
 						std::string comment;
 						std::string criticalThreshold;
 						std::string trend;

dataworks-public/include/alibabacloud/dataworks-public/model/UpdateIDEEventResultRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATEIDEEVENTRESULTREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATEIDEEVENTRESULTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dataworks_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT UpdateIDEEventResultRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateIDEEventResultRequest();
+				~UpdateIDEEventResultRequest();
+
+				std::string getCheckResultTip()const;
+				void setCheckResultTip(const std::string& checkResultTip);
+				std::string getCheckResult()const;
+				void setCheckResult(const std::string& checkResult);
+				std::string getMessageId()const;
+				void setMessageId(const std::string& messageId);
+				std::string getExtensionCode()const;
+				void setExtensionCode(const std::string& extensionCode);
+
+            private:
+				std::string checkResultTip_;
+				std::string checkResult_;
+				std::string messageId_;
+				std::string extensionCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATEIDEEVENTRESULTREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/UpdateIDEEventResultResult.h

@@ -14,38 +14,36 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRRESULT_H_
-#define ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRRESULT_H_
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATEIDEEVENTRESULTRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATEIDEEVENTRESULTRESULT_H_
 
 #include <string>
 #include <vector>
 #include <utility>
 #include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/ecs/EcsExport.h>
+#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Ecs
+	namespace Dataworks_public
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_ECS_EXPORT CreateDiskReplicaPairResult : public ServiceResult
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT UpdateIDEEventResultResult : public ServiceResult
 			{
 			public:
 
 
-				CreateDiskReplicaPairResult();
-				explicit CreateDiskReplicaPairResult(const std::string &payload);
-				~CreateDiskReplicaPairResult();
-				std::string getPairId()const;
+				UpdateIDEEventResultResult();
+				explicit UpdateIDEEventResultResult(const std::string &payload);
+				~UpdateIDEEventResultResult();
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string pairId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRRESULT_H_
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATEIDEEVENTRESULTRESULT_H_

dataworks-public/src/Dataworks-publicClient.cc

@@ -771,6 +771,42 @@ Dataworks_publicClient::CreateDataSourceOutcomeCallable Dataworks_publicClient::
 	return task->get_future();
 }
 
+Dataworks_publicClient::CreateExportMigrationOutcome Dataworks_publicClient::createExportMigration(const CreateExportMigrationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateExportMigrationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateExportMigrationOutcome(CreateExportMigrationResult(outcome.result()));
+	else
+		return CreateExportMigrationOutcome(outcome.error());
+}
+
+void Dataworks_publicClient::createExportMigrationAsync(const CreateExportMigrationRequest& request, const CreateExportMigrationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createExportMigration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dataworks_publicClient::CreateExportMigrationOutcomeCallable Dataworks_publicClient::createExportMigrationCallable(const CreateExportMigrationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateExportMigrationOutcome()>>(
+			[this, request]()
+			{
+			return this->createExportMigration(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dataworks_publicClient::CreateFileOutcome Dataworks_publicClient::createFile(const CreateFileRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3183,6 +3219,42 @@ Dataworks_publicClient::GetFolderOutcomeCallable Dataworks_publicClient::getFold
 	return task->get_future();
 }
 
+Dataworks_publicClient::GetIDEEventDetailOutcome Dataworks_publicClient::getIDEEventDetail(const GetIDEEventDetailRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetIDEEventDetailOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetIDEEventDetailOutcome(GetIDEEventDetailResult(outcome.result()));
+	else
+		return GetIDEEventDetailOutcome(outcome.error());
+}
+
+void Dataworks_publicClient::getIDEEventDetailAsync(const GetIDEEventDetailRequest& request, const GetIDEEventDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getIDEEventDetail(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dataworks_publicClient::GetIDEEventDetailOutcomeCallable Dataworks_publicClient::getIDEEventDetailCallable(const GetIDEEventDetailRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetIDEEventDetailOutcome()>>(
+			[this, request]()
+			{
+			return this->getIDEEventDetail(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dataworks_publicClient::GetInstanceOutcome Dataworks_publicClient::getInstance(const GetInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4011,6 +4083,42 @@ Dataworks_publicClient::GetMigrationProcessOutcomeCallable Dataworks_publicClien
 	return task->get_future();
 }
 
+Dataworks_publicClient::GetMigrationSummaryOutcome Dataworks_publicClient::getMigrationSummary(const GetMigrationSummaryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetMigrationSummaryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetMigrationSummaryOutcome(GetMigrationSummaryResult(outcome.result()));
+	else
+		return GetMigrationSummaryOutcome(outcome.error());
+}
+
+void Dataworks_publicClient::getMigrationSummaryAsync(const GetMigrationSummaryRequest& request, const GetMigrationSummaryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getMigrationSummary(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dataworks_publicClient::GetMigrationSummaryOutcomeCallable Dataworks_publicClient::getMigrationSummaryCallable(const GetMigrationSummaryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetMigrationSummaryOutcome()>>(
+			[this, request]()
+			{
+			return this->getMigrationSummary(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dataworks_publicClient::GetNodeOutcome Dataworks_publicClient::getNode(const GetNodeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5091,6 +5199,42 @@ Dataworks_publicClient::ListDISyncTasksOutcomeCallable Dataworks_publicClient::l
 	return task->get_future();
 }
 
+Dataworks_publicClient::ListDagsOutcome Dataworks_publicClient::listDags(const ListDagsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListDagsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListDagsOutcome(ListDagsResult(outcome.result()));
+	else
+		return ListDagsOutcome(outcome.error());
+}
+
+void Dataworks_publicClient::listDagsAsync(const ListDagsRequest& request, const ListDagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listDags(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dataworks_publicClient::ListDagsOutcomeCallable Dataworks_publicClient::listDagsCallable(const ListDagsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListDagsOutcome()>>(
+			[this, request]()
+			{
+			return this->listDags(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dataworks_publicClient::ListDataServiceApiAuthoritiesOutcome Dataworks_publicClient::listDataServiceApiAuthorities(const ListDataServiceApiAuthoritiesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5379,6 +5523,42 @@ Dataworks_publicClient::ListDataSourcesOutcomeCallable Dataworks_publicClient::l
 	return task->get_future();
 }
 
+Dataworks_publicClient::ListDeploymentsOutcome Dataworks_publicClient::listDeployments(const ListDeploymentsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListDeploymentsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListDeploymentsOutcome(ListDeploymentsResult(outcome.result()));
+	else
+		return ListDeploymentsOutcome(outcome.error());
+}
+
+void Dataworks_publicClient::listDeploymentsAsync(const ListDeploymentsRequest& request, const ListDeploymentsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listDeployments(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dataworks_publicClient::ListDeploymentsOutcomeCallable Dataworks_publicClient::listDeploymentsCallable(const ListDeploymentsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListDeploymentsOutcome()>>(
+			[this, request]()
+			{
+			return this->listDeployments(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dataworks_publicClient::ListFileTypeOutcome Dataworks_publicClient::listFileType(const ListFileTypeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -7719,6 +7899,42 @@ Dataworks_publicClient::UpdateFolderOutcomeCallable Dataworks_publicClient::upda
 	return task->get_future();
 }
 
+Dataworks_publicClient::UpdateIDEEventResultOutcome Dataworks_publicClient::updateIDEEventResult(const UpdateIDEEventResultRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateIDEEventResultOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateIDEEventResultOutcome(UpdateIDEEventResultResult(outcome.result()));
+	else
+		return UpdateIDEEventResultOutcome(outcome.error());
+}
+
+void Dataworks_publicClient::updateIDEEventResultAsync(const UpdateIDEEventResultRequest& request, const UpdateIDEEventResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateIDEEventResult(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dataworks_publicClient::UpdateIDEEventResultOutcomeCallable Dataworks_publicClient::updateIDEEventResultCallable(const UpdateIDEEventResultRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateIDEEventResultOutcome()>>(
+			[this, request]()
+			{
+			return this->updateIDEEventResult(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dataworks_publicClient::UpdateMetaCategoryOutcome Dataworks_publicClient::updateMetaCategory(const UpdateMetaCategoryRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

dataworks-public/src/model/CreateExportMigrationRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/dataworks-public/model/CreateExportMigrationRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::CreateExportMigrationRequest;
+
+CreateExportMigrationRequest::CreateExportMigrationRequest() :
+	RpcServiceRequest("dataworks-public", "2020-05-18", "CreateExportMigration")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateExportMigrationRequest::~CreateExportMigrationRequest()
+{}
+
+std::string CreateExportMigrationRequest::getExportObjectStatus()const
+{
+	return exportObjectStatus_;
+}
+
+void CreateExportMigrationRequest::setExportObjectStatus(const std::string& exportObjectStatus)
+{
+	exportObjectStatus_ = exportObjectStatus;
+	setBodyParameter("ExportObjectStatus", exportObjectStatus);
+}
+
+std::string CreateExportMigrationRequest::getExportMode()const
+{
+	return exportMode_;
+}
+
+void CreateExportMigrationRequest::setExportMode(const std::string& exportMode)
+{
+	exportMode_ = exportMode;
+	setBodyParameter("ExportMode", exportMode);
+}
+
+long CreateExportMigrationRequest::getIncrementalSince()const
+{
+	return incrementalSince_;
+}
+
+void CreateExportMigrationRequest::setIncrementalSince(long incrementalSince)
+{
+	incrementalSince_ = incrementalSince;
+	setBodyParameter("IncrementalSince", std::to_string(incrementalSince));
+}
+
+std::string CreateExportMigrationRequest::getName()const
+{
+	return name_;
+}
+
+void CreateExportMigrationRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setBodyParameter("Name", name);
+}
+
+std::string CreateExportMigrationRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateExportMigrationRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setBodyParameter("Description", description);
+}
+
+long CreateExportMigrationRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void CreateExportMigrationRequest::setProjectId(long projectId)
+{
+	projectId_ = projectId;
+	setBodyParameter("ProjectId", std::to_string(projectId));
+}
+

dataworks-public/src/model/CreateExportMigrationResult.cc

@@ -14,38 +14,45 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/ecs/model/CreateDiskReplicaPairResult.h>
+#include <alibabacloud/dataworks-public/model/CreateExportMigrationResult.h>
 #include <json/json.h>
 
-using namespace AlibabaCloud::Ecs;
-using namespace AlibabaCloud::Ecs::Model;
+using namespace AlibabaCloud::Dataworks_public;
+using namespace AlibabaCloud::Dataworks_public::Model;
 
-CreateDiskReplicaPairResult::CreateDiskReplicaPairResult() :
+CreateExportMigrationResult::CreateExportMigrationResult() :
 	ServiceResult()
 {}
 
-CreateDiskReplicaPairResult::CreateDiskReplicaPairResult(const std::string &payload) :
+CreateExportMigrationResult::CreateExportMigrationResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateDiskReplicaPairResult::~CreateDiskReplicaPairResult()
+CreateExportMigrationResult::~CreateExportMigrationResult()
 {}
 
-void CreateDiskReplicaPairResult::parse(const std::string &payload)
+void CreateExportMigrationResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["PairId"].isNull())
-		pairId_ = value["PairId"].asString();
+	if(!value["Data"].isNull())
+		data_ = std::stol(value["Data"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 
-std::string CreateDiskReplicaPairResult::getPairId()const
+long CreateExportMigrationResult::getData()const
 {
-	return pairId_;
+	return data_;
+}
+
+bool CreateExportMigrationResult::getSuccess()const
+{
+	return success_;
 }
 

dataworks-public/src/model/CreateQualityEntityResult.cc

@@ -39,16 +39,16 @@ void CreateQualityEntityResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["Data"].isNull())
-		data_ = std::stoi(value["Data"].asString());
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Data"].isNull())
+		data_ = std::stoi(value["Data"].asString());
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
 
 }
 

dataworks-public/src/model/CreateQualityFollowerResult.cc

@@ -39,16 +39,16 @@ void CreateQualityFollowerResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
-	if(!value["Data"].isNull())
-		data_ = std::stoi(value["Data"].asString());
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Data"].isNull())
+		data_ = std::stoi(value["Data"].asString());
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 

dataworks-public/src/model/CreateQualityRelativeNodeResult.cc

@@ -39,16 +39,16 @@ void CreateQualityRelativeNodeResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
 	if(!value["Data"].isNull())
 		data_ = value["Data"].asString() == "true";
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
 
 }
 

dataworks-public/src/model/CreateQualityRuleResult.cc

@@ -39,16 +39,16 @@ void CreateQualityRuleResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
-	if(!value["Data"].isNull())
-		data_ = value["Data"].asString();
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 

dataworks-public/src/model/CreateTableResult.cc

@@ -40,14 +40,14 @@ void CreateTableResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto taskInfoNode = value["TaskInfo"];
-	if(!taskInfoNode["TaskId"].isNull())
-		taskInfo_.taskId = taskInfoNode["TaskId"].asString();
-	if(!taskInfoNode["Content"].isNull())
-		taskInfo_.content = taskInfoNode["Content"].asString();
 	if(!taskInfoNode["Status"].isNull())
 		taskInfo_.status = taskInfoNode["Status"].asString();
 	if(!taskInfoNode["NextTaskId"].isNull())
 		taskInfo_.nextTaskId = taskInfoNode["NextTaskId"].asString();
+	if(!taskInfoNode["TaskId"].isNull())
+		taskInfo_.taskId = taskInfoNode["TaskId"].asString();
+	if(!taskInfoNode["Content"].isNull())
+		taskInfo_.content = taskInfoNode["Content"].asString();
 
 }
 

dataworks-public/src/model/DeleteQualityEntityResult.cc

@@ -39,16 +39,16 @@ void DeleteQualityEntityResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
 	if(!value["Data"].isNull())
 		data_ = value["Data"].asString() == "true";
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
 
 }
 

dataworks-public/src/model/DeleteQualityRelativeNodeResult.cc

@@ -39,16 +39,16 @@ void DeleteQualityRelativeNodeResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
 	if(!value["Data"].isNull())
 		data_ = value["Data"].asString() == "true";
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
 
 }
 

dataworks-public/src/model/GetDagResult.cc

@@ -40,38 +40,40 @@ void GetDagResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["ProjectId"].isNull())
-		data_.projectId = std::stol(dataNode["ProjectId"].asString());
-	if(!dataNode["DagId"].isNull())
-		data_.dagId = std::stol(dataNode["DagId"].asString());
-	if(!dataNode["Name"].isNull())
-		data_.name = dataNode["Name"].asString();
 	if(!dataNode["Type"].isNull())
 		data_.type = dataNode["Type"].asString();
 	if(!dataNode["Status"].isNull())
 		data_.status = dataNode["Status"].asString();
-	if(!dataNode["Bizdate"].isNull())
-		data_.bizdate = std::stol(dataNode["Bizdate"].asString());
-	if(!dataNode["Gmtdate"].isNull())
-		data_.gmtdate = std::stol(dataNode["Gmtdate"].asString());
-	if(!dataNode["StartTime"].isNull())
-		data_.startTime = std::stol(dataNode["StartTime"].asString());
 	if(!dataNode["FinishTime"].isNull())
 		data_.finishTime = std::stol(dataNode["FinishTime"].asString());
 	if(!dataNode["CreateTime"].isNull())
 		data_.createTime = std::stol(dataNode["CreateTime"].asString());
+	if(!dataNode["ProjectId"].isNull())
+		data_.projectId = std::stol(dataNode["ProjectId"].asString());
+	if(!dataNode["DagId"].isNull())
+		data_.dagId = std::stol(dataNode["DagId"].asString());
+	if(!dataNode["Gmtdate"].isNull())
+		data_.gmtdate = std::stol(dataNode["Gmtdate"].asString());
+	if(!dataNode["StartTime"].isNull())
+		data_.startTime = std::stol(dataNode["StartTime"].asString());
 	if(!dataNode["CreateUser"].isNull())
 		data_.createUser = dataNode["CreateUser"].asString();
+	if(!dataNode["Bizdate"].isNull())
+		data_.bizdate = std::stol(dataNode["Bizdate"].asString());
+	if(!dataNode["Name"].isNull())
+		data_.name = dataNode["Name"].asString();
 	if(!dataNode["ModifyTime"].isNull())
 		data_.modifyTime = std::stol(dataNode["ModifyTime"].asString());
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
+	if(!dataNode["OpSeq"].isNull())
+		data_.opSeq = std::stol(dataNode["OpSeq"].asString());
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
 	if(!value["ErrorMessage"].isNull())
 		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 

dataworks-public/src/model/GetIDEEventDetailRequest.cc

@@ -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/dataworks-public/model/GetIDEEventDetailRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::GetIDEEventDetailRequest;
+
+GetIDEEventDetailRequest::GetIDEEventDetailRequest() :
+	RpcServiceRequest("dataworks-public", "2020-05-18", "GetIDEEventDetail")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetIDEEventDetailRequest::~GetIDEEventDetailRequest()
+{}
+
+std::string GetIDEEventDetailRequest::getMessageId()const
+{
+	return messageId_;
+}
+
+void GetIDEEventDetailRequest::setMessageId(const std::string& messageId)
+{
+	messageId_ = messageId;
+	setBodyParameter("MessageId", messageId);
+}
+
+long GetIDEEventDetailRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void GetIDEEventDetailRequest::setProjectId(long projectId)
+{
+	projectId_ = projectId;
+	setBodyParameter("ProjectId", std::to_string(projectId));
+}
+

dataworks-public/src/model/GetIDEEventDetailResult.cc

@@ -0,0 +1,184 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/dataworks-public/model/GetIDEEventDetailResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dataworks_public;
+using namespace AlibabaCloud::Dataworks_public::Model;
+
+GetIDEEventDetailResult::GetIDEEventDetailResult() :
+	ServiceResult()
+{}
+
+GetIDEEventDetailResult::GetIDEEventDetailResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetIDEEventDetailResult::~GetIDEEventDetailResult()
+{}
+
+void GetIDEEventDetailResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto eventDetailNode = value["EventDetail"];
+	auto fileExecutionCommandNode = eventDetailNode["FileExecutionCommand"];
+	if(!fileExecutionCommandNode["FileId"].isNull())
+		eventDetail_.fileExecutionCommand.fileId = std::stol(fileExecutionCommandNode["FileId"].asString());
+	if(!fileExecutionCommandNode["DataSourceName"].isNull())
+		eventDetail_.fileExecutionCommand.dataSourceName = fileExecutionCommandNode["DataSourceName"].asString();
+	if(!fileExecutionCommandNode["Content"].isNull())
+		eventDetail_.fileExecutionCommand.content = fileExecutionCommandNode["Content"].asString();
+	if(!fileExecutionCommandNode["FileType"].isNull())
+		eventDetail_.fileExecutionCommand.fileType = std::stol(fileExecutionCommandNode["FileType"].asString());
+	auto deletedFileNode = eventDetailNode["DeletedFile"];
+	if(!deletedFileNode["Owner"].isNull())
+		eventDetail_.deletedFile.owner = deletedFileNode["Owner"].asString();
+	if(!deletedFileNode["FileType"].isNull())
+		eventDetail_.deletedFile.fileType = std::stol(deletedFileNode["FileType"].asString());
+	if(!deletedFileNode["CurrentVersion"].isNull())
+		eventDetail_.deletedFile.currentVersion = std::stol(deletedFileNode["CurrentVersion"].asString());
+	if(!deletedFileNode["BusinessId"].isNull())
+		eventDetail_.deletedFile.businessId = std::stol(deletedFileNode["BusinessId"].asString());
+	if(!deletedFileNode["FileName"].isNull())
+		eventDetail_.deletedFile.fileName = deletedFileNode["FileName"].asString();
+	if(!deletedFileNode["DataSourceName"].isNull())
+		eventDetail_.deletedFile.dataSourceName = deletedFileNode["DataSourceName"].asString();
+	if(!deletedFileNode["UseType"].isNull())
+		eventDetail_.deletedFile.useType = deletedFileNode["UseType"].asString();
+	if(!deletedFileNode["FolderId"].isNull())
+		eventDetail_.deletedFile.folderId = deletedFileNode["FolderId"].asString();
+	if(!deletedFileNode["ParentFileId"].isNull())
+		eventDetail_.deletedFile.parentFileId = std::stol(deletedFileNode["ParentFileId"].asString());
+	if(!deletedFileNode["Content"].isNull())
+		eventDetail_.deletedFile.content = deletedFileNode["Content"].asString();
+	if(!deletedFileNode["NodeId"].isNull())
+		eventDetail_.deletedFile.nodeId = std::stol(deletedFileNode["NodeId"].asString());
+	if(!deletedFileNode["FileId"].isNull())
+		eventDetail_.deletedFile.fileId = std::stol(deletedFileNode["FileId"].asString());
+	auto committedFileNode = eventDetailNode["CommittedFile"];
+	if(!committedFileNode["FileId"].isNull())
+		eventDetail_.committedFile.fileId = std::stol(committedFileNode["FileId"].asString());
+	if(!committedFileNode["Content"].isNull())
+		eventDetail_.committedFile.content = committedFileNode["Content"].asString();
+	if(!committedFileNode["Committor"].isNull())
+		eventDetail_.committedFile.committor = committedFileNode["Committor"].asString();
+	if(!committedFileNode["FileType"].isNull())
+		eventDetail_.committedFile.fileType = std::stol(committedFileNode["FileType"].asString());
+	if(!committedFileNode["ChangeType"].isNull())
+		eventDetail_.committedFile.changeType = committedFileNode["ChangeType"].asString();
+	if(!committedFileNode["FileName"].isNull())
+		eventDetail_.committedFile.fileName = committedFileNode["FileName"].asString();
+	if(!committedFileNode["NodeId"].isNull())
+		eventDetail_.committedFile.nodeId = std::stol(committedFileNode["NodeId"].asString());
+	if(!committedFileNode["Comment"].isNull())
+		eventDetail_.committedFile.comment = committedFileNode["Comment"].asString();
+	if(!committedFileNode["UseType"].isNull())
+		eventDetail_.committedFile.useType = committedFileNode["UseType"].asString();
+	auto filePropertyContentNode = committedFileNode["FilePropertyContent"];
+	if(!filePropertyContentNode["DataSourceName"].isNull())
+		eventDetail_.committedFile.filePropertyContent.dataSourceName = filePropertyContentNode["DataSourceName"].asString();
+	if(!filePropertyContentNode["ParentFileId"].isNull())
+		eventDetail_.committedFile.filePropertyContent.parentFileId = std::stol(filePropertyContentNode["ParentFileId"].asString());
+	if(!filePropertyContentNode["BusinessId"].isNull())
+		eventDetail_.committedFile.filePropertyContent.businessId = std::stol(filePropertyContentNode["BusinessId"].asString());
+	if(!filePropertyContentNode["CurrentVersion"].isNull())
+		eventDetail_.committedFile.filePropertyContent.currentVersion = std::stol(filePropertyContentNode["CurrentVersion"].asString());
+	if(!filePropertyContentNode["Owner"].isNull())
+		eventDetail_.committedFile.filePropertyContent.owner = filePropertyContentNode["Owner"].asString();
+	if(!filePropertyContentNode["FolderId"].isNull())
+		eventDetail_.committedFile.filePropertyContent.folderId = filePropertyContentNode["FolderId"].asString();
+	auto nodeConfigurationNode = committedFileNode["NodeConfiguration"];
+	if(!nodeConfigurationNode["RerunMode"].isNull())
+		eventDetail_.committedFile.nodeConfiguration.rerunMode = nodeConfigurationNode["RerunMode"].asString();
+	if(!nodeConfigurationNode["SchedulerType"].isNull())
+		eventDetail_.committedFile.nodeConfiguration.schedulerType = nodeConfigurationNode["SchedulerType"].asString();
+	if(!nodeConfigurationNode["ParaValue"].isNull())
+		eventDetail_.committedFile.nodeConfiguration.paraValue = nodeConfigurationNode["ParaValue"].asString();
+	if(!nodeConfigurationNode["CycleType"].isNull())
+		eventDetail_.committedFile.nodeConfiguration.cycleType = nodeConfigurationNode["CycleType"].asString();
+	if(!nodeConfigurationNode["DependentNodeIdList"].isNull())
+		eventDetail_.committedFile.nodeConfiguration.dependentNodeIdList = nodeConfigurationNode["DependentNodeIdList"].asString();
+	if(!nodeConfigurationNode["ResourceGroupId"].isNull())
+		eventDetail_.committedFile.nodeConfiguration.resourceGroupId = std::stol(nodeConfigurationNode["ResourceGroupId"].asString());
+	if(!nodeConfigurationNode["AutoRerunTimes"].isNull())
+		eventDetail_.committedFile.nodeConfiguration.autoRerunTimes = std::stol(nodeConfigurationNode["AutoRerunTimes"].asString());
+	if(!nodeConfigurationNode["AutoRerunIntervalMillis"].isNull())
+		eventDetail_.committedFile.nodeConfiguration.autoRerunIntervalMillis = std::stol(nodeConfigurationNode["AutoRerunIntervalMillis"].asString());
+	if(!nodeConfigurationNode["CronExpress"].isNull())
+		eventDetail_.committedFile.nodeConfiguration.cronExpress = nodeConfigurationNode["CronExpress"].asString();
+	if(!nodeConfigurationNode["DependentType"].isNull())
+		eventDetail_.committedFile.nodeConfiguration.dependentType = nodeConfigurationNode["DependentType"].asString();
+	auto allInputListNode = nodeConfigurationNode["InputList"]["Input"];
+	for (auto nodeConfigurationNodeInputListInput : allInputListNode)
+	{
+		EventDetail::CommittedFile::NodeConfiguration::Input inputObject;
+		if(!nodeConfigurationNodeInputListInput["Input"].isNull())
+			inputObject.input = nodeConfigurationNodeInputListInput["Input"].asString();
+		if(!nodeConfigurationNodeInputListInput["ParseType"].isNull())
+			inputObject.parseType = nodeConfigurationNodeInputListInput["ParseType"].asString();
+		eventDetail_.committedFile.nodeConfiguration.inputList.push_back(inputObject);
+	}
+	auto allOutputListNode = nodeConfigurationNode["OutputList"]["Output"];
+	for (auto nodeConfigurationNodeOutputListOutput : allOutputListNode)
+	{
+		EventDetail::CommittedFile::NodeConfiguration::Output outputObject;
+		if(!nodeConfigurationNodeOutputListOutput["RefTableName"].isNull())
+			outputObject.refTableName = nodeConfigurationNodeOutputListOutput["RefTableName"].asString();
+		if(!nodeConfigurationNodeOutputListOutput["Output"].isNull())
+			outputObject.output = nodeConfigurationNodeOutputListOutput["Output"].asString();
+		eventDetail_.committedFile.nodeConfiguration.outputList.push_back(outputObject);
+	}
+	auto tableModelNode = eventDetailNode["TableModel"];
+	if(!tableModelNode["Env"].isNull())
+		eventDetail_.tableModel.env = tableModelNode["Env"].asString();
+	if(!tableModelNode["LifeCycle"].isNull())
+		eventDetail_.tableModel.lifeCycle = std::stol(tableModelNode["LifeCycle"].asString());
+	if(!tableModelNode["TableName"].isNull())
+		eventDetail_.tableModel.tableName = tableModelNode["TableName"].asString();
+	if(!tableModelNode["DataSourceName"].isNull())
+		eventDetail_.tableModel.dataSourceName = tableModelNode["DataSourceName"].asString();
+	if(!tableModelNode["Comment"].isNull())
+		eventDetail_.tableModel.comment = tableModelNode["Comment"].asString();
+	if(!tableModelNode["Location"].isNull())
+		eventDetail_.tableModel.location = tableModelNode["Location"].asString();
+	auto allColumnsNode = tableModelNode["Columns"]["Column"];
+	for (auto tableModelNodeColumnsColumn : allColumnsNode)
+	{
+		EventDetail::TableModel::Column columnObject;
+		if(!tableModelNodeColumnsColumn["ColumnName"].isNull())
+			columnObject.columnName = tableModelNodeColumnsColumn["ColumnName"].asString();
+		if(!tableModelNodeColumnsColumn["ColumnType"].isNull())
+			columnObject.columnType = tableModelNodeColumnsColumn["ColumnType"].asString();
+		if(!tableModelNodeColumnsColumn["IsPartitionColumn"].isNull())
+			columnObject.isPartitionColumn = tableModelNodeColumnsColumn["IsPartitionColumn"].asString() == "true";
+		if(!tableModelNodeColumnsColumn["Comment"].isNull())
+			columnObject.comment = tableModelNodeColumnsColumn["Comment"].asString();
+		eventDetail_.tableModel.columns.push_back(columnObject);
+	}
+
+}
+
+GetIDEEventDetailResult::EventDetail GetIDEEventDetailResult::getEventDetail()const
+{
+	return eventDetail_;
+}
+

dataworks-public/src/model/GetInstanceResult.cc

@@ -40,68 +40,70 @@ void GetInstanceResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["NodeId"].isNull())
-		data_.nodeId = std::stol(dataNode["NodeId"].asString());
-	if(!dataNode["InstanceId"].isNull())
-		data_.instanceId = std::stol(dataNode["InstanceId"].asString());
-	if(!dataNode["DagId"].isNull())
-		data_.dagId = std::stol(dataNode["DagId"].asString());
-	if(!dataNode["DagType"].isNull())
-		data_.dagType = dataNode["DagType"].asString();
 	if(!dataNode["Status"].isNull())
 		data_.status = dataNode["Status"].asString();
-	if(!dataNode["Bizdate"].isNull())
-		data_.bizdate = std::stol(dataNode["Bizdate"].asString());
-	if(!dataNode["ParamValues"].isNull())
-		data_.paramValues = dataNode["ParamValues"].asString();
 	if(!dataNode["CycTime"].isNull())
 		data_.cycTime = std::stol(dataNode["CycTime"].asString());
-	if(!dataNode["FinishTime"].isNull())
-		data_.finishTime = std::stol(dataNode["FinishTime"].asString());
-	if(!dataNode["BeginWaitTimeTime"].isNull())
-		data_.beginWaitTimeTime = std::stol(dataNode["BeginWaitTimeTime"].asString());
-	if(!dataNode["BeginWaitResTime"].isNull())
-		data_.beginWaitResTime = std::stol(dataNode["BeginWaitResTime"].asString());
 	if(!dataNode["BeginRunningTime"].isNull())
 		data_.beginRunningTime = std::stol(dataNode["BeginRunningTime"].asString());
+	if(!dataNode["FinishTime"].isNull())
+		data_.finishTime = std::stol(dataNode["FinishTime"].asString());
+	if(!dataNode["ErrorMessage"].isNull())
+		data_.errorMessage = dataNode["ErrorMessage"].asString();
 	if(!dataNode["CreateTime"].isNull())
 		data_.createTime = std::stol(dataNode["CreateTime"].asString());
-	if(!dataNode["ModifyTime"].isNull())
-		data_.modifyTime = std::stol(dataNode["ModifyTime"].asString());
-	if(!dataNode["NodeName"].isNull())
-		data_.nodeName = dataNode["NodeName"].asString();
+	if(!dataNode["DagId"].isNull())
+		data_.dagId = std::stol(dataNode["DagId"].asString());
 	if(!dataNode["Priority"].isNull())
 		data_.priority = std::stoi(dataNode["Priority"].asString());
+	if(!dataNode["TaskType"].isNull())
+		data_.taskType = dataNode["TaskType"].asString();
+	if(!dataNode["ParamValues"].isNull())
+		data_.paramValues = dataNode["ParamValues"].asString();
+	if(!dataNode["Connection"].isNull())
+		data_.connection = dataNode["Connection"].asString();
 	if(!dataNode["BaselineId"].isNull())
 		data_.baselineId = std::stol(dataNode["BaselineId"].asString());
+	if(!dataNode["DqcType"].isNull())
+		data_.dqcType = std::stoi(dataNode["DqcType"].asString());
+	if(!dataNode["DagType"].isNull())
+		data_.dagType = dataNode["DagType"].asString();
+	if(!dataNode["BusinessId"].isNull())
+		data_.businessId = std::stol(dataNode["BusinessId"].asString());
+	if(!dataNode["TaskRerunTime"].isNull())
+		data_.taskRerunTime = std::stoi(dataNode["TaskRerunTime"].asString());
+	if(!dataNode["ModifyTime"].isNull())
+		data_.modifyTime = std::stol(dataNode["ModifyTime"].asString());
 	if(!dataNode["Repeatability"].isNull())
 		data_.repeatability = dataNode["Repeatability"].asString() == "true";
 	if(!dataNode["RepeatInterval"].isNull())
 		data_.repeatInterval = std::stol(dataNode["RepeatInterval"].asString());
-	if(!dataNode["Connection"].isNull())
-		data_.connection = dataNode["Connection"].asString();
-	if(!dataNode["DqcType"].isNull())
-		data_.dqcType = std::stoi(dataNode["DqcType"].asString());
-	if(!dataNode["DqcDescription"].isNull())
-		data_.dqcDescription = dataNode["DqcDescription"].asString();
-	if(!dataNode["ErrorMessage"].isNull())
-		data_.errorMessage = dataNode["ErrorMessage"].asString();
+	if(!dataNode["InstanceId"].isNull())
+		data_.instanceId = std::stol(dataNode["InstanceId"].asString());
+	if(!dataNode["BeginWaitResTime"].isNull())
+		data_.beginWaitResTime = std::stol(dataNode["BeginWaitResTime"].asString());
 	if(!dataNode["RelatedFlowId"].isNull())
 		data_.relatedFlowId = std::stol(dataNode["RelatedFlowId"].asString());
-	if(!dataNode["TaskType"].isNull())
-		data_.taskType = dataNode["TaskType"].asString();
-	if(!dataNode["TaskRerunTime"].isNull())
-		data_.taskRerunTime = std::stoi(dataNode["TaskRerunTime"].asString());
-	if(!dataNode["BusinessId"].isNull())
-		data_.businessId = std::stol(dataNode["BusinessId"].asString());
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
+	if(!dataNode["Bizdate"].isNull())
+		data_.bizdate = std::stol(dataNode["Bizdate"].asString());
+	if(!dataNode["NodeName"].isNull())
+		data_.nodeName = dataNode["NodeName"].asString();
+	if(!dataNode["BeginWaitTimeTime"].isNull())
+		data_.beginWaitTimeTime = std::stol(dataNode["BeginWaitTimeTime"].asString());
+	if(!dataNode["DqcDescription"].isNull())
+		data_.dqcDescription = dataNode["DqcDescription"].asString();
+	if(!dataNode["NodeId"].isNull())
+		data_.nodeId = std::stol(dataNode["NodeId"].asString());
+	if(!dataNode["CreateUser"].isNull())
+		data_.createUser = dataNode["CreateUser"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["Success"].isNull())
 		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
 
 }
 

dataworks-public/src/model/GetInstanceStatusStatisticRequest.cc

@@ -38,6 +38,17 @@ void GetInstanceStatusStatisticRequest::setProjectEnv(const std::string& project
 	setBodyParameter("ProjectEnv", projectEnv);
 }
 
+std::string GetInstanceStatusStatisticRequest::getDagType()const
+{
+	return dagType_;
+}
+
+void GetInstanceStatusStatisticRequest::setDagType(const std::string& dagType)
+{
+	dagType_ = dagType;
+	setBodyParameter("DagType", dagType);
+}
+
 std::string GetInstanceStatusStatisticRequest::getBizDate()const
 {
 	return bizDate_;
@@ -49,6 +60,17 @@ void GetInstanceStatusStatisticRequest::setBizDate(const std::string& bizDate)
 	setBodyParameter("BizDate", bizDate);
 }
 
+std::string GetInstanceStatusStatisticRequest::getSchedulerType()const
+{
+	return schedulerType_;
+}
+
+void GetInstanceStatusStatisticRequest::setSchedulerType(const std::string& schedulerType)
+{
+	schedulerType_ = schedulerType;
+	setBodyParameter("SchedulerType", schedulerType);
+}
+
 long GetInstanceStatusStatisticRequest::getProjectId()const
 {
 	return projectId_;

dataworks-public/src/model/GetInstanceStatusStatisticResult.cc

@@ -40,20 +40,20 @@ void GetInstanceStatusStatisticResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto statusCountNode = value["StatusCount"];
+	if(!statusCountNode["FailureCount"].isNull())
+		statusCount_.failureCount = std::stoi(statusCountNode["FailureCount"].asString());
+	if(!statusCountNode["WaitTimeCount"].isNull())
+		statusCount_.waitTimeCount = std::stoi(statusCountNode["WaitTimeCount"].asString());
+	if(!statusCountNode["RunningCount"].isNull())
+		statusCount_.runningCount = std::stoi(statusCountNode["RunningCount"].asString());
+	if(!statusCountNode["SuccessCount"].isNull())
+		statusCount_.successCount = std::stoi(statusCountNode["SuccessCount"].asString());
 	if(!statusCountNode["TotalCount"].isNull())
 		statusCount_.totalCount = std::stoi(statusCountNode["TotalCount"].asString());
 	if(!statusCountNode["NotRunCount"].isNull())
 		statusCount_.notRunCount = std::stoi(statusCountNode["NotRunCount"].asString());
-	if(!statusCountNode["WaitTimeCount"].isNull())
-		statusCount_.waitTimeCount = std::stoi(statusCountNode["WaitTimeCount"].asString());
 	if(!statusCountNode["WaitResCount"].isNull())
 		statusCount_.waitResCount = std::stoi(statusCountNode["WaitResCount"].asString());
-	if(!statusCountNode["RunningCount"].isNull())
-		statusCount_.runningCount = std::stoi(statusCountNode["RunningCount"].asString());
-	if(!statusCountNode["FailureCount"].isNull())
-		statusCount_.failureCount = std::stoi(statusCountNode["FailureCount"].asString());
-	if(!statusCountNode["SuccessCount"].isNull())
-		statusCount_.successCount = std::stoi(statusCountNode["SuccessCount"].asString());
 
 }
 

dataworks-public/src/model/GetManualDagInstancesResult.cc

@@ -43,38 +43,40 @@ void GetManualDagInstancesResult::parse(const std::string &payload)
 	for (auto valueInstancesInstancesItem : allInstancesNode)
 	{
 		InstancesItem instancesObject;
-		if(!valueInstancesInstancesItem["NodeId"].isNull())
-			instancesObject.nodeId = std::stol(valueInstancesInstancesItem["NodeId"].asString());
-		if(!valueInstancesInstancesItem["InstanceId"].isNull())
-			instancesObject.instanceId = std::stol(valueInstancesInstancesItem["InstanceId"].asString());
-		if(!valueInstancesInstancesItem["DagId"].isNull())
-			instancesObject.dagId = std::stol(valueInstancesInstancesItem["DagId"].asString());
-		if(!valueInstancesInstancesItem["DagType"].isNull())
-			instancesObject.dagType = valueInstancesInstancesItem["DagType"].asString();
 		if(!valueInstancesInstancesItem["Status"].isNull())
 			instancesObject.status = valueInstancesInstancesItem["Status"].asString();
+		if(!valueInstancesInstancesItem["BeginRunningTime"].isNull())
+			instancesObject.beginRunningTime = std::stol(valueInstancesInstancesItem["BeginRunningTime"].asString());
 		if(!valueInstancesInstancesItem["BizDate"].isNull())
 			instancesObject.bizDate = std::stol(valueInstancesInstancesItem["BizDate"].asString());
 		if(!valueInstancesInstancesItem["CycTime"].isNull())
 			instancesObject.cycTime = std::stol(valueInstancesInstancesItem["CycTime"].asString());
+		if(!valueInstancesInstancesItem["FinishTime"].isNull())
+			instancesObject.finishTime = std::stol(valueInstancesInstancesItem["FinishTime"].asString());
 		if(!valueInstancesInstancesItem["CreateTime"].isNull())
 			instancesObject.createTime = std::stol(valueInstancesInstancesItem["CreateTime"].asString());
-		if(!valueInstancesInstancesItem["ModifyTime"].isNull())
-			instancesObject.modifyTime = std::stol(valueInstancesInstancesItem["ModifyTime"].asString());
+		if(!valueInstancesInstancesItem["DagId"].isNull())
+			instancesObject.dagId = std::stol(valueInstancesInstancesItem["DagId"].asString());
+		if(!valueInstancesInstancesItem["InstanceId"].isNull())
+			instancesObject.instanceId = std::stol(valueInstancesInstancesItem["InstanceId"].asString());
+		if(!valueInstancesInstancesItem["BeginWaitResTime"].isNull())
+			instancesObject.beginWaitResTime = std::stol(valueInstancesInstancesItem["BeginWaitResTime"].asString());
+		if(!valueInstancesInstancesItem["TaskType"].isNull())
+			instancesObject.taskType = valueInstancesInstancesItem["TaskType"].asString();
+		if(!valueInstancesInstancesItem["ParamValues"].isNull())
+			instancesObject.paramValues = valueInstancesInstancesItem["ParamValues"].asString();
+		if(!valueInstancesInstancesItem["DagType"].isNull())
+			instancesObject.dagType = valueInstancesInstancesItem["DagType"].asString();
 		if(!valueInstancesInstancesItem["NodeName"].isNull())
 			instancesObject.nodeName = valueInstancesInstancesItem["NodeName"].asString();
 		if(!valueInstancesInstancesItem["BeginWaitTimeTime"].isNull())
 			instancesObject.beginWaitTimeTime = std::stol(valueInstancesInstancesItem["BeginWaitTimeTime"].asString());
-		if(!valueInstancesInstancesItem["BeginWaitResTime"].isNull())
-			instancesObject.beginWaitResTime = std::stol(valueInstancesInstancesItem["BeginWaitResTime"].asString());
-		if(!valueInstancesInstancesItem["BeginRunningTime"].isNull())
-			instancesObject.beginRunningTime = std::stol(valueInstancesInstancesItem["BeginRunningTime"].asString());
-		if(!valueInstancesInstancesItem["ParamValues"].isNull())
-			instancesObject.paramValues = valueInstancesInstancesItem["ParamValues"].asString();
-		if(!valueInstancesInstancesItem["FinishTime"].isNull())
-			instancesObject.finishTime = std::stol(valueInstancesInstancesItem["FinishTime"].asString());
-		if(!valueInstancesInstancesItem["TaskType"].isNull())
-			instancesObject.taskType = valueInstancesInstancesItem["TaskType"].asString();
+		if(!valueInstancesInstancesItem["NodeId"].isNull())
+			instancesObject.nodeId = std::stol(valueInstancesInstancesItem["NodeId"].asString());
+		if(!valueInstancesInstancesItem["ModifyTime"].isNull())
+			instancesObject.modifyTime = std::stol(valueInstancesInstancesItem["ModifyTime"].asString());
+		if(!valueInstancesInstancesItem["CreateUser"].isNull())
+			instancesObject.createUser = valueInstancesInstancesItem["CreateUser"].asString();
 		instances_.push_back(instancesObject);
 	}
 

dataworks-public/src/model/GetMetaTableColumnResult.cc

@@ -40,44 +40,46 @@ void GetMetaTableColumnResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["TotalCount"].isNull())
-		data_.totalCount = std::stol(dataNode["TotalCount"].asString());
 	if(!dataNode["PageNum"].isNull())
 		data_.pageNum = std::stoi(dataNode["PageNum"].asString());
 	if(!dataNode["PageSize"].isNull())
 		data_.pageSize = std::stoi(dataNode["PageSize"].asString());
+	if(!dataNode["TotalCount"].isNull())
+		data_.totalCount = std::stol(dataNode["TotalCount"].asString());
 	auto allColumnListNode = dataNode["ColumnList"]["ColumnListItem"];
 	for (auto dataNodeColumnListColumnListItem : allColumnListNode)
 	{
 		Data::ColumnListItem columnListItemObject;
-		if(!dataNodeColumnListColumnListItem["ColumnName"].isNull())
-			columnListItemObject.columnName = dataNodeColumnListColumnListItem["ColumnName"].asString();
 		if(!dataNodeColumnListColumnListItem["ColumnGuid"].isNull())
 			columnListItemObject.columnGuid = dataNodeColumnListColumnListItem["ColumnGuid"].asString();
-		if(!dataNodeColumnListColumnListItem["Comment"].isNull())
-			columnListItemObject.comment = dataNodeColumnListColumnListItem["Comment"].asString();
-		if(!dataNodeColumnListColumnListItem["IsPrimaryKey"].isNull())
-			columnListItemObject.isPrimaryKey = dataNodeColumnListColumnListItem["IsPrimaryKey"].asString() == "true";
-		if(!dataNodeColumnListColumnListItem["ColumnType"].isNull())
-			columnListItemObject.columnType = dataNodeColumnListColumnListItem["ColumnType"].asString();
+		if(!dataNodeColumnListColumnListItem["ColumnName"].isNull())
+			columnListItemObject.columnName = dataNodeColumnListColumnListItem["ColumnName"].asString();
 		if(!dataNodeColumnListColumnListItem["IsPartitionColumn"].isNull())
 			columnListItemObject.isPartitionColumn = dataNodeColumnListColumnListItem["IsPartitionColumn"].asString() == "true";
-		if(!dataNodeColumnListColumnListItem["IsForeignKey"].isNull())
-			columnListItemObject.isForeignKey = dataNodeColumnListColumnListItem["IsForeignKey"].asString() == "true";
-		if(!dataNodeColumnListColumnListItem["Caption"].isNull())
-			columnListItemObject.caption = dataNodeColumnListColumnListItem["Caption"].asString();
+		if(!dataNodeColumnListColumnListItem["Comment"].isNull())
+			columnListItemObject.comment = dataNodeColumnListColumnListItem["Comment"].asString();
+		if(!dataNodeColumnListColumnListItem["ColumnType"].isNull())
+			columnListItemObject.columnType = dataNodeColumnListColumnListItem["ColumnType"].asString();
+		if(!dataNodeColumnListColumnListItem["IsPrimaryKey"].isNull())
+			columnListItemObject.isPrimaryKey = dataNodeColumnListColumnListItem["IsPrimaryKey"].asString() == "true";
 		if(!dataNodeColumnListColumnListItem["Position"].isNull())
 			columnListItemObject.position = std::stoi(dataNodeColumnListColumnListItem["Position"].asString());
+		if(!dataNodeColumnListColumnListItem["Caption"].isNull())
+			columnListItemObject.caption = dataNodeColumnListColumnListItem["Caption"].asString();
+		if(!dataNodeColumnListColumnListItem["IsForeignKey"].isNull())
+			columnListItemObject.isForeignKey = dataNodeColumnListColumnListItem["IsForeignKey"].asString() == "true";
+		if(!dataNodeColumnListColumnListItem["RelationCount"].isNull())
+			columnListItemObject.relationCount = std::stol(dataNodeColumnListColumnListItem["RelationCount"].asString());
 		data_.columnList.push_back(columnListItemObject);
 	}
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["Success"].isNull())
 		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
 
 }
 

dataworks-public/src/model/GetMetaTableLineageResult.cc

@@ -40,10 +40,10 @@ void GetMetaTableLineageResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["HasNext"].isNull())
-		data_.hasNext = dataNode["HasNext"].asString() == "true";
 	if(!dataNode["NextPrimaryKey"].isNull())
 		data_.nextPrimaryKey = dataNode["NextPrimaryKey"].asString();
+	if(!dataNode["HasNext"].isNull())
+		data_.hasNext = dataNode["HasNext"].asString() == "true";
 	auto allDataEntityListNode = dataNode["DataEntityList"]["DataEntityListItem"];
 	for (auto dataNodeDataEntityListDataEntityListItem : allDataEntityListNode)
 	{
@@ -52,16 +52,18 @@ void GetMetaTableLineageResult::parse(const std::string &payload)
 			dataEntityListItemObject.tableName = dataNodeDataEntityListDataEntityListItem["TableName"].asString();
 		if(!dataNodeDataEntityListDataEntityListItem["TableGuid"].isNull())
 			dataEntityListItemObject.tableGuid = dataNodeDataEntityListDataEntityListItem["TableGuid"].asString();
+		if(!dataNodeDataEntityListDataEntityListItem["CreateTimestamp"].isNull())
+			dataEntityListItemObject.createTimestamp = std::stol(dataNodeDataEntityListDataEntityListItem["CreateTimestamp"].asString());
 		data_.dataEntityList.push_back(dataEntityListItemObject);
 	}
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["Success"].isNull())
 		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
 
 }
 

dataworks-public/src/model/GetMigrationSummaryRequest.cc

@@ -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/dataworks-public/model/GetMigrationSummaryRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::GetMigrationSummaryRequest;
+
+GetMigrationSummaryRequest::GetMigrationSummaryRequest() :
+	RpcServiceRequest("dataworks-public", "2020-05-18", "GetMigrationSummary")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetMigrationSummaryRequest::~GetMigrationSummaryRequest()
+{}
+
+long GetMigrationSummaryRequest::getMigrationId()const
+{
+	return migrationId_;
+}
+
+void GetMigrationSummaryRequest::setMigrationId(long migrationId)
+{
+	migrationId_ = migrationId;
+	setBodyParameter("MigrationId", std::to_string(migrationId));
+}
+
+long GetMigrationSummaryRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void GetMigrationSummaryRequest::setProjectId(long projectId)
+{
+	projectId_ = projectId;
+	setBodyParameter("ProjectId", std::to_string(projectId));
+}
+

dataworks-public/src/model/GetMigrationSummaryResult.cc

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

dataworks-public/src/model/GetNodeChildrenResult.cc

@@ -44,36 +44,36 @@ void GetNodeChildrenResult::parse(const std::string &payload)
 	for (auto dataNodeNodesNodesItem : allNodesNode)
 	{
 		Data::NodesItem nodesItemObject;
-		if(!dataNodeNodesNodesItem["NodeId"].isNull())
-			nodesItemObject.nodeId = std::stol(dataNodeNodesNodesItem["NodeId"].asString());
-		if(!dataNodeNodesNodesItem["NodeName"].isNull())
-			nodesItemObject.nodeName = dataNodeNodesNodesItem["NodeName"].asString();
-		if(!dataNodeNodesNodesItem["CronExpress"].isNull())
-			nodesItemObject.cronExpress = dataNodeNodesNodesItem["CronExpress"].asString();
 		if(!dataNodeNodesNodesItem["SchedulerType"].isNull())
 			nodesItemObject.schedulerType = dataNodeNodesNodesItem["SchedulerType"].asString();
-		if(!dataNodeNodesNodesItem["ProgramType"].isNull())
-			nodesItemObject.programType = dataNodeNodesNodesItem["ProgramType"].asString();
-		if(!dataNodeNodesNodesItem["OwnerId"].isNull())
-			nodesItemObject.ownerId = dataNodeNodesNodesItem["OwnerId"].asString();
-		if(!dataNodeNodesNodesItem["ProjectId"].isNull())
-			nodesItemObject.projectId = std::stol(dataNodeNodesNodesItem["ProjectId"].asString());
-		if(!dataNodeNodesNodesItem["Repeatability"].isNull())
-			nodesItemObject.repeatability = dataNodeNodesNodesItem["Repeatability"].asString() == "true";
-		if(!dataNodeNodesNodesItem["Priority"].isNull())
-			nodesItemObject.priority = std::stoi(dataNodeNodesNodesItem["Priority"].asString());
 		if(!dataNodeNodesNodesItem["BaselineId"].isNull())
 			nodesItemObject.baselineId = std::stol(dataNodeNodesNodesItem["BaselineId"].asString());
+		if(!dataNodeNodesNodesItem["Repeatability"].isNull())
+			nodesItemObject.repeatability = dataNodeNodesNodesItem["Repeatability"].asString() == "true";
+		if(!dataNodeNodesNodesItem["NodeName"].isNull())
+			nodesItemObject.nodeName = dataNodeNodesNodesItem["NodeName"].asString();
+		if(!dataNodeNodesNodesItem["ProjectId"].isNull())
+			nodesItemObject.projectId = std::stol(dataNodeNodesNodesItem["ProjectId"].asString());
+		if(!dataNodeNodesNodesItem["ProgramType"].isNull())
+			nodesItemObject.programType = dataNodeNodesNodesItem["ProgramType"].asString();
+		if(!dataNodeNodesNodesItem["Priority"].isNull())
+			nodesItemObject.priority = std::stoi(dataNodeNodesNodesItem["Priority"].asString());
+		if(!dataNodeNodesNodesItem["OwnerId"].isNull())
+			nodesItemObject.ownerId = dataNodeNodesNodesItem["OwnerId"].asString();
+		if(!dataNodeNodesNodesItem["CronExpress"].isNull())
+			nodesItemObject.cronExpress = dataNodeNodesNodesItem["CronExpress"].asString();
+		if(!dataNodeNodesNodesItem["NodeId"].isNull())
+			nodesItemObject.nodeId = std::stol(dataNodeNodesNodesItem["NodeId"].asString());
 		data_.nodes.push_back(nodesItemObject);
 	}
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
 	if(!value["ErrorMessage"].isNull())
 		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 

dataworks-public/src/model/GetNodeParentsResult.cc

@@ -44,36 +44,36 @@ void GetNodeParentsResult::parse(const std::string &payload)
 	for (auto dataNodeNodesNodesItem : allNodesNode)
 	{
 		Data::NodesItem nodesItemObject;
-		if(!dataNodeNodesNodesItem["NodeId"].isNull())
-			nodesItemObject.nodeId = std::stol(dataNodeNodesNodesItem["NodeId"].asString());
-		if(!dataNodeNodesNodesItem["NodeName"].isNull())
-			nodesItemObject.nodeName = dataNodeNodesNodesItem["NodeName"].asString();
-		if(!dataNodeNodesNodesItem["CronExpress"].isNull())
-			nodesItemObject.cronExpress = dataNodeNodesNodesItem["CronExpress"].asString();
 		if(!dataNodeNodesNodesItem["SchedulerType"].isNull())
 			nodesItemObject.schedulerType = dataNodeNodesNodesItem["SchedulerType"].asString();
-		if(!dataNodeNodesNodesItem["ProgramType"].isNull())
-			nodesItemObject.programType = dataNodeNodesNodesItem["ProgramType"].asString();
-		if(!dataNodeNodesNodesItem["OwnerId"].isNull())
-			nodesItemObject.ownerId = dataNodeNodesNodesItem["OwnerId"].asString();
-		if(!dataNodeNodesNodesItem["ProjectId"].isNull())
-			nodesItemObject.projectId = std::stol(dataNodeNodesNodesItem["ProjectId"].asString());
-		if(!dataNodeNodesNodesItem["Repeatability"].isNull())
-			nodesItemObject.repeatability = dataNodeNodesNodesItem["Repeatability"].asString() == "true";
-		if(!dataNodeNodesNodesItem["Priority"].isNull())
-			nodesItemObject.priority = std::stoi(dataNodeNodesNodesItem["Priority"].asString());
 		if(!dataNodeNodesNodesItem["BaselineId"].isNull())
 			nodesItemObject.baselineId = std::stol(dataNodeNodesNodesItem["BaselineId"].asString());
+		if(!dataNodeNodesNodesItem["Repeatability"].isNull())
+			nodesItemObject.repeatability = dataNodeNodesNodesItem["Repeatability"].asString() == "true";
+		if(!dataNodeNodesNodesItem["NodeName"].isNull())
+			nodesItemObject.nodeName = dataNodeNodesNodesItem["NodeName"].asString();
+		if(!dataNodeNodesNodesItem["ProjectId"].isNull())
+			nodesItemObject.projectId = std::stol(dataNodeNodesNodesItem["ProjectId"].asString());
+		if(!dataNodeNodesNodesItem["ProgramType"].isNull())
+			nodesItemObject.programType = dataNodeNodesNodesItem["ProgramType"].asString();
+		if(!dataNodeNodesNodesItem["Priority"].isNull())
+			nodesItemObject.priority = std::stoi(dataNodeNodesNodesItem["Priority"].asString());
+		if(!dataNodeNodesNodesItem["OwnerId"].isNull())
+			nodesItemObject.ownerId = dataNodeNodesNodesItem["OwnerId"].asString();
+		if(!dataNodeNodesNodesItem["CronExpress"].isNull())
+			nodesItemObject.cronExpress = dataNodeNodesNodesItem["CronExpress"].asString();
+		if(!dataNodeNodesNodesItem["NodeId"].isNull())
+			nodesItemObject.nodeId = std::stol(dataNodeNodesNodesItem["NodeId"].asString());
 		data_.nodes.push_back(nodesItemObject);
 	}
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
 	if(!value["ErrorMessage"].isNull())
 		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 

dataworks-public/src/model/GetQualityEntityResult.cc

@@ -43,48 +43,48 @@ void GetQualityEntityResult::parse(const std::string &payload)
 	for (auto valueDataEntityDto : allDataNode)
 	{
 		EntityDto dataObject;
-		if(!valueDataEntityDto["Id"].isNull())
-			dataObject.id = std::stol(valueDataEntityDto["Id"].asString());
-		if(!valueDataEntityDto["ProjectName"].isNull())
-			dataObject.projectName = valueDataEntityDto["ProjectName"].asString();
-		if(!valueDataEntityDto["TableName"].isNull())
-			dataObject.tableName = valueDataEntityDto["TableName"].asString();
-		if(!valueDataEntityDto["EnvType"].isNull())
-			dataObject.envType = valueDataEntityDto["EnvType"].asString();
-		if(!valueDataEntityDto["MatchExpression"].isNull())
-			dataObject.matchExpression = valueDataEntityDto["MatchExpression"].asString();
-		if(!valueDataEntityDto["EntityLevel"].isNull())
-			dataObject.entityLevel = std::stoi(valueDataEntityDto["EntityLevel"].asString());
-		if(!valueDataEntityDto["OnDuty"].isNull())
-			dataObject.onDuty = valueDataEntityDto["OnDuty"].asString();
-		if(!valueDataEntityDto["ModifyUser"].isNull())
-			dataObject.modifyUser = valueDataEntityDto["ModifyUser"].asString();
-		if(!valueDataEntityDto["CreateTime"].isNull())
-			dataObject.createTime = std::stol(valueDataEntityDto["CreateTime"].asString());
-		if(!valueDataEntityDto["ModifyTime"].isNull())
-			dataObject.modifyTime = std::stol(valueDataEntityDto["ModifyTime"].asString());
-		if(!valueDataEntityDto["Sql"].isNull())
-			dataObject.sql = std::stoi(valueDataEntityDto["Sql"].asString());
-		if(!valueDataEntityDto["Task"].isNull())
-			dataObject.task = std::stoi(valueDataEntityDto["Task"].asString());
-		if(!valueDataEntityDto["Followers"].isNull())
-			dataObject.followers = valueDataEntityDto["Followers"].asString();
-		if(!valueDataEntityDto["HasRelativeNode"].isNull())
-			dataObject.hasRelativeNode = valueDataEntityDto["HasRelativeNode"].asString() == "true";
 		if(!valueDataEntityDto["RelativeNode"].isNull())
 			dataObject.relativeNode = valueDataEntityDto["RelativeNode"].asString();
 		if(!valueDataEntityDto["OnDutyAccountName"].isNull())
 			dataObject.onDutyAccountName = valueDataEntityDto["OnDutyAccountName"].asString();
+		if(!valueDataEntityDto["Task"].isNull())
+			dataObject.task = std::stoi(valueDataEntityDto["Task"].asString());
+		if(!valueDataEntityDto["TableName"].isNull())
+			dataObject.tableName = valueDataEntityDto["TableName"].asString();
+		if(!valueDataEntityDto["Followers"].isNull())
+			dataObject.followers = valueDataEntityDto["Followers"].asString();
+		if(!valueDataEntityDto["OnDuty"].isNull())
+			dataObject.onDuty = valueDataEntityDto["OnDuty"].asString();
+		if(!valueDataEntityDto["MatchExpression"].isNull())
+			dataObject.matchExpression = valueDataEntityDto["MatchExpression"].asString();
+		if(!valueDataEntityDto["CreateTime"].isNull())
+			dataObject.createTime = std::stol(valueDataEntityDto["CreateTime"].asString());
+		if(!valueDataEntityDto["ProjectName"].isNull())
+			dataObject.projectName = valueDataEntityDto["ProjectName"].asString();
+		if(!valueDataEntityDto["HasRelativeNode"].isNull())
+			dataObject.hasRelativeNode = valueDataEntityDto["HasRelativeNode"].asString() == "true";
+		if(!valueDataEntityDto["EnvType"].isNull())
+			dataObject.envType = valueDataEntityDto["EnvType"].asString();
+		if(!valueDataEntityDto["EntityLevel"].isNull())
+			dataObject.entityLevel = std::stoi(valueDataEntityDto["EntityLevel"].asString());
+		if(!valueDataEntityDto["ModifyUser"].isNull())
+			dataObject.modifyUser = valueDataEntityDto["ModifyUser"].asString();
+		if(!valueDataEntityDto["Sql"].isNull())
+			dataObject.sql = std::stoi(valueDataEntityDto["Sql"].asString());
+		if(!valueDataEntityDto["Id"].isNull())
+			dataObject.id = std::stol(valueDataEntityDto["Id"].asString());
+		if(!valueDataEntityDto["ModifyTime"].isNull())
+			dataObject.modifyTime = std::stol(valueDataEntityDto["ModifyTime"].asString());
 		data_.push_back(dataObject);
 	}
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 

dataworks-public/src/model/GetQualityRuleResult.cc

@@ -40,60 +40,60 @@ void GetQualityRuleResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["Id"].isNull())
-		data_.id = std::stol(dataNode["Id"].asString());
-	if(!dataNode["EntityId"].isNull())
-		data_.entityId = std::stol(dataNode["EntityId"].asString());
-	if(!dataNode["Property"].isNull())
-		data_.property = dataNode["Property"].asString();
-	if(!dataNode["MethodId"].isNull())
-		data_.methodId = std::stoi(dataNode["MethodId"].asString());
-	if(!dataNode["MethodName"].isNull())
-		data_.methodName = dataNode["MethodName"].asString();
-	if(!dataNode["WhereCondition"].isNull())
-		data_.whereCondition = dataNode["WhereCondition"].asString();
-	if(!dataNode["OnDuty"].isNull())
-		data_.onDuty = dataNode["OnDuty"].asString();
-	if(!dataNode["RuleType"].isNull())
-		data_.ruleType = std::stoi(dataNode["RuleType"].asString());
 	if(!dataNode["BlockType"].isNull())
 		data_.blockType = std::stoi(dataNode["BlockType"].asString());
-	if(!dataNode["TemplateId"].isNull())
-		data_.templateId = std::stoi(dataNode["TemplateId"].asString());
-	if(!dataNode["TemplateName"].isNull())
-		data_.templateName = dataNode["TemplateName"].asString();
-	if(!dataNode["Comment"].isNull())
-		data_.comment = dataNode["Comment"].asString();
-	if(!dataNode["RuleName"].isNull())
-		data_.ruleName = dataNode["RuleName"].asString();
-	if(!dataNode["PredictType"].isNull())
-		data_.predictType = std::stoi(dataNode["PredictType"].asString());
+	if(!dataNode["OnDutyAccountName"].isNull())
+		data_.onDutyAccountName = dataNode["OnDutyAccountName"].asString();
 	if(!dataNode["WarningThreshold"].isNull())
 		data_.warningThreshold = dataNode["WarningThreshold"].asString();
+	if(!dataNode["Property"].isNull())
+		data_.property = dataNode["Property"].asString();
+	if(!dataNode["RuleType"].isNull())
+		data_.ruleType = std::stoi(dataNode["RuleType"].asString());
+	if(!dataNode["Comment"].isNull())
+		data_.comment = dataNode["Comment"].asString();
+	if(!dataNode["OnDuty"].isNull())
+		data_.onDuty = dataNode["OnDuty"].asString();
+	if(!dataNode["Checker"].isNull())
+		data_.checker = std::stoi(dataNode["Checker"].asString());
+	if(!dataNode["FixCheck"].isNull())
+		data_.fixCheck = dataNode["FixCheck"].asString() == "true";
+	if(!dataNode["MethodId"].isNull())
+		data_.methodId = std::stoi(dataNode["MethodId"].asString());
 	if(!dataNode["CriticalThreshold"].isNull())
 		data_.criticalThreshold = dataNode["CriticalThreshold"].asString();
+	if(!dataNode["PredictType"].isNull())
+		data_.predictType = std::stoi(dataNode["PredictType"].asString());
+	if(!dataNode["TemplateName"].isNull())
+		data_.templateName = dataNode["TemplateName"].asString();
+	if(!dataNode["CheckerName"].isNull())
+		data_.checkerName = dataNode["CheckerName"].asString();
+	if(!dataNode["RuleName"].isNull())
+		data_.ruleName = dataNode["RuleName"].asString();
+	if(!dataNode["MethodName"].isNull())
+		data_.methodName = dataNode["MethodName"].asString();
+	if(!dataNode["EntityId"].isNull())
+		data_.entityId = std::stol(dataNode["EntityId"].asString());
+	if(!dataNode["WhereCondition"].isNull())
+		data_.whereCondition = dataNode["WhereCondition"].asString();
 	if(!dataNode["Operator"].isNull())
 		data_._operator = dataNode["Operator"].asString();
 	if(!dataNode["ExpectValue"].isNull())
 		data_.expectValue = dataNode["ExpectValue"].asString();
 	if(!dataNode["Trend"].isNull())
 		data_.trend = dataNode["Trend"].asString();
-	if(!dataNode["CheckerName"].isNull())
-		data_.checkerName = dataNode["CheckerName"].asString();
-	if(!dataNode["Checker"].isNull())
-		data_.checker = std::stoi(dataNode["Checker"].asString());
-	if(!dataNode["FixCheck"].isNull())
-		data_.fixCheck = dataNode["FixCheck"].asString() == "true";
-	if(!dataNode["OnDutyAccountName"].isNull())
-		data_.onDutyAccountName = dataNode["OnDutyAccountName"].asString();
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
+	if(!dataNode["TemplateId"].isNull())
+		data_.templateId = std::stoi(dataNode["TemplateId"].asString());
+	if(!dataNode["Id"].isNull())
+		data_.id = std::stol(dataNode["Id"].asString());
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 

dataworks-public/src/model/ListDagsRequest.cc

@@ -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/dataworks-public/model/ListDagsRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::ListDagsRequest;
+
+ListDagsRequest::ListDagsRequest() :
+	RpcServiceRequest("dataworks-public", "2020-05-18", "ListDags")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListDagsRequest::~ListDagsRequest()
+{}
+
+std::string ListDagsRequest::getProjectEnv()const
+{
+	return projectEnv_;
+}
+
+void ListDagsRequest::setProjectEnv(const std::string& projectEnv)
+{
+	projectEnv_ = projectEnv;
+	setBodyParameter("ProjectEnv", projectEnv);
+}
+
+long ListDagsRequest::getOpSeq()const
+{
+	return opSeq_;
+}
+
+void ListDagsRequest::setOpSeq(long opSeq)
+{
+	opSeq_ = opSeq;
+	setBodyParameter("OpSeq", std::to_string(opSeq));
+}
+

dataworks-public/src/model/ListDagsResult.cc

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dataworks-public/model/ListDagsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dataworks_public;
+using namespace AlibabaCloud::Dataworks_public::Model;
+
+ListDagsResult::ListDagsResult() :
+	ServiceResult()
+{}
+
+ListDagsResult::ListDagsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListDagsResult::~ListDagsResult()
+{}
+
+void ListDagsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto allDagsNode = dataNode["Dags"]["Dag"];
+	for (auto dataNodeDagsDag : allDagsNode)
+	{
+		Data::Dag dagObject;
+		if(!dataNodeDagsDag["Type"].isNull())
+			dagObject.type = dataNodeDagsDag["Type"].asString();
+		if(!dataNodeDagsDag["Status"].isNull())
+			dagObject.status = dataNodeDagsDag["Status"].asString();
+		if(!dataNodeDagsDag["FinishTime"].isNull())
+			dagObject.finishTime = std::stol(dataNodeDagsDag["FinishTime"].asString());
+		if(!dataNodeDagsDag["CreateTime"].isNull())
+			dagObject.createTime = std::stol(dataNodeDagsDag["CreateTime"].asString());
+		if(!dataNodeDagsDag["ProjectId"].isNull())
+			dagObject.projectId = std::stol(dataNodeDagsDag["ProjectId"].asString());
+		if(!dataNodeDagsDag["DagId"].isNull())
+			dagObject.dagId = std::stol(dataNodeDagsDag["DagId"].asString());
+		if(!dataNodeDagsDag["Gmtdate"].isNull())
+			dagObject.gmtdate = std::stol(dataNodeDagsDag["Gmtdate"].asString());
+		if(!dataNodeDagsDag["StartTime"].isNull())
+			dagObject.startTime = std::stol(dataNodeDagsDag["StartTime"].asString());
+		if(!dataNodeDagsDag["CreateUser"].isNull())
+			dagObject.createUser = dataNodeDagsDag["CreateUser"].asString();
+		if(!dataNodeDagsDag["Bizdate"].isNull())
+			dagObject.bizdate = std::stol(dataNodeDagsDag["Bizdate"].asString());
+		if(!dataNodeDagsDag["Name"].isNull())
+			dagObject.name = dataNodeDagsDag["Name"].asString();
+		if(!dataNodeDagsDag["ModifyTime"].isNull())
+			dagObject.modifyTime = std::stol(dataNodeDagsDag["ModifyTime"].asString());
+		if(!dataNodeDagsDag["OpSeq"].isNull())
+			dagObject.opSeq = std::stol(dataNodeDagsDag["OpSeq"].asString());
+		data_.dags.push_back(dagObject);
+	}
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+int ListDagsResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+ListDagsResult::Data ListDagsResult::getData()const
+{
+	return data_;
+}
+
+std::string ListDagsResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListDagsResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool ListDagsResult::getSuccess()const
+{
+	return success_;
+}
+

dataworks-public/src/model/ListDeploymentsRequest.cc

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/dataworks-public/model/ListDeploymentsRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::ListDeploymentsRequest;
+
+ListDeploymentsRequest::ListDeploymentsRequest() :
+	RpcServiceRequest("dataworks-public", "2020-05-18", "ListDeployments")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListDeploymentsRequest::~ListDeploymentsRequest()
+{}
+
+std::string ListDeploymentsRequest::getCreator()const
+{
+	return creator_;
+}
+
+void ListDeploymentsRequest::setCreator(const std::string& creator)
+{
+	creator_ = creator;
+	setBodyParameter("Creator", creator);
+}
+
+long ListDeploymentsRequest::getEndCreateTime()const
+{
+	return endCreateTime_;
+}
+
+void ListDeploymentsRequest::setEndCreateTime(long endCreateTime)
+{
+	endCreateTime_ = endCreateTime;
+	setBodyParameter("EndCreateTime", std::to_string(endCreateTime));
+}
+
+std::string ListDeploymentsRequest::getProjectIdentifier()const
+{
+	return projectIdentifier_;
+}
+
+void ListDeploymentsRequest::setProjectIdentifier(const std::string& projectIdentifier)
+{
+	projectIdentifier_ = projectIdentifier;
+	setBodyParameter("ProjectIdentifier", projectIdentifier);
+}
+
+int ListDeploymentsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListDeploymentsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setBodyParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string ListDeploymentsRequest::getExecutor()const
+{
+	return executor_;
+}
+
+void ListDeploymentsRequest::setExecutor(const std::string& executor)
+{
+	executor_ = executor;
+	setBodyParameter("Executor", executor);
+}
+
+int ListDeploymentsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListDeploymentsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setBodyParameter("PageSize", std::to_string(pageSize));
+}
+
+long ListDeploymentsRequest::getEndExecuteTime()const
+{
+	return endExecuteTime_;
+}
+
+void ListDeploymentsRequest::setEndExecuteTime(long endExecuteTime)
+{
+	endExecuteTime_ = endExecuteTime;
+	setBodyParameter("EndExecuteTime", std::to_string(endExecuteTime));
+}
+
+std::string ListDeploymentsRequest::getKeyword()const
+{
+	return keyword_;
+}
+
+void ListDeploymentsRequest::setKeyword(const std::string& keyword)
+{
+	keyword_ = keyword;
+	setBodyParameter("Keyword", keyword);
+}
+
+long ListDeploymentsRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void ListDeploymentsRequest::setProjectId(long projectId)
+{
+	projectId_ = projectId;
+	setBodyParameter("ProjectId", std::to_string(projectId));
+}
+
+int ListDeploymentsRequest::getStatus()const
+{
+	return status_;
+}
+
+void ListDeploymentsRequest::setStatus(int status)
+{
+	status_ = status;
+	setBodyParameter("Status", std::to_string(status));
+}
+

dataworks-public/src/model/ListDeploymentsResult.cc

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dataworks-public/model/ListDeploymentsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dataworks_public;
+using namespace AlibabaCloud::Dataworks_public::Model;
+
+ListDeploymentsResult::ListDeploymentsResult() :
+	ServiceResult()
+{}
+
+ListDeploymentsResult::ListDeploymentsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListDeploymentsResult::~ListDeploymentsResult()
+{}
+
+void ListDeploymentsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["PageNumber"].isNull())
+		data_.pageNumber = std::stol(dataNode["PageNumber"].asString());
+	if(!dataNode["PageSize"].isNull())
+		data_.pageSize = std::stol(dataNode["PageSize"].asString());
+	if(!dataNode["TotalCount"].isNull())
+		data_.totalCount = std::stol(dataNode["TotalCount"].asString());
+	auto allDeploymentsNode = dataNode["Deployments"]["Deployment"];
+	for (auto dataNodeDeploymentsDeployment : allDeploymentsNode)
+	{
+		Data::Deployment deploymentObject;
+		if(!dataNodeDeploymentsDeployment["Status"].isNull())
+			deploymentObject.status = std::stoi(dataNodeDeploymentsDeployment["Status"].asString());
+		if(!dataNodeDeploymentsDeployment["ErrorMessage"].isNull())
+			deploymentObject.errorMessage = dataNodeDeploymentsDeployment["ErrorMessage"].asString();
+		if(!dataNodeDeploymentsDeployment["CreateTime"].isNull())
+			deploymentObject.createTime = std::stol(dataNodeDeploymentsDeployment["CreateTime"].asString());
+		if(!dataNodeDeploymentsDeployment["Executor"].isNull())
+			deploymentObject.executor = dataNodeDeploymentsDeployment["Executor"].asString();
+		if(!dataNodeDeploymentsDeployment["Creator"].isNull())
+			deploymentObject.creator = dataNodeDeploymentsDeployment["Creator"].asString();
+		if(!dataNodeDeploymentsDeployment["ExecuteTime"].isNull())
+			deploymentObject.executeTime = std::stol(dataNodeDeploymentsDeployment["ExecuteTime"].asString());
+		if(!dataNodeDeploymentsDeployment["Name"].isNull())
+			deploymentObject.name = dataNodeDeploymentsDeployment["Name"].asString();
+		if(!dataNodeDeploymentsDeployment["Id"].isNull())
+			deploymentObject.id = std::stol(dataNodeDeploymentsDeployment["Id"].asString());
+		data_.deployments.push_back(deploymentObject);
+	}
+
+}
+
+ListDeploymentsResult::Data ListDeploymentsResult::getData()const
+{
+	return data_;
+}
+

dataworks-public/src/model/ListInstancesResult.cc

@@ -50,70 +50,72 @@ void ListInstancesResult::parse(const std::string &payload)
 	for (auto dataNodeInstancesInstance : allInstancesNode)
 	{
 		Data::Instance instanceObject;
-		if(!dataNodeInstancesInstance["NodeId"].isNull())
-			instanceObject.nodeId = std::stol(dataNodeInstancesInstance["NodeId"].asString());
-		if(!dataNodeInstancesInstance["InstanceId"].isNull())
-			instanceObject.instanceId = std::stol(dataNodeInstancesInstance["InstanceId"].asString());
-		if(!dataNodeInstancesInstance["DagId"].isNull())
-			instanceObject.dagId = std::stol(dataNodeInstancesInstance["DagId"].asString());
-		if(!dataNodeInstancesInstance["DagType"].isNull())
-			instanceObject.dagType = dataNodeInstancesInstance["DagType"].asString();
 		if(!dataNodeInstancesInstance["Status"].isNull())
 			instanceObject.status = dataNodeInstancesInstance["Status"].asString();
-		if(!dataNodeInstancesInstance["Bizdate"].isNull())
-			instanceObject.bizdate = std::stol(dataNodeInstancesInstance["Bizdate"].asString());
 		if(!dataNodeInstancesInstance["CycTime"].isNull())
 			instanceObject.cycTime = std::stol(dataNodeInstancesInstance["CycTime"].asString());
-		if(!dataNodeInstancesInstance["CreateTime"].isNull())
-			instanceObject.createTime = std::stol(dataNodeInstancesInstance["CreateTime"].asString());
-		if(!dataNodeInstancesInstance["ModifyTime"].isNull())
-			instanceObject.modifyTime = std::stol(dataNodeInstancesInstance["ModifyTime"].asString());
-		if(!dataNodeInstancesInstance["NodeName"].isNull())
-			instanceObject.nodeName = dataNodeInstancesInstance["NodeName"].asString();
-		if(!dataNodeInstancesInstance["BeginWaitTimeTime"].isNull())
-			instanceObject.beginWaitTimeTime = std::stol(dataNodeInstancesInstance["BeginWaitTimeTime"].asString());
-		if(!dataNodeInstancesInstance["BeginWaitResTime"].isNull())
-			instanceObject.beginWaitResTime = std::stol(dataNodeInstancesInstance["BeginWaitResTime"].asString());
 		if(!dataNodeInstancesInstance["BeginRunningTime"].isNull())
 			instanceObject.beginRunningTime = std::stol(dataNodeInstancesInstance["BeginRunningTime"].asString());
-		if(!dataNodeInstancesInstance["ParamValues"].isNull())
-			instanceObject.paramValues = dataNodeInstancesInstance["ParamValues"].asString();
 		if(!dataNodeInstancesInstance["FinishTime"].isNull())
 			instanceObject.finishTime = std::stol(dataNodeInstancesInstance["FinishTime"].asString());
+		if(!dataNodeInstancesInstance["ErrorMessage"].isNull())
+			instanceObject.errorMessage = dataNodeInstancesInstance["ErrorMessage"].asString();
+		if(!dataNodeInstancesInstance["CreateTime"].isNull())
+			instanceObject.createTime = std::stol(dataNodeInstancesInstance["CreateTime"].asString());
+		if(!dataNodeInstancesInstance["DagId"].isNull())
+			instanceObject.dagId = std::stol(dataNodeInstancesInstance["DagId"].asString());
 		if(!dataNodeInstancesInstance["Priority"].isNull())
 			instanceObject.priority = std::stoi(dataNodeInstancesInstance["Priority"].asString());
+		if(!dataNodeInstancesInstance["TaskType"].isNull())
+			instanceObject.taskType = dataNodeInstancesInstance["TaskType"].asString();
+		if(!dataNodeInstancesInstance["ParamValues"].isNull())
+			instanceObject.paramValues = dataNodeInstancesInstance["ParamValues"].asString();
+		if(!dataNodeInstancesInstance["Connection"].isNull())
+			instanceObject.connection = dataNodeInstancesInstance["Connection"].asString();
 		if(!dataNodeInstancesInstance["BaselineId"].isNull())
 			instanceObject.baselineId = std::stol(dataNodeInstancesInstance["BaselineId"].asString());
+		if(!dataNodeInstancesInstance["DqcType"].isNull())
+			instanceObject.dqcType = std::stoi(dataNodeInstancesInstance["DqcType"].asString());
+		if(!dataNodeInstancesInstance["DagType"].isNull())
+			instanceObject.dagType = dataNodeInstancesInstance["DagType"].asString();
+		if(!dataNodeInstancesInstance["BusinessId"].isNull())
+			instanceObject.businessId = std::stol(dataNodeInstancesInstance["BusinessId"].asString());
+		if(!dataNodeInstancesInstance["TaskRerunTime"].isNull())
+			instanceObject.taskRerunTime = std::stoi(dataNodeInstancesInstance["TaskRerunTime"].asString());
+		if(!dataNodeInstancesInstance["ModifyTime"].isNull())
+			instanceObject.modifyTime = std::stol(dataNodeInstancesInstance["ModifyTime"].asString());
 		if(!dataNodeInstancesInstance["Repeatability"].isNull())
 			instanceObject.repeatability = dataNodeInstancesInstance["Repeatability"].asString() == "true";
 		if(!dataNodeInstancesInstance["RepeatInterval"].isNull())
 			instanceObject.repeatInterval = std::stol(dataNodeInstancesInstance["RepeatInterval"].asString());
-		if(!dataNodeInstancesInstance["Connection"].isNull())
-			instanceObject.connection = dataNodeInstancesInstance["Connection"].asString();
-		if(!dataNodeInstancesInstance["DqcType"].isNull())
-			instanceObject.dqcType = std::stoi(dataNodeInstancesInstance["DqcType"].asString());
-		if(!dataNodeInstancesInstance["DqcDescription"].isNull())
-			instanceObject.dqcDescription = dataNodeInstancesInstance["DqcDescription"].asString();
-		if(!dataNodeInstancesInstance["ErrorMessage"].isNull())
-			instanceObject.errorMessage = dataNodeInstancesInstance["ErrorMessage"].asString();
+		if(!dataNodeInstancesInstance["InstanceId"].isNull())
+			instanceObject.instanceId = std::stol(dataNodeInstancesInstance["InstanceId"].asString());
+		if(!dataNodeInstancesInstance["BeginWaitResTime"].isNull())
+			instanceObject.beginWaitResTime = std::stol(dataNodeInstancesInstance["BeginWaitResTime"].asString());
 		if(!dataNodeInstancesInstance["RelatedFlowId"].isNull())
 			instanceObject.relatedFlowId = std::stol(dataNodeInstancesInstance["RelatedFlowId"].asString());
-		if(!dataNodeInstancesInstance["TaskType"].isNull())
-			instanceObject.taskType = dataNodeInstancesInstance["TaskType"].asString();
-		if(!dataNodeInstancesInstance["TaskRerunTime"].isNull())
-			instanceObject.taskRerunTime = std::stoi(dataNodeInstancesInstance["TaskRerunTime"].asString());
-		if(!dataNodeInstancesInstance["BusinessId"].isNull())
-			instanceObject.businessId = std::stol(dataNodeInstancesInstance["BusinessId"].asString());
+		if(!dataNodeInstancesInstance["Bizdate"].isNull())
+			instanceObject.bizdate = std::stol(dataNodeInstancesInstance["Bizdate"].asString());
+		if(!dataNodeInstancesInstance["NodeName"].isNull())
+			instanceObject.nodeName = dataNodeInstancesInstance["NodeName"].asString();
+		if(!dataNodeInstancesInstance["BeginWaitTimeTime"].isNull())
+			instanceObject.beginWaitTimeTime = std::stol(dataNodeInstancesInstance["BeginWaitTimeTime"].asString());
+		if(!dataNodeInstancesInstance["DqcDescription"].isNull())
+			instanceObject.dqcDescription = dataNodeInstancesInstance["DqcDescription"].asString();
+		if(!dataNodeInstancesInstance["NodeId"].isNull())
+			instanceObject.nodeId = std::stol(dataNodeInstancesInstance["NodeId"].asString());
+		if(!dataNodeInstancesInstance["CreateUser"].isNull())
+			instanceObject.createUser = dataNodeInstancesInstance["CreateUser"].asString();
 		data_.instances.push_back(instanceObject);
 	}
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
 	if(!value["ErrorMessage"].isNull())
 		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 

dataworks-public/src/model/ListManualDagInstancesResult.cc

@@ -43,38 +43,40 @@ void ListManualDagInstancesResult::parse(const std::string &payload)
 	for (auto valueInstancesInstancesItem : allInstancesNode)
 	{
 		InstancesItem instancesObject;
-		if(!valueInstancesInstancesItem["NodeId"].isNull())
-			instancesObject.nodeId = std::stol(valueInstancesInstancesItem["NodeId"].asString());
-		if(!valueInstancesInstancesItem["InstanceId"].isNull())
-			instancesObject.instanceId = std::stol(valueInstancesInstancesItem["InstanceId"].asString());
-		if(!valueInstancesInstancesItem["DagId"].isNull())
-			instancesObject.dagId = std::stol(valueInstancesInstancesItem["DagId"].asString());
-		if(!valueInstancesInstancesItem["DagType"].isNull())
-			instancesObject.dagType = valueInstancesInstancesItem["DagType"].asString();
 		if(!valueInstancesInstancesItem["Status"].isNull())
 			instancesObject.status = valueInstancesInstancesItem["Status"].asString();
+		if(!valueInstancesInstancesItem["BeginRunningTime"].isNull())
+			instancesObject.beginRunningTime = std::stol(valueInstancesInstancesItem["BeginRunningTime"].asString());
 		if(!valueInstancesInstancesItem["BizDate"].isNull())
 			instancesObject.bizDate = std::stol(valueInstancesInstancesItem["BizDate"].asString());
 		if(!valueInstancesInstancesItem["CycTime"].isNull())
 			instancesObject.cycTime = std::stol(valueInstancesInstancesItem["CycTime"].asString());
+		if(!valueInstancesInstancesItem["FinishTime"].isNull())
+			instancesObject.finishTime = std::stol(valueInstancesInstancesItem["FinishTime"].asString());
 		if(!valueInstancesInstancesItem["CreateTime"].isNull())
 			instancesObject.createTime = std::stol(valueInstancesInstancesItem["CreateTime"].asString());
-		if(!valueInstancesInstancesItem["ModifyTime"].isNull())
-			instancesObject.modifyTime = std::stol(valueInstancesInstancesItem["ModifyTime"].asString());
+		if(!valueInstancesInstancesItem["DagId"].isNull())
+			instancesObject.dagId = std::stol(valueInstancesInstancesItem["DagId"].asString());
+		if(!valueInstancesInstancesItem["InstanceId"].isNull())
+			instancesObject.instanceId = std::stol(valueInstancesInstancesItem["InstanceId"].asString());
+		if(!valueInstancesInstancesItem["BeginWaitResTime"].isNull())
+			instancesObject.beginWaitResTime = std::stol(valueInstancesInstancesItem["BeginWaitResTime"].asString());
+		if(!valueInstancesInstancesItem["TaskType"].isNull())
+			instancesObject.taskType = valueInstancesInstancesItem["TaskType"].asString();
+		if(!valueInstancesInstancesItem["ParamValues"].isNull())
+			instancesObject.paramValues = valueInstancesInstancesItem["ParamValues"].asString();
+		if(!valueInstancesInstancesItem["DagType"].isNull())
+			instancesObject.dagType = valueInstancesInstancesItem["DagType"].asString();
 		if(!valueInstancesInstancesItem["NodeName"].isNull())
 			instancesObject.nodeName = valueInstancesInstancesItem["NodeName"].asString();
 		if(!valueInstancesInstancesItem["BeginWaitTimeTime"].isNull())
 			instancesObject.beginWaitTimeTime = std::stol(valueInstancesInstancesItem["BeginWaitTimeTime"].asString());
-		if(!valueInstancesInstancesItem["BeginWaitResTime"].isNull())
-			instancesObject.beginWaitResTime = std::stol(valueInstancesInstancesItem["BeginWaitResTime"].asString());
-		if(!valueInstancesInstancesItem["BeginRunningTime"].isNull())
-			instancesObject.beginRunningTime = std::stol(valueInstancesInstancesItem["BeginRunningTime"].asString());
-		if(!valueInstancesInstancesItem["ParamValues"].isNull())
-			instancesObject.paramValues = valueInstancesInstancesItem["ParamValues"].asString();
-		if(!valueInstancesInstancesItem["FinishTime"].isNull())
-			instancesObject.finishTime = std::stol(valueInstancesInstancesItem["FinishTime"].asString());
-		if(!valueInstancesInstancesItem["TaskType"].isNull())
-			instancesObject.taskType = valueInstancesInstancesItem["TaskType"].asString();
+		if(!valueInstancesInstancesItem["NodeId"].isNull())
+			instancesObject.nodeId = std::stol(valueInstancesInstancesItem["NodeId"].asString());
+		if(!valueInstancesInstancesItem["ModifyTime"].isNull())
+			instancesObject.modifyTime = std::stol(valueInstancesInstancesItem["ModifyTime"].asString());
+		if(!valueInstancesInstancesItem["CreateUser"].isNull())
+			instancesObject.createUser = valueInstancesInstancesItem["CreateUser"].asString();
 		instances_.push_back(instancesObject);
 	}
 

dataworks-public/src/model/ListQualityResultsByEntityResult.cc

@@ -40,118 +40,118 @@ void ListQualityResultsByEntityResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["TotalCount"].isNull())
-		data_.totalCount = std::stol(dataNode["TotalCount"].asString());
 	if(!dataNode["PageNumber"].isNull())
 		data_.pageNumber = std::stoi(dataNode["PageNumber"].asString());
 	if(!dataNode["PageSize"].isNull())
 		data_.pageSize = std::stoi(dataNode["PageSize"].asString());
+	if(!dataNode["TotalCount"].isNull())
+		data_.totalCount = std::stol(dataNode["TotalCount"].asString());
 	auto allRuleChecksNode = dataNode["RuleChecks"]["RuleChecksItem"];
 	for (auto dataNodeRuleChecksRuleChecksItem : allRuleChecksNode)
 	{
 		Data::RuleChecksItem ruleChecksItemObject;
-		if(!dataNodeRuleChecksRuleChecksItem["Id"].isNull())
-			ruleChecksItemObject.id = std::stoi(dataNodeRuleChecksRuleChecksItem["Id"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["TaskId"].isNull())
-			ruleChecksItemObject.taskId = dataNodeRuleChecksRuleChecksItem["TaskId"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["EntityId"].isNull())
-			ruleChecksItemObject.entityId = std::stoi(dataNodeRuleChecksRuleChecksItem["EntityId"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["RuleId"].isNull())
-			ruleChecksItemObject.ruleId = std::stoi(dataNodeRuleChecksRuleChecksItem["RuleId"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["Property"].isNull())
-			ruleChecksItemObject.property = dataNodeRuleChecksRuleChecksItem["Property"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["BizDate"].isNull())
-			ruleChecksItemObject.bizDate = std::stol(dataNodeRuleChecksRuleChecksItem["BizDate"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["DateType"].isNull())
-			ruleChecksItemObject.dateType = dataNodeRuleChecksRuleChecksItem["DateType"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["ActualExpression"].isNull())
-			ruleChecksItemObject.actualExpression = dataNodeRuleChecksRuleChecksItem["ActualExpression"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["MatchExpression"].isNull())
-			ruleChecksItemObject.matchExpression = dataNodeRuleChecksRuleChecksItem["MatchExpression"].asString();
 		if(!dataNodeRuleChecksRuleChecksItem["BlockType"].isNull())
 			ruleChecksItemObject.blockType = std::stoi(dataNodeRuleChecksRuleChecksItem["BlockType"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["CheckResult"].isNull())
-			ruleChecksItemObject.checkResult = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResult"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].isNull())
-			ruleChecksItemObject.checkResultStatus = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["MethodName"].isNull())
-			ruleChecksItemObject.methodName = dataNodeRuleChecksRuleChecksItem["MethodName"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["Comment"].isNull())
-			ruleChecksItemObject.comment = dataNodeRuleChecksRuleChecksItem["Comment"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["WhereCondition"].isNull())
-			ruleChecksItemObject.whereCondition = dataNodeRuleChecksRuleChecksItem["WhereCondition"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["BeginTime"].isNull())
-			ruleChecksItemObject.beginTime = std::stol(dataNodeRuleChecksRuleChecksItem["BeginTime"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["EndTime"].isNull())
-			ruleChecksItemObject.endTime = std::stol(dataNodeRuleChecksRuleChecksItem["EndTime"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["TimeCost"].isNull())
-			ruleChecksItemObject.timeCost = dataNodeRuleChecksRuleChecksItem["TimeCost"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["ExternalType"].isNull())
-			ruleChecksItemObject.externalType = dataNodeRuleChecksRuleChecksItem["ExternalType"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["ExternalId"].isNull())
-			ruleChecksItemObject.externalId = dataNodeRuleChecksRuleChecksItem["ExternalId"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].isNull())
-			ruleChecksItemObject.discreteCheck = dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].asString() == "true";
-		if(!dataNodeRuleChecksRuleChecksItem["FixedCheck"].isNull())
-			ruleChecksItemObject.fixedCheck = dataNodeRuleChecksRuleChecksItem["FixedCheck"].asString() == "true";
-		if(!dataNodeRuleChecksRuleChecksItem["Trend"].isNull())
-			ruleChecksItemObject.trend = dataNodeRuleChecksRuleChecksItem["Trend"].asString();
 		if(!dataNodeRuleChecksRuleChecksItem["WarningThreshold"].isNull())
 			ruleChecksItemObject.warningThreshold = std::stof(dataNodeRuleChecksRuleChecksItem["WarningThreshold"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].isNull())
-			ruleChecksItemObject.criticalThreshold = std::stof(dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["ExpectValue"].isNull())
-			ruleChecksItemObject.expectValue = std::stof(dataNodeRuleChecksRuleChecksItem["ExpectValue"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["Op"].isNull())
-			ruleChecksItemObject.op = dataNodeRuleChecksRuleChecksItem["Op"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["ProjectName"].isNull())
-			ruleChecksItemObject.projectName = dataNodeRuleChecksRuleChecksItem["ProjectName"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["Property"].isNull())
+			ruleChecksItemObject.property = dataNodeRuleChecksRuleChecksItem["Property"].asString();
 		if(!dataNodeRuleChecksRuleChecksItem["TableName"].isNull())
 			ruleChecksItemObject.tableName = dataNodeRuleChecksRuleChecksItem["TableName"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["TemplateId"].isNull())
-			ruleChecksItemObject.templateId = std::stoi(dataNodeRuleChecksRuleChecksItem["TemplateId"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["Comment"].isNull())
+			ruleChecksItemObject.comment = dataNodeRuleChecksRuleChecksItem["Comment"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].isNull())
+			ruleChecksItemObject.checkResultStatus = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].asString());
 		if(!dataNodeRuleChecksRuleChecksItem["TemplateName"].isNull())
 			ruleChecksItemObject.templateName = dataNodeRuleChecksRuleChecksItem["TemplateName"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["ResultString"].isNull())
-			ruleChecksItemObject.resultString = dataNodeRuleChecksRuleChecksItem["ResultString"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["CheckerId"].isNull())
-			ruleChecksItemObject.checkerId = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerId"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["CheckerType"].isNull())
-			ruleChecksItemObject.checkerType = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerType"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["RuleName"].isNull())
-			ruleChecksItemObject.ruleName = dataNodeRuleChecksRuleChecksItem["RuleName"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["IsPrediction"].isNull())
-			ruleChecksItemObject.isPrediction = dataNodeRuleChecksRuleChecksItem["IsPrediction"].asString() == "true";
-		if(!dataNodeRuleChecksRuleChecksItem["UpperValue"].isNull())
-			ruleChecksItemObject.upperValue = std::stof(dataNodeRuleChecksRuleChecksItem["UpperValue"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["LowerValue"].isNull())
-			ruleChecksItemObject.lowerValue = std::stof(dataNodeRuleChecksRuleChecksItem["LowerValue"].asString());
 		if(!dataNodeRuleChecksRuleChecksItem["CheckerName"].isNull())
 			ruleChecksItemObject.checkerName = dataNodeRuleChecksRuleChecksItem["CheckerName"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["RuleId"].isNull())
+			ruleChecksItemObject.ruleId = std::stoi(dataNodeRuleChecksRuleChecksItem["RuleId"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["FixedCheck"].isNull())
+			ruleChecksItemObject.fixedCheck = dataNodeRuleChecksRuleChecksItem["FixedCheck"].asString() == "true";
+		if(!dataNodeRuleChecksRuleChecksItem["Op"].isNull())
+			ruleChecksItemObject.op = dataNodeRuleChecksRuleChecksItem["Op"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["UpperValue"].isNull())
+			ruleChecksItemObject.upperValue = std::stof(dataNodeRuleChecksRuleChecksItem["UpperValue"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["ActualExpression"].isNull())
+			ruleChecksItemObject.actualExpression = dataNodeRuleChecksRuleChecksItem["ActualExpression"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["ExternalId"].isNull())
+			ruleChecksItemObject.externalId = dataNodeRuleChecksRuleChecksItem["ExternalId"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["TimeCost"].isNull())
+			ruleChecksItemObject.timeCost = dataNodeRuleChecksRuleChecksItem["TimeCost"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["Trend"].isNull())
+			ruleChecksItemObject.trend = dataNodeRuleChecksRuleChecksItem["Trend"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["ExternalType"].isNull())
+			ruleChecksItemObject.externalType = dataNodeRuleChecksRuleChecksItem["ExternalType"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["BizDate"].isNull())
+			ruleChecksItemObject.bizDate = std::stol(dataNodeRuleChecksRuleChecksItem["BizDate"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["CheckResult"].isNull())
+			ruleChecksItemObject.checkResult = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResult"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["ResultString"].isNull())
+			ruleChecksItemObject.resultString = dataNodeRuleChecksRuleChecksItem["ResultString"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["MatchExpression"].isNull())
+			ruleChecksItemObject.matchExpression = dataNodeRuleChecksRuleChecksItem["MatchExpression"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["CheckerType"].isNull())
+			ruleChecksItemObject.checkerType = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerType"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["ProjectName"].isNull())
+			ruleChecksItemObject.projectName = dataNodeRuleChecksRuleChecksItem["ProjectName"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["BeginTime"].isNull())
+			ruleChecksItemObject.beginTime = std::stol(dataNodeRuleChecksRuleChecksItem["BeginTime"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["DateType"].isNull())
+			ruleChecksItemObject.dateType = dataNodeRuleChecksRuleChecksItem["DateType"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].isNull())
+			ruleChecksItemObject.criticalThreshold = std::stof(dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["IsPrediction"].isNull())
+			ruleChecksItemObject.isPrediction = dataNodeRuleChecksRuleChecksItem["IsPrediction"].asString() == "true";
+		if(!dataNodeRuleChecksRuleChecksItem["RuleName"].isNull())
+			ruleChecksItemObject.ruleName = dataNodeRuleChecksRuleChecksItem["RuleName"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["CheckerId"].isNull())
+			ruleChecksItemObject.checkerId = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerId"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].isNull())
+			ruleChecksItemObject.discreteCheck = dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].asString() == "true";
+		if(!dataNodeRuleChecksRuleChecksItem["EndTime"].isNull())
+			ruleChecksItemObject.endTime = std::stol(dataNodeRuleChecksRuleChecksItem["EndTime"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["MethodName"].isNull())
+			ruleChecksItemObject.methodName = dataNodeRuleChecksRuleChecksItem["MethodName"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["LowerValue"].isNull())
+			ruleChecksItemObject.lowerValue = std::stof(dataNodeRuleChecksRuleChecksItem["LowerValue"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["EntityId"].isNull())
+			ruleChecksItemObject.entityId = std::stoi(dataNodeRuleChecksRuleChecksItem["EntityId"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["WhereCondition"].isNull())
+			ruleChecksItemObject.whereCondition = dataNodeRuleChecksRuleChecksItem["WhereCondition"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["ExpectValue"].isNull())
+			ruleChecksItemObject.expectValue = std::stof(dataNodeRuleChecksRuleChecksItem["ExpectValue"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["TemplateId"].isNull())
+			ruleChecksItemObject.templateId = std::stoi(dataNodeRuleChecksRuleChecksItem["TemplateId"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["TaskId"].isNull())
+			ruleChecksItemObject.taskId = dataNodeRuleChecksRuleChecksItem["TaskId"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["Id"].isNull())
+			ruleChecksItemObject.id = std::stoi(dataNodeRuleChecksRuleChecksItem["Id"].asString());
 		auto allReferenceValueNode = dataNodeRuleChecksRuleChecksItem["ReferenceValue"]["ReferenceValueItem"];
 		for (auto dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem : allReferenceValueNode)
 		{
 			Data::RuleChecksItem::ReferenceValueItem referenceValueObject;
-			if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].isNull())
-				referenceValueObject.bizDate = dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].asString();
 			if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].isNull())
 				referenceValueObject.discreteProperty = dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].asString();
 			if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].isNull())
 				referenceValueObject.value = std::stof(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].asString());
-			if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].isNull())
-				referenceValueObject.threshold = std::stof(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].asString());
+			if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].isNull())
+				referenceValueObject.bizDate = dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].asString();
 			if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].isNull())
 				referenceValueObject.singleCheckResult = std::stoi(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].asString());
+			if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].isNull())
+				referenceValueObject.threshold = std::stof(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].asString());
 			ruleChecksItemObject.referenceValue.push_back(referenceValueObject);
 		}
 		auto allSampleValueNode = dataNodeRuleChecksRuleChecksItem["SampleValue"]["SampleValueItem"];
 		for (auto dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem : allSampleValueNode)
 		{
 			Data::RuleChecksItem::SampleValueItem sampleValueObject;
-			if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].isNull())
-				sampleValueObject.bizDate = dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].asString();
 			if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].isNull())
 				sampleValueObject.discreteProperty = dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].asString();
+			if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].isNull())
+				sampleValueObject.bizDate = dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].asString();
 			if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].isNull())
 				sampleValueObject.value = std::stof(dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].asString());
 			ruleChecksItemObject.sampleValue.push_back(sampleValueObject);
@@ -162,10 +162,10 @@ void ListQualityResultsByEntityResult::parse(const std::string &payload)
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
 	if(!value["ErrorMessage"].isNull())
 		errorMessage_ = value["ErrorMessage"].asString();
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
 	if(!value["Success"].isNull())
 		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
 
 }
 

dataworks-public/src/model/ListQualityResultsByRuleResult.cc

@@ -40,132 +40,132 @@ void ListQualityResultsByRuleResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["TotalCount"].isNull())
-		data_.totalCount = std::stol(dataNode["TotalCount"].asString());
 	if(!dataNode["PageNumber"].isNull())
 		data_.pageNumber = std::stoi(dataNode["PageNumber"].asString());
 	if(!dataNode["PageSize"].isNull())
 		data_.pageSize = std::stoi(dataNode["PageSize"].asString());
+	if(!dataNode["TotalCount"].isNull())
+		data_.totalCount = std::stol(dataNode["TotalCount"].asString());
 	auto allRuleChecksNode = dataNode["RuleChecks"]["RuleChecksItem"];
 	for (auto dataNodeRuleChecksRuleChecksItem : allRuleChecksNode)
 	{
 		Data::RuleChecksItem ruleChecksItemObject;
-		if(!dataNodeRuleChecksRuleChecksItem["Id"].isNull())
-			ruleChecksItemObject.id = std::stoi(dataNodeRuleChecksRuleChecksItem["Id"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["TaskId"].isNull())
-			ruleChecksItemObject.taskId = dataNodeRuleChecksRuleChecksItem["TaskId"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["EntityId"].isNull())
-			ruleChecksItemObject.entityId = std::stoi(dataNodeRuleChecksRuleChecksItem["EntityId"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["RuleId"].isNull())
-			ruleChecksItemObject.ruleId = std::stoi(dataNodeRuleChecksRuleChecksItem["RuleId"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["Property"].isNull())
-			ruleChecksItemObject.property = dataNodeRuleChecksRuleChecksItem["Property"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["BizDate"].isNull())
-			ruleChecksItemObject.bizDate = std::stol(dataNodeRuleChecksRuleChecksItem["BizDate"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["DateType"].isNull())
-			ruleChecksItemObject.dateType = dataNodeRuleChecksRuleChecksItem["DateType"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["ActualExpression"].isNull())
-			ruleChecksItemObject.actualExpression = dataNodeRuleChecksRuleChecksItem["ActualExpression"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["MatchExpression"].isNull())
-			ruleChecksItemObject.matchExpression = dataNodeRuleChecksRuleChecksItem["MatchExpression"].asString();
 		if(!dataNodeRuleChecksRuleChecksItem["BlockType"].isNull())
 			ruleChecksItemObject.blockType = std::stoi(dataNodeRuleChecksRuleChecksItem["BlockType"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["CheckResult"].isNull())
-			ruleChecksItemObject.checkResult = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResult"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].isNull())
-			ruleChecksItemObject.checkResultStatus = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["MethodName"].isNull())
-			ruleChecksItemObject.methodName = dataNodeRuleChecksRuleChecksItem["MethodName"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["Comment"].isNull())
-			ruleChecksItemObject.comment = dataNodeRuleChecksRuleChecksItem["Comment"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["WhereCondition"].isNull())
-			ruleChecksItemObject.whereCondition = dataNodeRuleChecksRuleChecksItem["WhereCondition"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["BeginTime"].isNull())
-			ruleChecksItemObject.beginTime = std::stol(dataNodeRuleChecksRuleChecksItem["BeginTime"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["EndTime"].isNull())
-			ruleChecksItemObject.endTime = std::stol(dataNodeRuleChecksRuleChecksItem["EndTime"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["TimeCost"].isNull())
-			ruleChecksItemObject.timeCost = dataNodeRuleChecksRuleChecksItem["TimeCost"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["ExternalType"].isNull())
-			ruleChecksItemObject.externalType = dataNodeRuleChecksRuleChecksItem["ExternalType"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["ExternalId"].isNull())
-			ruleChecksItemObject.externalId = dataNodeRuleChecksRuleChecksItem["ExternalId"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].isNull())
-			ruleChecksItemObject.discreteCheck = dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].asString() == "true";
-		if(!dataNodeRuleChecksRuleChecksItem["FixedCheck"].isNull())
-			ruleChecksItemObject.fixedCheck = dataNodeRuleChecksRuleChecksItem["FixedCheck"].asString() == "true";
-		if(!dataNodeRuleChecksRuleChecksItem["Trend"].isNull())
-			ruleChecksItemObject.trend = dataNodeRuleChecksRuleChecksItem["Trend"].asString();
 		if(!dataNodeRuleChecksRuleChecksItem["WarningThreshold"].isNull())
 			ruleChecksItemObject.warningThreshold = std::stof(dataNodeRuleChecksRuleChecksItem["WarningThreshold"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].isNull())
-			ruleChecksItemObject.criticalThreshold = std::stof(dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["ExpectValue"].isNull())
-			ruleChecksItemObject.expectValue = std::stof(dataNodeRuleChecksRuleChecksItem["ExpectValue"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["Op"].isNull())
-			ruleChecksItemObject.op = dataNodeRuleChecksRuleChecksItem["Op"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["ProjectName"].isNull())
-			ruleChecksItemObject.projectName = dataNodeRuleChecksRuleChecksItem["ProjectName"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["Property"].isNull())
+			ruleChecksItemObject.property = dataNodeRuleChecksRuleChecksItem["Property"].asString();
 		if(!dataNodeRuleChecksRuleChecksItem["TableName"].isNull())
 			ruleChecksItemObject.tableName = dataNodeRuleChecksRuleChecksItem["TableName"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["TemplateId"].isNull())
-			ruleChecksItemObject.templateId = std::stoi(dataNodeRuleChecksRuleChecksItem["TemplateId"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["Comment"].isNull())
+			ruleChecksItemObject.comment = dataNodeRuleChecksRuleChecksItem["Comment"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].isNull())
+			ruleChecksItemObject.checkResultStatus = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].asString());
 		if(!dataNodeRuleChecksRuleChecksItem["TemplateName"].isNull())
 			ruleChecksItemObject.templateName = dataNodeRuleChecksRuleChecksItem["TemplateName"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["ResultString"].isNull())
-			ruleChecksItemObject.resultString = dataNodeRuleChecksRuleChecksItem["ResultString"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["CheckerId"].isNull())
-			ruleChecksItemObject.checkerId = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerId"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["CheckerType"].isNull())
-			ruleChecksItemObject.checkerType = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerType"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["RuleName"].isNull())
-			ruleChecksItemObject.ruleName = dataNodeRuleChecksRuleChecksItem["RuleName"].asString();
-		if(!dataNodeRuleChecksRuleChecksItem["IsPrediction"].isNull())
-			ruleChecksItemObject.isPrediction = dataNodeRuleChecksRuleChecksItem["IsPrediction"].asString() == "true";
-		if(!dataNodeRuleChecksRuleChecksItem["UpperValue"].isNull())
-			ruleChecksItemObject.upperValue = std::stof(dataNodeRuleChecksRuleChecksItem["UpperValue"].asString());
-		if(!dataNodeRuleChecksRuleChecksItem["LowerValue"].isNull())
-			ruleChecksItemObject.lowerValue = std::stof(dataNodeRuleChecksRuleChecksItem["LowerValue"].asString());
 		if(!dataNodeRuleChecksRuleChecksItem["CheckerName"].isNull())
 			ruleChecksItemObject.checkerName = dataNodeRuleChecksRuleChecksItem["CheckerName"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["RuleId"].isNull())
+			ruleChecksItemObject.ruleId = std::stoi(dataNodeRuleChecksRuleChecksItem["RuleId"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["FixedCheck"].isNull())
+			ruleChecksItemObject.fixedCheck = dataNodeRuleChecksRuleChecksItem["FixedCheck"].asString() == "true";
+		if(!dataNodeRuleChecksRuleChecksItem["Op"].isNull())
+			ruleChecksItemObject.op = dataNodeRuleChecksRuleChecksItem["Op"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["UpperValue"].isNull())
+			ruleChecksItemObject.upperValue = std::stof(dataNodeRuleChecksRuleChecksItem["UpperValue"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["ActualExpression"].isNull())
+			ruleChecksItemObject.actualExpression = dataNodeRuleChecksRuleChecksItem["ActualExpression"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["ExternalId"].isNull())
+			ruleChecksItemObject.externalId = dataNodeRuleChecksRuleChecksItem["ExternalId"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["TimeCost"].isNull())
+			ruleChecksItemObject.timeCost = dataNodeRuleChecksRuleChecksItem["TimeCost"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["Trend"].isNull())
+			ruleChecksItemObject.trend = dataNodeRuleChecksRuleChecksItem["Trend"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["ExternalType"].isNull())
+			ruleChecksItemObject.externalType = dataNodeRuleChecksRuleChecksItem["ExternalType"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["BizDate"].isNull())
+			ruleChecksItemObject.bizDate = std::stol(dataNodeRuleChecksRuleChecksItem["BizDate"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["CheckResult"].isNull())
+			ruleChecksItemObject.checkResult = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResult"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["ResultString"].isNull())
+			ruleChecksItemObject.resultString = dataNodeRuleChecksRuleChecksItem["ResultString"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["MatchExpression"].isNull())
+			ruleChecksItemObject.matchExpression = dataNodeRuleChecksRuleChecksItem["MatchExpression"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["CheckerType"].isNull())
+			ruleChecksItemObject.checkerType = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerType"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["ProjectName"].isNull())
+			ruleChecksItemObject.projectName = dataNodeRuleChecksRuleChecksItem["ProjectName"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["BeginTime"].isNull())
+			ruleChecksItemObject.beginTime = std::stol(dataNodeRuleChecksRuleChecksItem["BeginTime"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["DateType"].isNull())
+			ruleChecksItemObject.dateType = dataNodeRuleChecksRuleChecksItem["DateType"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].isNull())
+			ruleChecksItemObject.criticalThreshold = std::stof(dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["IsPrediction"].isNull())
+			ruleChecksItemObject.isPrediction = dataNodeRuleChecksRuleChecksItem["IsPrediction"].asString() == "true";
+		if(!dataNodeRuleChecksRuleChecksItem["RuleName"].isNull())
+			ruleChecksItemObject.ruleName = dataNodeRuleChecksRuleChecksItem["RuleName"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["CheckerId"].isNull())
+			ruleChecksItemObject.checkerId = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerId"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].isNull())
+			ruleChecksItemObject.discreteCheck = dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].asString() == "true";
+		if(!dataNodeRuleChecksRuleChecksItem["EndTime"].isNull())
+			ruleChecksItemObject.endTime = std::stol(dataNodeRuleChecksRuleChecksItem["EndTime"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["MethodName"].isNull())
+			ruleChecksItemObject.methodName = dataNodeRuleChecksRuleChecksItem["MethodName"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["LowerValue"].isNull())
+			ruleChecksItemObject.lowerValue = std::stof(dataNodeRuleChecksRuleChecksItem["LowerValue"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["EntityId"].isNull())
+			ruleChecksItemObject.entityId = std::stoi(dataNodeRuleChecksRuleChecksItem["EntityId"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["WhereCondition"].isNull())
+			ruleChecksItemObject.whereCondition = dataNodeRuleChecksRuleChecksItem["WhereCondition"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["ExpectValue"].isNull())
+			ruleChecksItemObject.expectValue = std::stof(dataNodeRuleChecksRuleChecksItem["ExpectValue"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["TemplateId"].isNull())
+			ruleChecksItemObject.templateId = std::stoi(dataNodeRuleChecksRuleChecksItem["TemplateId"].asString());
+		if(!dataNodeRuleChecksRuleChecksItem["TaskId"].isNull())
+			ruleChecksItemObject.taskId = dataNodeRuleChecksRuleChecksItem["TaskId"].asString();
+		if(!dataNodeRuleChecksRuleChecksItem["Id"].isNull())
+			ruleChecksItemObject.id = std::stoi(dataNodeRuleChecksRuleChecksItem["Id"].asString());
 		auto allReferenceValueNode = dataNodeRuleChecksRuleChecksItem["ReferenceValue"]["ReferenceValueItem"];
 		for (auto dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem : allReferenceValueNode)
 		{
 			Data::RuleChecksItem::ReferenceValueItem referenceValueObject;
-			if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].isNull())
-				referenceValueObject.bizDate = dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].asString();
 			if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].isNull())
 				referenceValueObject.discreteProperty = dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].asString();
 			if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].isNull())
 				referenceValueObject.value = std::stof(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].asString());
-			if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].isNull())
-				referenceValueObject.threshold = std::stof(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].asString());
+			if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].isNull())
+				referenceValueObject.bizDate = dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].asString();
 			if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].isNull())
 				referenceValueObject.singleCheckResult = std::stoi(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].asString());
+			if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].isNull())
+				referenceValueObject.threshold = std::stof(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].asString());
 			ruleChecksItemObject.referenceValue.push_back(referenceValueObject);
 		}
 		auto allSampleValueNode = dataNodeRuleChecksRuleChecksItem["SampleValue"]["SampleValueItem"];
 		for (auto dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem : allSampleValueNode)
 		{
 			Data::RuleChecksItem::SampleValueItem sampleValueObject;
-			if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].isNull())
-				sampleValueObject.bizDate = dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].asString();
 			if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].isNull())
 				sampleValueObject.discreteProperty = dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].asString();
+			if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].isNull())
+				sampleValueObject.bizDate = dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].asString();
 			if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].isNull())
 				sampleValueObject.value = std::stof(dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].asString());
 			ruleChecksItemObject.sampleValue.push_back(sampleValueObject);
 		}
 		data_.ruleChecks.push_back(ruleChecksItemObject);
 	}
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 

dataworks-public/src/model/ListQualityRulesResult.cc

@@ -40,76 +40,78 @@ void ListQualityRulesResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto dataNode = value["Data"];
-	if(!dataNode["TotalCount"].isNull())
-		data_.totalCount = std::stol(dataNode["TotalCount"].asString());
 	if(!dataNode["PageNumber"].isNull())
 		data_.pageNumber = std::stoi(dataNode["PageNumber"].asString());
 	if(!dataNode["PageSize"].isNull())
 		data_.pageSize = std::stoi(dataNode["PageSize"].asString());
+	if(!dataNode["TotalCount"].isNull())
+		data_.totalCount = std::stol(dataNode["TotalCount"].asString());
 	auto allRulesNode = dataNode["Rules"]["RulesItem"];
 	for (auto dataNodeRulesRulesItem : allRulesNode)
 	{
 		Data::RulesItem rulesItemObject;
-		if(!dataNodeRulesRulesItem["ProjectName"].isNull())
-			rulesItemObject.projectName = dataNodeRulesRulesItem["ProjectName"].asString();
-		if(!dataNodeRulesRulesItem["TableName"].isNull())
-			rulesItemObject.tableName = dataNodeRulesRulesItem["TableName"].asString();
-		if(!dataNodeRulesRulesItem["Id"].isNull())
-			rulesItemObject.id = std::stoi(dataNodeRulesRulesItem["Id"].asString());
-		if(!dataNodeRulesRulesItem["EntityId"].isNull())
-			rulesItemObject.entityId = std::stoi(dataNodeRulesRulesItem["EntityId"].asString());
-		if(!dataNodeRulesRulesItem["Property"].isNull())
-			rulesItemObject.property = dataNodeRulesRulesItem["Property"].asString();
-		if(!dataNodeRulesRulesItem["MethodId"].isNull())
-			rulesItemObject.methodId = std::stoi(dataNodeRulesRulesItem["MethodId"].asString());
-		if(!dataNodeRulesRulesItem["MethodName"].isNull())
-			rulesItemObject.methodName = dataNodeRulesRulesItem["MethodName"].asString();
-		if(!dataNodeRulesRulesItem["OnDuty"].isNull())
-			rulesItemObject.onDuty = dataNodeRulesRulesItem["OnDuty"].asString();
-		if(!dataNodeRulesRulesItem["RuleType"].isNull())
-			rulesItemObject.ruleType = std::stoi(dataNodeRulesRulesItem["RuleType"].asString());
 		if(!dataNodeRulesRulesItem["BlockType"].isNull())
 			rulesItemObject.blockType = std::stoi(dataNodeRulesRulesItem["BlockType"].asString());
-		if(!dataNodeRulesRulesItem["TemplateId"].isNull())
-			rulesItemObject.templateId = std::stoi(dataNodeRulesRulesItem["TemplateId"].asString());
-		if(!dataNodeRulesRulesItem["TemplateName"].isNull())
-			rulesItemObject.templateName = dataNodeRulesRulesItem["TemplateName"].asString();
-		if(!dataNodeRulesRulesItem["RuleCheckerRelationId"].isNull())
-			rulesItemObject.ruleCheckerRelationId = std::stoi(dataNodeRulesRulesItem["RuleCheckerRelationId"].asString());
-		if(!dataNodeRulesRulesItem["CheckerId"].isNull())
-			rulesItemObject.checkerId = std::stoi(dataNodeRulesRulesItem["CheckerId"].asString());
-		if(!dataNodeRulesRulesItem["FixCheck"].isNull())
-			rulesItemObject.fixCheck = dataNodeRulesRulesItem["FixCheck"].asString() == "true";
-		if(!dataNodeRulesRulesItem["Trend"].isNull())
-			rulesItemObject.trend = dataNodeRulesRulesItem["Trend"].asString();
-		if(!dataNodeRulesRulesItem["WarningThreshold"].isNull())
-			rulesItemObject.warningThreshold = dataNodeRulesRulesItem["WarningThreshold"].asString();
-		if(!dataNodeRulesRulesItem["CriticalThreshold"].isNull())
-			rulesItemObject.criticalThreshold = dataNodeRulesRulesItem["CriticalThreshold"].asString();
-		if(!dataNodeRulesRulesItem["HistoryWarningThreshold"].isNull())
-			rulesItemObject.historyWarningThreshold = dataNodeRulesRulesItem["HistoryWarningThreshold"].asString();
-		if(!dataNodeRulesRulesItem["HistoryCriticalThreshold"].isNull())
-			rulesItemObject.historyCriticalThreshold = dataNodeRulesRulesItem["HistoryCriticalThreshold"].asString();
-		if(!dataNodeRulesRulesItem["PropertyKey"].isNull())
-			rulesItemObject.propertyKey = dataNodeRulesRulesItem["PropertyKey"].asString();
-		if(!dataNodeRulesRulesItem["MatchExpression"].isNull())
-			rulesItemObject.matchExpression = dataNodeRulesRulesItem["MatchExpression"].asString();
-		if(!dataNodeRulesRulesItem["Comment"].isNull())
-			rulesItemObject.comment = dataNodeRulesRulesItem["Comment"].asString();
-		if(!dataNodeRulesRulesItem["ExpectValue"].isNull())
-			rulesItemObject.expectValue = dataNodeRulesRulesItem["ExpectValue"].asString();
 		if(!dataNodeRulesRulesItem["OnDutyAccountName"].isNull())
 			rulesItemObject.onDutyAccountName = dataNodeRulesRulesItem["OnDutyAccountName"].asString();
+		if(!dataNodeRulesRulesItem["Property"].isNull())
+			rulesItemObject.property = dataNodeRulesRulesItem["Property"].asString();
+		if(!dataNodeRulesRulesItem["WarningThreshold"].isNull())
+			rulesItemObject.warningThreshold = dataNodeRulesRulesItem["WarningThreshold"].asString();
+		if(!dataNodeRulesRulesItem["TableName"].isNull())
+			rulesItemObject.tableName = dataNodeRulesRulesItem["TableName"].asString();
+		if(!dataNodeRulesRulesItem["OnDuty"].isNull())
+			rulesItemObject.onDuty = dataNodeRulesRulesItem["OnDuty"].asString();
+		if(!dataNodeRulesRulesItem["Comment"].isNull())
+			rulesItemObject.comment = dataNodeRulesRulesItem["Comment"].asString();
+		if(!dataNodeRulesRulesItem["RuleCheckerRelationId"].isNull())
+			rulesItemObject.ruleCheckerRelationId = std::stoi(dataNodeRulesRulesItem["RuleCheckerRelationId"].asString());
+		if(!dataNodeRulesRulesItem["FixCheck"].isNull())
+			rulesItemObject.fixCheck = dataNodeRulesRulesItem["FixCheck"].asString() == "true";
+		if(!dataNodeRulesRulesItem["MethodId"].isNull())
+			rulesItemObject.methodId = std::stoi(dataNodeRulesRulesItem["MethodId"].asString());
+		if(!dataNodeRulesRulesItem["TemplateName"].isNull())
+			rulesItemObject.templateName = dataNodeRulesRulesItem["TemplateName"].asString();
+		if(!dataNodeRulesRulesItem["Trend"].isNull())
+			rulesItemObject.trend = dataNodeRulesRulesItem["Trend"].asString();
+		if(!dataNodeRulesRulesItem["HistoryWarningThreshold"].isNull())
+			rulesItemObject.historyWarningThreshold = dataNodeRulesRulesItem["HistoryWarningThreshold"].asString();
+		if(!dataNodeRulesRulesItem["RuleType"].isNull())
+			rulesItemObject.ruleType = std::stoi(dataNodeRulesRulesItem["RuleType"].asString());
+		if(!dataNodeRulesRulesItem["MatchExpression"].isNull())
+			rulesItemObject.matchExpression = dataNodeRulesRulesItem["MatchExpression"].asString();
+		if(!dataNodeRulesRulesItem["ProjectName"].isNull())
+			rulesItemObject.projectName = dataNodeRulesRulesItem["ProjectName"].asString();
+		if(!dataNodeRulesRulesItem["PropertyKey"].isNull())
+			rulesItemObject.propertyKey = dataNodeRulesRulesItem["PropertyKey"].asString();
+		if(!dataNodeRulesRulesItem["CriticalThreshold"].isNull())
+			rulesItemObject.criticalThreshold = dataNodeRulesRulesItem["CriticalThreshold"].asString();
+		if(!dataNodeRulesRulesItem["HistoryCriticalThreshold"].isNull())
+			rulesItemObject.historyCriticalThreshold = dataNodeRulesRulesItem["HistoryCriticalThreshold"].asString();
+		if(!dataNodeRulesRulesItem["MethodName"].isNull())
+			rulesItemObject.methodName = dataNodeRulesRulesItem["MethodName"].asString();
+		if(!dataNodeRulesRulesItem["CheckerId"].isNull())
+			rulesItemObject.checkerId = std::stoi(dataNodeRulesRulesItem["CheckerId"].asString());
+		if(!dataNodeRulesRulesItem["EntityId"].isNull())
+			rulesItemObject.entityId = std::stoi(dataNodeRulesRulesItem["EntityId"].asString());
+		if(!dataNodeRulesRulesItem["ExpectValue"].isNull())
+			rulesItemObject.expectValue = dataNodeRulesRulesItem["ExpectValue"].asString();
+		if(!dataNodeRulesRulesItem["TemplateId"].isNull())
+			rulesItemObject.templateId = std::stoi(dataNodeRulesRulesItem["TemplateId"].asString());
+		if(!dataNodeRulesRulesItem["Id"].isNull())
+			rulesItemObject.id = std::stoi(dataNodeRulesRulesItem["Id"].asString());
+		if(!dataNodeRulesRulesItem["RuleName"].isNull())
+			rulesItemObject.ruleName = dataNodeRulesRulesItem["RuleName"].asString();
 		data_.rules.push_back(rulesItemObject);
 	}
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
 
 }
 

dataworks-public/src/model/UpdateIDEEventResultRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dataworks-public/model/UpdateIDEEventResultRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::UpdateIDEEventResultRequest;
+
+UpdateIDEEventResultRequest::UpdateIDEEventResultRequest() :
+	RpcServiceRequest("dataworks-public", "2020-05-18", "UpdateIDEEventResult")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UpdateIDEEventResultRequest::~UpdateIDEEventResultRequest()
+{}
+
+std::string UpdateIDEEventResultRequest::getCheckResultTip()const
+{
+	return checkResultTip_;
+}
+
+void UpdateIDEEventResultRequest::setCheckResultTip(const std::string& checkResultTip)
+{
+	checkResultTip_ = checkResultTip;
+	setBodyParameter("CheckResultTip", checkResultTip);
+}
+
+std::string UpdateIDEEventResultRequest::getCheckResult()const
+{
+	return checkResult_;
+}
+
+void UpdateIDEEventResultRequest::setCheckResult(const std::string& checkResult)
+{
+	checkResult_ = checkResult;
+	setBodyParameter("CheckResult", checkResult);
+}
+
+std::string UpdateIDEEventResultRequest::getMessageId()const
+{
+	return messageId_;
+}
+
+void UpdateIDEEventResultRequest::setMessageId(const std::string& messageId)
+{
+	messageId_ = messageId;
+	setBodyParameter("MessageId", messageId);
+}
+
+std::string UpdateIDEEventResultRequest::getExtensionCode()const
+{
+	return extensionCode_;
+}
+
+void UpdateIDEEventResultRequest::setExtensionCode(const std::string& extensionCode)
+{
+	extensionCode_ = extensionCode;
+	setBodyParameter("ExtensionCode", extensionCode);
+}
+

dataworks-public/src/model/UpdateIDEEventResultResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/ecs/model/DeleteDiskReplicaPairResult.h>
+#include <alibabacloud/dataworks-public/model/UpdateIDEEventResultResult.h>
 #include <json/json.h>
 
-using namespace AlibabaCloud::Ecs;
-using namespace AlibabaCloud::Ecs::Model;
+using namespace AlibabaCloud::Dataworks_public;
+using namespace AlibabaCloud::Dataworks_public::Model;
 
-DeleteDiskReplicaPairResult::DeleteDiskReplicaPairResult() :
+UpdateIDEEventResultResult::UpdateIDEEventResultResult() :
 	ServiceResult()
 {}
 
-DeleteDiskReplicaPairResult::DeleteDiskReplicaPairResult(const std::string &payload) :
+UpdateIDEEventResultResult::UpdateIDEEventResultResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-DeleteDiskReplicaPairResult::~DeleteDiskReplicaPairResult()
+UpdateIDEEventResultResult::~UpdateIDEEventResultResult()
 {}
 
-void DeleteDiskReplicaPairResult::parse(const std::string &payload)
+void UpdateIDEEventResultResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;

dataworks-public/src/model/UpdateQualityFollowerResult.cc

@@ -39,16 +39,16 @@ void UpdateQualityFollowerResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
-	if(!value["Data"].isNull())
-		data_ = value["Data"].asString() == "true";
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString() == "true";
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 

dataworks-public/src/model/UpdateQualityRuleResult.cc

@@ -39,16 +39,16 @@ void UpdateQualityRuleResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["ErrorCode"].isNull())
-		errorCode_ = value["ErrorCode"].asString();
-	if(!value["Data"].isNull())
-		data_ = value["Data"].asString() == "true";
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
-	if(!value["ErrorMessage"].isNull())
-		errorMessage_ = value["ErrorMessage"].asString();
 	if(!value["HttpStatusCode"].isNull())
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString() == "true";
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 

ecs/CMakeLists.txt

@@ -99,8 +99,6 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/CreateDeploymentSetResult.h
 	include/alibabacloud/ecs/model/CreateDiskRequest.h
 	include/alibabacloud/ecs/model/CreateDiskResult.h
-	include/alibabacloud/ecs/model/CreateDiskReplicaPairRequest.h
-	include/alibabacloud/ecs/model/CreateDiskReplicaPairResult.h
 	include/alibabacloud/ecs/model/CreateElasticityAssuranceRequest.h
 	include/alibabacloud/ecs/model/CreateElasticityAssuranceResult.h
 	include/alibabacloud/ecs/model/CreateForwardEntryRequest.h
@@ -173,8 +171,6 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/DeleteDeploymentSetResult.h
 	include/alibabacloud/ecs/model/DeleteDiskRequest.h
 	include/alibabacloud/ecs/model/DeleteDiskResult.h
-	include/alibabacloud/ecs/model/DeleteDiskReplicaPairRequest.h
-	include/alibabacloud/ecs/model/DeleteDiskReplicaPairResult.h
 	include/alibabacloud/ecs/model/DeleteForwardEntryRequest.h
 	include/alibabacloud/ecs/model/DeleteForwardEntryResult.h
 	include/alibabacloud/ecs/model/DeleteHaVipRequest.h
@@ -277,8 +273,6 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/DescribeDeploymentSetsResult.h
 	include/alibabacloud/ecs/model/DescribeDiskMonitorDataRequest.h
 	include/alibabacloud/ecs/model/DescribeDiskMonitorDataResult.h
-	include/alibabacloud/ecs/model/DescribeDiskReplicaPairsRequest.h
-	include/alibabacloud/ecs/model/DescribeDiskReplicaPairsResult.h
 	include/alibabacloud/ecs/model/DescribeDisksRequest.h
 	include/alibabacloud/ecs/model/DescribeDisksResult.h
 	include/alibabacloud/ecs/model/DescribeDisksFullStatusRequest.h
@@ -665,8 +659,6 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/RunInstancesResult.h
 	include/alibabacloud/ecs/model/SendFileRequest.h
 	include/alibabacloud/ecs/model/SendFileResult.h
-	include/alibabacloud/ecs/model/StartDiskReplicaPairRequest.h
-	include/alibabacloud/ecs/model/StartDiskReplicaPairResult.h
 	include/alibabacloud/ecs/model/StartElasticityAssuranceRequest.h
 	include/alibabacloud/ecs/model/StartElasticityAssuranceResult.h
 	include/alibabacloud/ecs/model/StartImagePipelineExecutionRequest.h
@@ -677,8 +669,6 @@ set(ecs_public_header_model
 	include/alibabacloud/ecs/model/StartInstancesResult.h
 	include/alibabacloud/ecs/model/StartTerminalSessionRequest.h
 	include/alibabacloud/ecs/model/StartTerminalSessionResult.h
-	include/alibabacloud/ecs/model/StopDiskReplicaPairRequest.h
-	include/alibabacloud/ecs/model/StopDiskReplicaPairResult.h
 	include/alibabacloud/ecs/model/StopInstanceRequest.h
 	include/alibabacloud/ecs/model/StopInstanceResult.h
 	include/alibabacloud/ecs/model/StopInstancesRequest.h
@@ -782,8 +772,6 @@ set(ecs_src
 	src/model/CreateDeploymentSetResult.cc
 	src/model/CreateDiskRequest.cc
 	src/model/CreateDiskResult.cc
-	src/model/CreateDiskReplicaPairRequest.cc
-	src/model/CreateDiskReplicaPairResult.cc
 	src/model/CreateElasticityAssuranceRequest.cc
 	src/model/CreateElasticityAssuranceResult.cc
 	src/model/CreateForwardEntryRequest.cc
@@ -856,8 +844,6 @@ set(ecs_src
 	src/model/DeleteDeploymentSetResult.cc
 	src/model/DeleteDiskRequest.cc
 	src/model/DeleteDiskResult.cc
-	src/model/DeleteDiskReplicaPairRequest.cc
-	src/model/DeleteDiskReplicaPairResult.cc
 	src/model/DeleteForwardEntryRequest.cc
 	src/model/DeleteForwardEntryResult.cc
 	src/model/DeleteHaVipRequest.cc
@@ -960,8 +946,6 @@ set(ecs_src
 	src/model/DescribeDeploymentSetsResult.cc
 	src/model/DescribeDiskMonitorDataRequest.cc
 	src/model/DescribeDiskMonitorDataResult.cc
-	src/model/DescribeDiskReplicaPairsRequest.cc
-	src/model/DescribeDiskReplicaPairsResult.cc
 	src/model/DescribeDisksRequest.cc
 	src/model/DescribeDisksResult.cc
 	src/model/DescribeDisksFullStatusRequest.cc
@@ -1348,8 +1332,6 @@ set(ecs_src
 	src/model/RunInstancesResult.cc
 	src/model/SendFileRequest.cc
 	src/model/SendFileResult.cc
-	src/model/StartDiskReplicaPairRequest.cc
-	src/model/StartDiskReplicaPairResult.cc
 	src/model/StartElasticityAssuranceRequest.cc
 	src/model/StartElasticityAssuranceResult.cc
 	src/model/StartImagePipelineExecutionRequest.cc
@@ -1360,8 +1342,6 @@ set(ecs_src
 	src/model/StartInstancesResult.cc
 	src/model/StartTerminalSessionRequest.cc
 	src/model/StartTerminalSessionResult.cc
-	src/model/StopDiskReplicaPairRequest.cc
-	src/model/StopDiskReplicaPairResult.cc
 	src/model/StopInstanceRequest.cc
 	src/model/StopInstanceResult.cc
 	src/model/StopInstancesRequest.cc

ecs/include/alibabacloud/ecs/EcsClient.h

@@ -100,8 +100,6 @@
 #include "model/CreateDeploymentSetResult.h"
 #include "model/CreateDiskRequest.h"
 #include "model/CreateDiskResult.h"
-#include "model/CreateDiskReplicaPairRequest.h"
-#include "model/CreateDiskReplicaPairResult.h"
 #include "model/CreateElasticityAssuranceRequest.h"
 #include "model/CreateElasticityAssuranceResult.h"
 #include "model/CreateForwardEntryRequest.h"
@@ -174,8 +172,6 @@
 #include "model/DeleteDeploymentSetResult.h"
 #include "model/DeleteDiskRequest.h"
 #include "model/DeleteDiskResult.h"
-#include "model/DeleteDiskReplicaPairRequest.h"
-#include "model/DeleteDiskReplicaPairResult.h"
 #include "model/DeleteForwardEntryRequest.h"
 #include "model/DeleteForwardEntryResult.h"
 #include "model/DeleteHaVipRequest.h"
@@ -278,8 +274,6 @@
 #include "model/DescribeDeploymentSetsResult.h"
 #include "model/DescribeDiskMonitorDataRequest.h"
 #include "model/DescribeDiskMonitorDataResult.h"
-#include "model/DescribeDiskReplicaPairsRequest.h"
-#include "model/DescribeDiskReplicaPairsResult.h"
 #include "model/DescribeDisksRequest.h"
 #include "model/DescribeDisksResult.h"
 #include "model/DescribeDisksFullStatusRequest.h"
@@ -666,8 +660,6 @@
 #include "model/RunInstancesResult.h"
 #include "model/SendFileRequest.h"
 #include "model/SendFileResult.h"
-#include "model/StartDiskReplicaPairRequest.h"
-#include "model/StartDiskReplicaPairResult.h"
 #include "model/StartElasticityAssuranceRequest.h"
 #include "model/StartElasticityAssuranceResult.h"
 #include "model/StartImagePipelineExecutionRequest.h"
@@ -678,8 +670,6 @@
 #include "model/StartInstancesResult.h"
 #include "model/StartTerminalSessionRequest.h"
 #include "model/StartTerminalSessionResult.h"
-#include "model/StopDiskReplicaPairRequest.h"
-#include "model/StopDiskReplicaPairResult.h"
 #include "model/StopInstanceRequest.h"
 #include "model/StopInstanceResult.h"
 #include "model/StopInstancesRequest.h"
@@ -828,9 +818,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateDiskResult> CreateDiskOutcome;
 			typedef std::future<CreateDiskOutcome> CreateDiskOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::CreateDiskRequest&, const CreateDiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDiskAsyncHandler;
-			typedef Outcome<Error, Model::CreateDiskReplicaPairResult> CreateDiskReplicaPairOutcome;
-			typedef std::future<CreateDiskReplicaPairOutcome> CreateDiskReplicaPairOutcomeCallable;
-			typedef std::function<void(const EcsClient*, const Model::CreateDiskReplicaPairRequest&, const CreateDiskReplicaPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDiskReplicaPairAsyncHandler;
 			typedef Outcome<Error, Model::CreateElasticityAssuranceResult> CreateElasticityAssuranceOutcome;
 			typedef std::future<CreateElasticityAssuranceOutcome> CreateElasticityAssuranceOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::CreateElasticityAssuranceRequest&, const CreateElasticityAssuranceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateElasticityAssuranceAsyncHandler;
@@ -939,9 +926,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteDiskResult> DeleteDiskOutcome;
 			typedef std::future<DeleteDiskOutcome> DeleteDiskOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::DeleteDiskRequest&, const DeleteDiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDiskAsyncHandler;
-			typedef Outcome<Error, Model::DeleteDiskReplicaPairResult> DeleteDiskReplicaPairOutcome;
-			typedef std::future<DeleteDiskReplicaPairOutcome> DeleteDiskReplicaPairOutcomeCallable;
-			typedef std::function<void(const EcsClient*, const Model::DeleteDiskReplicaPairRequest&, const DeleteDiskReplicaPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDiskReplicaPairAsyncHandler;
 			typedef Outcome<Error, Model::DeleteForwardEntryResult> DeleteForwardEntryOutcome;
 			typedef std::future<DeleteForwardEntryOutcome> DeleteForwardEntryOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::DeleteForwardEntryRequest&, const DeleteForwardEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteForwardEntryAsyncHandler;
@@ -1095,9 +1079,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDiskMonitorDataResult> DescribeDiskMonitorDataOutcome;
 			typedef std::future<DescribeDiskMonitorDataOutcome> DescribeDiskMonitorDataOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::DescribeDiskMonitorDataRequest&, const DescribeDiskMonitorDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDiskMonitorDataAsyncHandler;
-			typedef Outcome<Error, Model::DescribeDiskReplicaPairsResult> DescribeDiskReplicaPairsOutcome;
-			typedef std::future<DescribeDiskReplicaPairsOutcome> DescribeDiskReplicaPairsOutcomeCallable;
-			typedef std::function<void(const EcsClient*, const Model::DescribeDiskReplicaPairsRequest&, const DescribeDiskReplicaPairsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDiskReplicaPairsAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDisksResult> DescribeDisksOutcome;
 			typedef std::future<DescribeDisksOutcome> DescribeDisksOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::DescribeDisksRequest&, const DescribeDisksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDisksAsyncHandler;
@@ -1677,9 +1658,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::SendFileResult> SendFileOutcome;
 			typedef std::future<SendFileOutcome> SendFileOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::SendFileRequest&, const SendFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SendFileAsyncHandler;
-			typedef Outcome<Error, Model::StartDiskReplicaPairResult> StartDiskReplicaPairOutcome;
-			typedef std::future<StartDiskReplicaPairOutcome> StartDiskReplicaPairOutcomeCallable;
-			typedef std::function<void(const EcsClient*, const Model::StartDiskReplicaPairRequest&, const StartDiskReplicaPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartDiskReplicaPairAsyncHandler;
 			typedef Outcome<Error, Model::StartElasticityAssuranceResult> StartElasticityAssuranceOutcome;
 			typedef std::future<StartElasticityAssuranceOutcome> StartElasticityAssuranceOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::StartElasticityAssuranceRequest&, const StartElasticityAssuranceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartElasticityAssuranceAsyncHandler;
@@ -1695,9 +1673,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::StartTerminalSessionResult> StartTerminalSessionOutcome;
 			typedef std::future<StartTerminalSessionOutcome> StartTerminalSessionOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::StartTerminalSessionRequest&, const StartTerminalSessionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartTerminalSessionAsyncHandler;
-			typedef Outcome<Error, Model::StopDiskReplicaPairResult> StopDiskReplicaPairOutcome;
-			typedef std::future<StopDiskReplicaPairOutcome> StopDiskReplicaPairOutcomeCallable;
-			typedef std::function<void(const EcsClient*, const Model::StopDiskReplicaPairRequest&, const StopDiskReplicaPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopDiskReplicaPairAsyncHandler;
 			typedef Outcome<Error, Model::StopInstanceResult> StopInstanceOutcome;
 			typedef std::future<StopInstanceOutcome> StopInstanceOutcomeCallable;
 			typedef std::function<void(const EcsClient*, const Model::StopInstanceRequest&, const StopInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopInstanceAsyncHandler;
@@ -1853,9 +1828,6 @@ namespace AlibabaCloud
 			CreateDiskOutcome createDisk(const Model::CreateDiskRequest &request)const;
 			void createDiskAsync(const Model::CreateDiskRequest& request, const CreateDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDiskOutcomeCallable createDiskCallable(const Model::CreateDiskRequest& request) const;
-			CreateDiskReplicaPairOutcome createDiskReplicaPair(const Model::CreateDiskReplicaPairRequest &request)const;
-			void createDiskReplicaPairAsync(const Model::CreateDiskReplicaPairRequest& request, const CreateDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateDiskReplicaPairOutcomeCallable createDiskReplicaPairCallable(const Model::CreateDiskReplicaPairRequest& request) const;
 			CreateElasticityAssuranceOutcome createElasticityAssurance(const Model::CreateElasticityAssuranceRequest &request)const;
 			void createElasticityAssuranceAsync(const Model::CreateElasticityAssuranceRequest& request, const CreateElasticityAssuranceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateElasticityAssuranceOutcomeCallable createElasticityAssuranceCallable(const Model::CreateElasticityAssuranceRequest& request) const;
@@ -1964,9 +1936,6 @@ namespace AlibabaCloud
 			DeleteDiskOutcome deleteDisk(const Model::DeleteDiskRequest &request)const;
 			void deleteDiskAsync(const Model::DeleteDiskRequest& request, const DeleteDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteDiskOutcomeCallable deleteDiskCallable(const Model::DeleteDiskRequest& request) const;
-			DeleteDiskReplicaPairOutcome deleteDiskReplicaPair(const Model::DeleteDiskReplicaPairRequest &request)const;
-			void deleteDiskReplicaPairAsync(const Model::DeleteDiskReplicaPairRequest& request, const DeleteDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteDiskReplicaPairOutcomeCallable deleteDiskReplicaPairCallable(const Model::DeleteDiskReplicaPairRequest& request) const;
 			DeleteForwardEntryOutcome deleteForwardEntry(const Model::DeleteForwardEntryRequest &request)const;
 			void deleteForwardEntryAsync(const Model::DeleteForwardEntryRequest& request, const DeleteForwardEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteForwardEntryOutcomeCallable deleteForwardEntryCallable(const Model::DeleteForwardEntryRequest& request) const;
@@ -2120,9 +2089,6 @@ namespace AlibabaCloud
 			DescribeDiskMonitorDataOutcome describeDiskMonitorData(const Model::DescribeDiskMonitorDataRequest &request)const;
 			void describeDiskMonitorDataAsync(const Model::DescribeDiskMonitorDataRequest& request, const DescribeDiskMonitorDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDiskMonitorDataOutcomeCallable describeDiskMonitorDataCallable(const Model::DescribeDiskMonitorDataRequest& request) const;
-			DescribeDiskReplicaPairsOutcome describeDiskReplicaPairs(const Model::DescribeDiskReplicaPairsRequest &request)const;
-			void describeDiskReplicaPairsAsync(const Model::DescribeDiskReplicaPairsRequest& request, const DescribeDiskReplicaPairsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeDiskReplicaPairsOutcomeCallable describeDiskReplicaPairsCallable(const Model::DescribeDiskReplicaPairsRequest& request) const;
 			DescribeDisksOutcome describeDisks(const Model::DescribeDisksRequest &request)const;
 			void describeDisksAsync(const Model::DescribeDisksRequest& request, const DescribeDisksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDisksOutcomeCallable describeDisksCallable(const Model::DescribeDisksRequest& request) const;
@@ -2702,9 +2668,6 @@ namespace AlibabaCloud
 			SendFileOutcome sendFile(const Model::SendFileRequest &request)const;
 			void sendFileAsync(const Model::SendFileRequest& request, const SendFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SendFileOutcomeCallable sendFileCallable(const Model::SendFileRequest& request) const;
-			StartDiskReplicaPairOutcome startDiskReplicaPair(const Model::StartDiskReplicaPairRequest &request)const;
-			void startDiskReplicaPairAsync(const Model::StartDiskReplicaPairRequest& request, const StartDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			StartDiskReplicaPairOutcomeCallable startDiskReplicaPairCallable(const Model::StartDiskReplicaPairRequest& request) const;
 			StartElasticityAssuranceOutcome startElasticityAssurance(const Model::StartElasticityAssuranceRequest &request)const;
 			void startElasticityAssuranceAsync(const Model::StartElasticityAssuranceRequest& request, const StartElasticityAssuranceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StartElasticityAssuranceOutcomeCallable startElasticityAssuranceCallable(const Model::StartElasticityAssuranceRequest& request) const;
@@ -2720,9 +2683,6 @@ namespace AlibabaCloud
 			StartTerminalSessionOutcome startTerminalSession(const Model::StartTerminalSessionRequest &request)const;
 			void startTerminalSessionAsync(const Model::StartTerminalSessionRequest& request, const StartTerminalSessionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StartTerminalSessionOutcomeCallable startTerminalSessionCallable(const Model::StartTerminalSessionRequest& request) const;
-			StopDiskReplicaPairOutcome stopDiskReplicaPair(const Model::StopDiskReplicaPairRequest &request)const;
-			void stopDiskReplicaPairAsync(const Model::StopDiskReplicaPairRequest& request, const StopDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			StopDiskReplicaPairOutcomeCallable stopDiskReplicaPairCallable(const Model::StopDiskReplicaPairRequest& request) const;
 			StopInstanceOutcome stopInstance(const Model::StopInstanceRequest &request)const;
 			void stopInstanceAsync(const Model::StopInstanceRequest& request, const StopInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StopInstanceOutcomeCallable stopInstanceCallable(const Model::StopInstanceRequest& request) const;

ecs/include/alibabacloud/ecs/model/CreateDiskReplicaPairRequest.h

@@ -1,72 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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_ECS_MODEL_CREATEDISKREPLICAPAIRREQUEST_H_
-#define ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRREQUEST_H_
-
-#include <alibabacloud/ecs/EcsExport.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <string>
-#include <vector>
-#include <map>
-
-namespace AlibabaCloud {
-namespace Ecs {
-namespace Model {
-class ALIBABACLOUD_ECS_EXPORT CreateDiskReplicaPairRequest : public RpcServiceRequest {
-public:
-	CreateDiskReplicaPairRequest();
-	~CreateDiskReplicaPairRequest();
-	long getResourceOwnerId() const;
-	void setResourceOwnerId(long resourceOwnerId);
-	std::string getPairName() const;
-	void setPairName(const std::string &pairName);
-	std::string getDestinationRegionId() const;
-	void setDestinationRegionId(const std::string &destinationRegionId);
-	std::string getDescription() const;
-	void setDescription(const std::string &description);
-	std::string getRegionId() const;
-	void setRegionId(const std::string &regionId);
-	std::string getDiskId() const;
-	void setDiskId(const std::string &diskId);
-	int getAsyncCycle() const;
-	void setAsyncCycle(int asyncCycle);
-	std::string getResourceOwnerAccount() const;
-	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
-	std::string getOwnerAccount() const;
-	void setOwnerAccount(const std::string &ownerAccount);
-	long getOwnerId() const;
-	void setOwnerId(long ownerId);
-	std::string getDestinationDiskId() const;
-	void setDestinationDiskId(const std::string &destinationDiskId);
-
-private:
-	long resourceOwnerId_;
-	std::string pairName_;
-	std::string destinationRegionId_;
-	std::string description_;
-	std::string regionId_;
-	std::string diskId_;
-	int asyncCycle_;
-	std::string resourceOwnerAccount_;
-	std::string ownerAccount_;
-	long ownerId_;
-	std::string destinationDiskId_;
-};
-} // namespace Model
-} // namespace Ecs
-} // namespace AlibabaCloud
-#endif // !ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRREQUEST_H_

ecs/include/alibabacloud/ecs/model/DescribeCapacityReservationsResult.h

@@ -54,6 +54,7 @@ namespace AlibabaCloud
 					std::string privatePoolOptionsName;
 					std::string instanceChargeType;
 					std::string startTime;
+					std::string startTimeType;
 					std::string privatePoolOptionsMatchCriteria;
 					std::string timeSlot;
 					std::vector<CapacityReservationItem::AllocatedResource> allocatedResources;

ecs/include/alibabacloud/ecs/model/DescribeDisksFullStatusRequest.h

@@ -28,6 +28,10 @@ namespace Ecs {
 namespace Model {
 class ALIBABACLOUD_ECS_EXPORT DescribeDisksFullStatusRequest : public RpcServiceRequest {
 public:
+	struct Tag {
+		std::string key;
+		std::string value;
+	};
 	DescribeDisksFullStatusRequest();
 	~DescribeDisksFullStatusRequest();
 	std::vector<std::string> getEventId() const;
@@ -38,12 +42,16 @@ public:
 	void setPageNumber(int pageNumber);
 	std::string getEventTimeStart() const;
 	void setEventTimeStart(const std::string &eventTimeStart);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	int getPageSize() const;
 	void setPageSize(int pageSize);
 	std::vector<std::string> getDiskId() const;
 	void setDiskId(const std::vector<std::string> &diskId);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
 	std::string getResourceOwnerAccount() const;
 	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
 	std::string getOwnerAccount() const;
@@ -64,9 +72,11 @@ private:
 	long resourceOwnerId_;
 	int pageNumber_;
 	std::string eventTimeStart_;
+	std::string resourceGroupId_;
 	std::string regionId_;
 	int pageSize_;
 	std::vector<std::string> diskId_;
+	std::vector<Tag> tag_;
 	std::string resourceOwnerAccount_;
 	std::string ownerAccount_;
 	long ownerId_;

ecs/include/alibabacloud/ecs/model/DescribeElasticityAssurancesResult.h

@@ -53,7 +53,9 @@ namespace AlibabaCloud
 					std::string resourceGroupId;
 					std::string latestStartTime;
 					std::string privatePoolOptionsName;
+					std::string instanceChargeType;
 					std::string startTime;
+					std::string startTimeType;
 					std::string privatePoolOptionsMatchCriteria;
 					std::vector<ElasticityAssuranceItem::AllocatedResource> allocatedResources;
 					std::string privatePoolOptionsId;

ecs/include/alibabacloud/ecs/model/DescribeInstanceHistoryEventsResult.h

@@ -59,6 +59,7 @@ namespace AlibabaCloud
 						std::string hostId;
 						std::vector<InactiveDisk> inactiveDisks;
 						std::string diskId;
+						std::vector<std::string> migrationOptions;
 					};
 					std::string eventFinishTime;
 					EventCycleStatus eventCycleStatus;

ecs/include/alibabacloud/ecs/model/DescribeNetworkInterfaceAttributeResult.h

@@ -44,6 +44,23 @@ namespace AlibabaCloud
 					std::vector<std::string> memberNetworkInterfaceIds;
 					std::string trunkNetworkInterfaceId;
 				};
+				struct BondInterfaceSpecification
+				{
+					struct SlaveInterfaceSpecificationSet
+					{
+						std::string bondNetworkInterfaceId;
+						std::string workState;
+						std::string slaveNetworkInterfaceId;
+					};
+					std::vector<SlaveInterfaceSpecificationSet> slaveInterfaceSpecification2;
+					std::string bondMode;
+				};
+				struct SlaveInterfaceSpecification
+				{
+					std::string bondNetworkInterfaceId;
+					std::string workState;
+					std::string slaveNetworkInterfaceId;
+				};
 				struct PrivateIpSet
 				{
 					struct AssociatedPublicIp1
@@ -81,6 +98,7 @@ namespace AlibabaCloud
 				std::vector<Tag> getTags()const;
 				std::string getStatus()const;
 				std::string getNetworkInterfaceTrafficMode()const;
+				SlaveInterfaceSpecification getSlaveInterfaceSpecification()const;
 				std::string getZoneId()const;
 				std::string getInstanceId()const;
 				std::string getVSwitchId()const;
@@ -92,6 +110,7 @@ namespace AlibabaCloud
 				int getQueuePairNumber()const;
 				int getQueueNumber()const;
 				std::string getVpcId()const;
+				BondInterfaceSpecification getBondInterfaceSpecification()const;
 				std::string getCreationTime()const;
 				std::vector<PrivateIpSet> getPrivateIpSets()const;
 
@@ -110,6 +129,7 @@ namespace AlibabaCloud
 				std::vector<Tag> tags_;
 				std::string status_;
 				std::string networkInterfaceTrafficMode_;
+				SlaveInterfaceSpecification slaveInterfaceSpecification_;
 				std::string zoneId_;
 				std::string instanceId_;
 				std::string vSwitchId_;
@@ -121,6 +141,7 @@ namespace AlibabaCloud
 				int queuePairNumber_;
 				int queueNumber_;
 				std::string vpcId_;
+				BondInterfaceSpecification bondInterfaceSpecification_;
 				std::string creationTime_;
 				std::vector<PrivateIpSet> privateIpSets_;
 

ecs/include/alibabacloud/ecs/model/ResetDiskRequest.h

@@ -36,6 +36,8 @@ public:
 	void setSnapshotId(const std::string &snapshotId);
 	std::string getDiskId() const;
 	void setDiskId(const std::string &diskId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
 	std::string getResourceOwnerAccount() const;
 	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
 	std::string getOwnerAccount() const;
@@ -47,6 +49,7 @@ private:
 	long resourceOwnerId_;
 	std::string snapshotId_;
 	std::string diskId_;
+	bool dryRun_;
 	std::string resourceOwnerAccount_;
 	std::string ownerAccount_;
 	long ownerId_;

ecs/include/alibabacloud/ecs/model/ResetDisksRequest.h

@@ -38,6 +38,8 @@ public:
 	void setResourceOwnerId(long resourceOwnerId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
 	std::string getResourceOwnerAccount() const;
 	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
 	std::string getOwnerAccount() const;
@@ -50,6 +52,7 @@ public:
 private:
 	long resourceOwnerId_;
 	std::string regionId_;
+	bool dryRun_;
 	std::string resourceOwnerAccount_;
 	std::string ownerAccount_;
 	long ownerId_;

ecs/include/alibabacloud/ecs/model/RunInstancesRequest.h

@@ -47,6 +47,10 @@ public:
 		std::string securityGroupId;
 		std::string primaryIpAddress;
 		int queueNumber;
+		std::string networkInterfaceTrafficMode;
+		long queuePairNumber;
+		std::string instanceType;
+		long ipv6AddressCount;
 	};
 	struct DataDisk {
 		std::string performanceLevel;

ecs/include/alibabacloud/ecs/model/StartTerminalSessionRequest.h

@@ -42,6 +42,8 @@ public:
 	void setOwnerId(long ownerId);
 	std::vector<std::string> getInstanceId() const;
 	void setInstanceId(const std::vector<std::string> &instanceId);
+	int getPortNumber() const;
+	void setPortNumber(int portNumber);
 
 private:
 	long resourceOwnerId_;
@@ -50,6 +52,7 @@ private:
 	std::string ownerAccount_;
 	long ownerId_;
 	std::vector<std::string> instanceId_;
+	int portNumber_;
 };
 } // namespace Model
 } // namespace Ecs

ecs/src/EcsClient.cc

@@ -1455,42 +1455,6 @@ EcsClient::CreateDiskOutcomeCallable EcsClient::createDiskCallable(const CreateD
 	return task->get_future();
 }
 
-EcsClient::CreateDiskReplicaPairOutcome EcsClient::createDiskReplicaPair(const CreateDiskReplicaPairRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return CreateDiskReplicaPairOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return CreateDiskReplicaPairOutcome(CreateDiskReplicaPairResult(outcome.result()));
-	else
-		return CreateDiskReplicaPairOutcome(outcome.error());
-}
-
-void EcsClient::createDiskReplicaPairAsync(const CreateDiskReplicaPairRequest& request, const CreateDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, createDiskReplicaPair(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-EcsClient::CreateDiskReplicaPairOutcomeCallable EcsClient::createDiskReplicaPairCallable(const CreateDiskReplicaPairRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<CreateDiskReplicaPairOutcome()>>(
-			[this, request]()
-			{
-			return this->createDiskReplicaPair(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 EcsClient::CreateElasticityAssuranceOutcome EcsClient::createElasticityAssurance(const CreateElasticityAssuranceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2787,42 +2751,6 @@ EcsClient::DeleteDiskOutcomeCallable EcsClient::deleteDiskCallable(const DeleteD
 	return task->get_future();
 }
 
-EcsClient::DeleteDiskReplicaPairOutcome EcsClient::deleteDiskReplicaPair(const DeleteDiskReplicaPairRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DeleteDiskReplicaPairOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DeleteDiskReplicaPairOutcome(DeleteDiskReplicaPairResult(outcome.result()));
-	else
-		return DeleteDiskReplicaPairOutcome(outcome.error());
-}
-
-void EcsClient::deleteDiskReplicaPairAsync(const DeleteDiskReplicaPairRequest& request, const DeleteDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, deleteDiskReplicaPair(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-EcsClient::DeleteDiskReplicaPairOutcomeCallable EcsClient::deleteDiskReplicaPairCallable(const DeleteDiskReplicaPairRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DeleteDiskReplicaPairOutcome()>>(
-			[this, request]()
-			{
-			return this->deleteDiskReplicaPair(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 EcsClient::DeleteForwardEntryOutcome EcsClient::deleteForwardEntry(const DeleteForwardEntryRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4659,42 +4587,6 @@ EcsClient::DescribeDiskMonitorDataOutcomeCallable EcsClient::describeDiskMonitor
 	return task->get_future();
 }
 
-EcsClient::DescribeDiskReplicaPairsOutcome EcsClient::describeDiskReplicaPairs(const DescribeDiskReplicaPairsRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DescribeDiskReplicaPairsOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DescribeDiskReplicaPairsOutcome(DescribeDiskReplicaPairsResult(outcome.result()));
-	else
-		return DescribeDiskReplicaPairsOutcome(outcome.error());
-}
-
-void EcsClient::describeDiskReplicaPairsAsync(const DescribeDiskReplicaPairsRequest& request, const DescribeDiskReplicaPairsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, describeDiskReplicaPairs(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-EcsClient::DescribeDiskReplicaPairsOutcomeCallable EcsClient::describeDiskReplicaPairsCallable(const DescribeDiskReplicaPairsRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DescribeDiskReplicaPairsOutcome()>>(
-			[this, request]()
-			{
-			return this->describeDiskReplicaPairs(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 EcsClient::DescribeDisksOutcome EcsClient::describeDisks(const DescribeDisksRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -11643,42 +11535,6 @@ EcsClient::SendFileOutcomeCallable EcsClient::sendFileCallable(const SendFileReq
 	return task->get_future();
 }
 
-EcsClient::StartDiskReplicaPairOutcome EcsClient::startDiskReplicaPair(const StartDiskReplicaPairRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return StartDiskReplicaPairOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return StartDiskReplicaPairOutcome(StartDiskReplicaPairResult(outcome.result()));
-	else
-		return StartDiskReplicaPairOutcome(outcome.error());
-}
-
-void EcsClient::startDiskReplicaPairAsync(const StartDiskReplicaPairRequest& request, const StartDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, startDiskReplicaPair(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-EcsClient::StartDiskReplicaPairOutcomeCallable EcsClient::startDiskReplicaPairCallable(const StartDiskReplicaPairRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<StartDiskReplicaPairOutcome()>>(
-			[this, request]()
-			{
-			return this->startDiskReplicaPair(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 EcsClient::StartElasticityAssuranceOutcome EcsClient::startElasticityAssurance(const StartElasticityAssuranceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -11859,42 +11715,6 @@ EcsClient::StartTerminalSessionOutcomeCallable EcsClient::startTerminalSessionCa
 	return task->get_future();
 }
 
-EcsClient::StopDiskReplicaPairOutcome EcsClient::stopDiskReplicaPair(const StopDiskReplicaPairRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return StopDiskReplicaPairOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return StopDiskReplicaPairOutcome(StopDiskReplicaPairResult(outcome.result()));
-	else
-		return StopDiskReplicaPairOutcome(outcome.error());
-}
-
-void EcsClient::stopDiskReplicaPairAsync(const StopDiskReplicaPairRequest& request, const StopDiskReplicaPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, stopDiskReplicaPair(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-EcsClient::StopDiskReplicaPairOutcomeCallable EcsClient::stopDiskReplicaPairCallable(const StopDiskReplicaPairRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<StopDiskReplicaPairOutcome()>>(
-			[this, request]()
-			{
-			return this->stopDiskReplicaPair(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 EcsClient::StopInstanceOutcome EcsClient::stopInstance(const StopInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ecs/src/model/CreateDiskReplicaPairRequest.cc

@@ -1,126 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/ecs/model/CreateDiskReplicaPairRequest.h>
-
-using AlibabaCloud::Ecs::Model::CreateDiskReplicaPairRequest;
-
-CreateDiskReplicaPairRequest::CreateDiskReplicaPairRequest()
-    : RpcServiceRequest("ecs", "2014-05-26", "CreateDiskReplicaPair") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-CreateDiskReplicaPairRequest::~CreateDiskReplicaPairRequest() {}
-
-long CreateDiskReplicaPairRequest::getResourceOwnerId() const {
-  return resourceOwnerId_;
-}
-
-void CreateDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId) {
-  resourceOwnerId_ = resourceOwnerId;
-  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
-}
-
-std::string CreateDiskReplicaPairRequest::getPairName() const {
-  return pairName_;
-}
-
-void CreateDiskReplicaPairRequest::setPairName(const std::string &pairName) {
-  pairName_ = pairName;
-  setParameter(std::string("PairName"), pairName);
-}
-
-std::string CreateDiskReplicaPairRequest::getDestinationRegionId() const {
-  return destinationRegionId_;
-}
-
-void CreateDiskReplicaPairRequest::setDestinationRegionId(const std::string &destinationRegionId) {
-  destinationRegionId_ = destinationRegionId;
-  setParameter(std::string("DestinationRegionId"), destinationRegionId);
-}
-
-std::string CreateDiskReplicaPairRequest::getDescription() const {
-  return description_;
-}
-
-void CreateDiskReplicaPairRequest::setDescription(const std::string &description) {
-  description_ = description;
-  setParameter(std::string("Description"), description);
-}
-
-std::string CreateDiskReplicaPairRequest::getRegionId() const {
-  return regionId_;
-}
-
-void CreateDiskReplicaPairRequest::setRegionId(const std::string &regionId) {
-  regionId_ = regionId;
-  setParameter(std::string("RegionId"), regionId);
-}
-
-std::string CreateDiskReplicaPairRequest::getDiskId() const {
-  return diskId_;
-}
-
-void CreateDiskReplicaPairRequest::setDiskId(const std::string &diskId) {
-  diskId_ = diskId;
-  setParameter(std::string("DiskId"), diskId);
-}
-
-int CreateDiskReplicaPairRequest::getAsyncCycle() const {
-  return asyncCycle_;
-}
-
-void CreateDiskReplicaPairRequest::setAsyncCycle(int asyncCycle) {
-  asyncCycle_ = asyncCycle;
-  setParameter(std::string("AsyncCycle"), std::to_string(asyncCycle));
-}
-
-std::string CreateDiskReplicaPairRequest::getResourceOwnerAccount() const {
-  return resourceOwnerAccount_;
-}
-
-void CreateDiskReplicaPairRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
-  resourceOwnerAccount_ = resourceOwnerAccount;
-  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
-}
-
-std::string CreateDiskReplicaPairRequest::getOwnerAccount() const {
-  return ownerAccount_;
-}
-
-void CreateDiskReplicaPairRequest::setOwnerAccount(const std::string &ownerAccount) {
-  ownerAccount_ = ownerAccount;
-  setParameter(std::string("OwnerAccount"), ownerAccount);
-}
-
-long CreateDiskReplicaPairRequest::getOwnerId() const {
-  return ownerId_;
-}
-
-void CreateDiskReplicaPairRequest::setOwnerId(long ownerId) {
-  ownerId_ = ownerId;
-  setParameter(std::string("OwnerId"), std::to_string(ownerId));
-}
-
-std::string CreateDiskReplicaPairRequest::getDestinationDiskId() const {
-  return destinationDiskId_;
-}
-
-void CreateDiskReplicaPairRequest::setDestinationDiskId(const std::string &destinationDiskId) {
-  destinationDiskId_ = destinationDiskId;
-  setParameter(std::string("DestinationDiskId"), destinationDiskId);
-}
-

ecs/src/model/DeleteDiskReplicaPairRequest.cc

@@ -1,81 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/ecs/model/DeleteDiskReplicaPairRequest.h>
-
-using AlibabaCloud::Ecs::Model::DeleteDiskReplicaPairRequest;
-
-DeleteDiskReplicaPairRequest::DeleteDiskReplicaPairRequest()
-    : RpcServiceRequest("ecs", "2014-05-26", "DeleteDiskReplicaPair") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-DeleteDiskReplicaPairRequest::~DeleteDiskReplicaPairRequest() {}
-
-long DeleteDiskReplicaPairRequest::getResourceOwnerId() const {
-  return resourceOwnerId_;
-}
-
-void DeleteDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId) {
-  resourceOwnerId_ = resourceOwnerId;
-  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
-}
-
-std::string DeleteDiskReplicaPairRequest::getRegionId() const {
-  return regionId_;
-}
-
-void DeleteDiskReplicaPairRequest::setRegionId(const std::string &regionId) {
-  regionId_ = regionId;
-  setParameter(std::string("RegionId"), regionId);
-}
-
-std::string DeleteDiskReplicaPairRequest::getResourceOwnerAccount() const {
-  return resourceOwnerAccount_;
-}
-
-void DeleteDiskReplicaPairRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
-  resourceOwnerAccount_ = resourceOwnerAccount;
-  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
-}
-
-std::string DeleteDiskReplicaPairRequest::getOwnerAccount() const {
-  return ownerAccount_;
-}
-
-void DeleteDiskReplicaPairRequest::setOwnerAccount(const std::string &ownerAccount) {
-  ownerAccount_ = ownerAccount;
-  setParameter(std::string("OwnerAccount"), ownerAccount);
-}
-
-long DeleteDiskReplicaPairRequest::getOwnerId() const {
-  return ownerId_;
-}
-
-void DeleteDiskReplicaPairRequest::setOwnerId(long ownerId) {
-  ownerId_ = ownerId;
-  setParameter(std::string("OwnerId"), std::to_string(ownerId));
-}
-
-std::string DeleteDiskReplicaPairRequest::getReplicaPairId() const {
-  return replicaPairId_;
-}
-
-void DeleteDiskReplicaPairRequest::setReplicaPairId(const std::string &replicaPairId) {
-  replicaPairId_ = replicaPairId;
-  setParameter(std::string("ReplicaPairId"), replicaPairId);
-}
-

ecs/src/model/DescribeCapacityReservationsResult.cc

@@ -69,6 +69,8 @@ void DescribeCapacityReservationsResult::parse(const std::string &payload)
 			capacityReservationSetObject.resourceGroupId = valueCapacityReservationSetCapacityReservationItem["ResourceGroupId"].asString();
 		if(!valueCapacityReservationSetCapacityReservationItem["Platform"].isNull())
 			capacityReservationSetObject.platform = valueCapacityReservationSetCapacityReservationItem["Platform"].asString();
+		if(!valueCapacityReservationSetCapacityReservationItem["StartTimeType"].isNull())
+			capacityReservationSetObject.startTimeType = valueCapacityReservationSetCapacityReservationItem["StartTimeType"].asString();
 		auto allAllocatedResourcesNode = valueCapacityReservationSetCapacityReservationItem["AllocatedResources"]["AllocatedResource"];
 		for (auto valueCapacityReservationSetCapacityReservationItemAllocatedResourcesAllocatedResource : allAllocatedResourcesNode)
 		{

ecs/src/model/DescribeDiskReplicaPairsRequest.cc

@@ -1,90 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/ecs/model/DescribeDiskReplicaPairsRequest.h>
-
-using AlibabaCloud::Ecs::Model::DescribeDiskReplicaPairsRequest;
-
-DescribeDiskReplicaPairsRequest::DescribeDiskReplicaPairsRequest()
-    : RpcServiceRequest("ecs", "2014-05-26", "DescribeDiskReplicaPairs") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDiskReplicaPairsRequest::~DescribeDiskReplicaPairsRequest() {}
-
-long DescribeDiskReplicaPairsRequest::getResourceOwnerId() const {
-  return resourceOwnerId_;
-}
-
-void DescribeDiskReplicaPairsRequest::setResourceOwnerId(long resourceOwnerId) {
-  resourceOwnerId_ = resourceOwnerId;
-  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
-}
-
-std::string DescribeDiskReplicaPairsRequest::getRegionId() const {
-  return regionId_;
-}
-
-void DescribeDiskReplicaPairsRequest::setRegionId(const std::string &regionId) {
-  regionId_ = regionId;
-  setParameter(std::string("RegionId"), regionId);
-}
-
-std::string DescribeDiskReplicaPairsRequest::getNextToken() const {
-  return nextToken_;
-}
-
-void DescribeDiskReplicaPairsRequest::setNextToken(const std::string &nextToken) {
-  nextToken_ = nextToken;
-  setParameter(std::string("NextToken"), nextToken);
-}
-
-std::string DescribeDiskReplicaPairsRequest::getResourceOwnerAccount() const {
-  return resourceOwnerAccount_;
-}
-
-void DescribeDiskReplicaPairsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
-  resourceOwnerAccount_ = resourceOwnerAccount;
-  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
-}
-
-std::string DescribeDiskReplicaPairsRequest::getOwnerAccount() const {
-  return ownerAccount_;
-}
-
-void DescribeDiskReplicaPairsRequest::setOwnerAccount(const std::string &ownerAccount) {
-  ownerAccount_ = ownerAccount;
-  setParameter(std::string("OwnerAccount"), ownerAccount);
-}
-
-long DescribeDiskReplicaPairsRequest::getOwnerId() const {
-  return ownerId_;
-}
-
-void DescribeDiskReplicaPairsRequest::setOwnerId(long ownerId) {
-  ownerId_ = ownerId;
-  setParameter(std::string("OwnerId"), std::to_string(ownerId));
-}
-
-int DescribeDiskReplicaPairsRequest::getMaxResults() const {
-  return maxResults_;
-}
-
-void DescribeDiskReplicaPairsRequest::setMaxResults(int maxResults) {
-  maxResults_ = maxResults;
-  setParameter(std::string("MaxResults"), std::to_string(maxResults));
-}
-

ecs/src/model/DescribeDiskReplicaPairsResult.cc

@@ -1,78 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/ecs/model/DescribeDiskReplicaPairsResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Ecs;
-using namespace AlibabaCloud::Ecs::Model;
-
-DescribeDiskReplicaPairsResult::DescribeDiskReplicaPairsResult() :
-	ServiceResult()
-{}
-
-DescribeDiskReplicaPairsResult::DescribeDiskReplicaPairsResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeDiskReplicaPairsResult::~DescribeDiskReplicaPairsResult()
-{}
-
-void DescribeDiskReplicaPairsResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allDiskReplicaPairsNode = value["DiskReplicaPairs"]["DiskReplicaPair"];
-	for (auto valueDiskReplicaPairsDiskReplicaPair : allDiskReplicaPairsNode)
-	{
-		DiskReplicaPair diskReplicaPairsObject;
-		if(!valueDiskReplicaPairsDiskReplicaPair["Status"].isNull())
-			diskReplicaPairsObject.status = valueDiskReplicaPairsDiskReplicaPair["Status"].asString();
-		if(!valueDiskReplicaPairsDiskReplicaPair["SourceDiskId"].isNull())
-			diskReplicaPairsObject.sourceDiskId = valueDiskReplicaPairsDiskReplicaPair["SourceDiskId"].asString();
-		if(!valueDiskReplicaPairsDiskReplicaPair["ReplicaPairId"].isNull())
-			diskReplicaPairsObject.replicaPairId = valueDiskReplicaPairsDiskReplicaPair["ReplicaPairId"].asString();
-		if(!valueDiskReplicaPairsDiskReplicaPair["Description"].isNull())
-			diskReplicaPairsObject.description = valueDiskReplicaPairsDiskReplicaPair["Description"].asString();
-		if(!valueDiskReplicaPairsDiskReplicaPair["DestinationRegion"].isNull())
-			diskReplicaPairsObject.destinationRegion = valueDiskReplicaPairsDiskReplicaPair["DestinationRegion"].asString();
-		if(!valueDiskReplicaPairsDiskReplicaPair["PairName"].isNull())
-			diskReplicaPairsObject.pairName = valueDiskReplicaPairsDiskReplicaPair["PairName"].asString();
-		if(!valueDiskReplicaPairsDiskReplicaPair["SourceRegion"].isNull())
-			diskReplicaPairsObject.sourceRegion = valueDiskReplicaPairsDiskReplicaPair["SourceRegion"].asString();
-		if(!valueDiskReplicaPairsDiskReplicaPair["DestinationDiskId"].isNull())
-			diskReplicaPairsObject.destinationDiskId = valueDiskReplicaPairsDiskReplicaPair["DestinationDiskId"].asString();
-		diskReplicaPairs_.push_back(diskReplicaPairsObject);
-	}
-	if(!value["NextToken"].isNull())
-		nextToken_ = value["NextToken"].asString();
-
-}
-
-std::string DescribeDiskReplicaPairsResult::getNextToken()const
-{
-	return nextToken_;
-}
-
-std::vector<DescribeDiskReplicaPairsResult::DiskReplicaPair> DescribeDiskReplicaPairsResult::getDiskReplicaPairs()const
-{
-	return diskReplicaPairs_;
-}
-

ecs/src/model/DescribeDisksFullStatusRequest.cc

@@ -60,6 +60,15 @@ void DescribeDisksFullStatusRequest::setEventTimeStart(const std::string &eventT
   setParameter(std::string("EventTime.Start"), eventTimeStart);
 }
 
+std::string DescribeDisksFullStatusRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void DescribeDisksFullStatusRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
 std::string DescribeDisksFullStatusRequest::getRegionId() const {
   return regionId_;
 }
@@ -86,6 +95,20 @@ void DescribeDisksFullStatusRequest::setDiskId(const std::vector<std::string> &d
   diskId_ = diskId;
 }
 
+std::vector<DescribeDisksFullStatusRequest::Tag> DescribeDisksFullStatusRequest::getTag() const {
+  return tag_;
+}
+
+void DescribeDisksFullStatusRequest::setTag(const std::vector<DescribeDisksFullStatusRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+  }
+}
+
 std::string DescribeDisksFullStatusRequest::getResourceOwnerAccount() const {
   return resourceOwnerAccount_;
 }

ecs/src/model/DescribeElasticityAssurancesResult.cc

@@ -67,6 +67,10 @@ void DescribeElasticityAssurancesResult::parse(const std::string &payload)
 			elasticityAssuranceSetObject.resourceGroupId = valueElasticityAssuranceSetElasticityAssuranceItem["ResourceGroupId"].asString();
 		if(!valueElasticityAssuranceSetElasticityAssuranceItem["TotalAssuranceTimes"].isNull())
 			elasticityAssuranceSetObject.totalAssuranceTimes = valueElasticityAssuranceSetElasticityAssuranceItem["TotalAssuranceTimes"].asString();
+		if(!valueElasticityAssuranceSetElasticityAssuranceItem["InstanceChargeType"].isNull())
+			elasticityAssuranceSetObject.instanceChargeType = valueElasticityAssuranceSetElasticityAssuranceItem["InstanceChargeType"].asString();
+		if(!valueElasticityAssuranceSetElasticityAssuranceItem["StartTimeType"].isNull())
+			elasticityAssuranceSetObject.startTimeType = valueElasticityAssuranceSetElasticityAssuranceItem["StartTimeType"].asString();
 		auto allAllocatedResourcesNode = valueElasticityAssuranceSetElasticityAssuranceItem["AllocatedResources"]["AllocatedResource"];
 		for (auto valueElasticityAssuranceSetElasticityAssuranceItemAllocatedResourcesAllocatedResource : allAllocatedResourcesNode)
 		{

ecs/src/model/DescribeInstanceHistoryEventsResult.cc

@@ -94,6 +94,9 @@ void DescribeInstanceHistoryEventsResult::parse(const std::string &payload)
 				inactiveDiskObject.releaseTime = extendedAttributeNodeInactiveDisksInactiveDisk["ReleaseTime"].asString();
 			instanceSystemEventSetObject.extendedAttribute.inactiveDisks.push_back(inactiveDiskObject);
 		}
+			auto allMigrationOptions = extendedAttributeNode["MigrationOptions"]["MigrationOption"];
+			for (auto value : allMigrationOptions)
+				instanceSystemEventSetObject.extendedAttribute.migrationOptions.push_back(value.asString());
 		instanceSystemEventSet_.push_back(instanceSystemEventSetObject);
 	}
 	if(!value["PageSize"].isNull())

ecs/src/model/DescribeNetworkInterfaceAttributeResult.cc

@@ -87,6 +87,28 @@ void DescribeNetworkInterfaceAttributeResult::parse(const std::string &payload)
 		auto allMemberNetworkInterfaceIds = attachmentNode["MemberNetworkInterfaceIds"]["MemberNetworkInterfaceId"];
 		for (auto value : allMemberNetworkInterfaceIds)
 			attachment_.memberNetworkInterfaceIds.push_back(value.asString());
+	auto bondInterfaceSpecificationNode = value["BondInterfaceSpecification"];
+	if(!bondInterfaceSpecificationNode["BondMode"].isNull())
+		bondInterfaceSpecification_.bondMode = bondInterfaceSpecificationNode["BondMode"].asString();
+	auto allSlaveInterfaceSpecification2Node = bondInterfaceSpecificationNode["SlaveInterfaceSpecification"]["SlaveInterfaceSpecificationSet"];
+	for (auto bondInterfaceSpecificationNodeSlaveInterfaceSpecificationSlaveInterfaceSpecificationSet : allSlaveInterfaceSpecification2Node)
+	{
+		BondInterfaceSpecification::SlaveInterfaceSpecificationSet slaveInterfaceSpecificationSetObject;
+		if(!bondInterfaceSpecificationNodeSlaveInterfaceSpecificationSlaveInterfaceSpecificationSet["SlaveNetworkInterfaceId"].isNull())
+			slaveInterfaceSpecificationSetObject.slaveNetworkInterfaceId = bondInterfaceSpecificationNodeSlaveInterfaceSpecificationSlaveInterfaceSpecificationSet["SlaveNetworkInterfaceId"].asString();
+		if(!bondInterfaceSpecificationNodeSlaveInterfaceSpecificationSlaveInterfaceSpecificationSet["WorkState"].isNull())
+			slaveInterfaceSpecificationSetObject.workState = bondInterfaceSpecificationNodeSlaveInterfaceSpecificationSlaveInterfaceSpecificationSet["WorkState"].asString();
+		if(!bondInterfaceSpecificationNodeSlaveInterfaceSpecificationSlaveInterfaceSpecificationSet["BondNetworkInterfaceId"].isNull())
+			slaveInterfaceSpecificationSetObject.bondNetworkInterfaceId = bondInterfaceSpecificationNodeSlaveInterfaceSpecificationSlaveInterfaceSpecificationSet["BondNetworkInterfaceId"].asString();
+		bondInterfaceSpecification_.slaveInterfaceSpecification2.push_back(slaveInterfaceSpecificationSetObject);
+	}
+	auto slaveInterfaceSpecificationNode = value["SlaveInterfaceSpecification"];
+	if(!slaveInterfaceSpecificationNode["SlaveNetworkInterfaceId"].isNull())
+		slaveInterfaceSpecification_.slaveNetworkInterfaceId = slaveInterfaceSpecificationNode["SlaveNetworkInterfaceId"].asString();
+	if(!slaveInterfaceSpecificationNode["WorkState"].isNull())
+		slaveInterfaceSpecification_.workState = slaveInterfaceSpecificationNode["WorkState"].asString();
+	if(!slaveInterfaceSpecificationNode["BondNetworkInterfaceId"].isNull())
+		slaveInterfaceSpecification_.bondNetworkInterfaceId = slaveInterfaceSpecificationNode["BondNetworkInterfaceId"].asString();
 	auto allSecurityGroupIds = value["SecurityGroupIds"]["SecurityGroupId"];
 	for (const auto &item : allSecurityGroupIds)
 		securityGroupIds_.push_back(item.asString());
@@ -191,6 +213,11 @@ std::string DescribeNetworkInterfaceAttributeResult::getNetworkInterfaceTrafficM
 	return networkInterfaceTrafficMode_;
 }
 
+DescribeNetworkInterfaceAttributeResult::SlaveInterfaceSpecification DescribeNetworkInterfaceAttributeResult::getSlaveInterfaceSpecification()const
+{
+	return slaveInterfaceSpecification_;
+}
+
 std::string DescribeNetworkInterfaceAttributeResult::getZoneId()const
 {
 	return zoneId_;
@@ -246,6 +273,11 @@ std::string DescribeNetworkInterfaceAttributeResult::getVpcId()const
 	return vpcId_;
 }
 
+DescribeNetworkInterfaceAttributeResult::BondInterfaceSpecification DescribeNetworkInterfaceAttributeResult::getBondInterfaceSpecification()const
+{
+	return bondInterfaceSpecification_;
+}
+
 std::string DescribeNetworkInterfaceAttributeResult::getCreationTime()const
 {
 	return creationTime_;

ecs/src/model/ResetDiskRequest.cc

@@ -52,6 +52,15 @@ void ResetDiskRequest::setDiskId(const std::string &diskId) {
   setParameter(std::string("DiskId"), diskId);
 }
 
+bool ResetDiskRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void ResetDiskRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
 std::string ResetDiskRequest::getResourceOwnerAccount() const {
   return resourceOwnerAccount_;
 }

ecs/src/model/ResetDisksRequest.cc

@@ -43,6 +43,15 @@ void ResetDisksRequest::setRegionId(const std::string &regionId) {
   setParameter(std::string("RegionId"), regionId);
 }
 
+bool ResetDisksRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void ResetDisksRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
 std::string ResetDisksRequest::getResourceOwnerAccount() const {
   return resourceOwnerAccount_;
 }

ecs/src/model/RunInstancesRequest.cc

@@ -705,6 +705,10 @@ void RunInstancesRequest::setNetworkInterface(const std::vector<RunInstancesRequ
     setParameter(networkInterfaceObjStr + ".SecurityGroupId", networkInterfaceObj.securityGroupId);
     setParameter(networkInterfaceObjStr + ".PrimaryIpAddress", networkInterfaceObj.primaryIpAddress);
     setParameter(networkInterfaceObjStr + ".QueueNumber", std::to_string(networkInterfaceObj.queueNumber));
+    setParameter(networkInterfaceObjStr + ".NetworkInterfaceTrafficMode", networkInterfaceObj.networkInterfaceTrafficMode);
+    setParameter(networkInterfaceObjStr + ".QueuePairNumber", std::to_string(networkInterfaceObj.queuePairNumber));
+    setParameter(networkInterfaceObjStr + ".InstanceType", networkInterfaceObj.instanceType);
+    setParameter(networkInterfaceObjStr + ".Ipv6AddressCount", std::to_string(networkInterfaceObj.ipv6AddressCount));
   }
 }
 

ecs/src/model/StartDiskReplicaPairRequest.cc

@@ -1,81 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/ecs/model/StartDiskReplicaPairRequest.h>
-
-using AlibabaCloud::Ecs::Model::StartDiskReplicaPairRequest;
-
-StartDiskReplicaPairRequest::StartDiskReplicaPairRequest()
-    : RpcServiceRequest("ecs", "2014-05-26", "StartDiskReplicaPair") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-StartDiskReplicaPairRequest::~StartDiskReplicaPairRequest() {}
-
-long StartDiskReplicaPairRequest::getResourceOwnerId() const {
-  return resourceOwnerId_;
-}
-
-void StartDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId) {
-  resourceOwnerId_ = resourceOwnerId;
-  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
-}
-
-std::string StartDiskReplicaPairRequest::getRegionId() const {
-  return regionId_;
-}
-
-void StartDiskReplicaPairRequest::setRegionId(const std::string &regionId) {
-  regionId_ = regionId;
-  setParameter(std::string("RegionId"), regionId);
-}
-
-std::string StartDiskReplicaPairRequest::getResourceOwnerAccount() const {
-  return resourceOwnerAccount_;
-}
-
-void StartDiskReplicaPairRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
-  resourceOwnerAccount_ = resourceOwnerAccount;
-  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
-}
-
-std::string StartDiskReplicaPairRequest::getOwnerAccount() const {
-  return ownerAccount_;
-}
-
-void StartDiskReplicaPairRequest::setOwnerAccount(const std::string &ownerAccount) {
-  ownerAccount_ = ownerAccount;
-  setParameter(std::string("OwnerAccount"), ownerAccount);
-}
-
-long StartDiskReplicaPairRequest::getOwnerId() const {
-  return ownerId_;
-}
-
-void StartDiskReplicaPairRequest::setOwnerId(long ownerId) {
-  ownerId_ = ownerId;
-  setParameter(std::string("OwnerId"), std::to_string(ownerId));
-}
-
-std::string StartDiskReplicaPairRequest::getReplicaPairId() const {
-  return replicaPairId_;
-}
-
-void StartDiskReplicaPairRequest::setReplicaPairId(const std::string &replicaPairId) {
-  replicaPairId_ = replicaPairId;
-  setParameter(std::string("ReplicaPairId"), replicaPairId);
-}
-

ecs/src/model/StartTerminalSessionRequest.cc

@@ -78,3 +78,12 @@ void StartTerminalSessionRequest::setInstanceId(const std::vector<std::string> &
   instanceId_ = instanceId;
 }
 
+int StartTerminalSessionRequest::getPortNumber() const {
+  return portNumber_;
+}
+
+void StartTerminalSessionRequest::setPortNumber(int portNumber) {
+  portNumber_ = portNumber;
+  setParameter(std::string("PortNumber"), std::to_string(portNumber));
+}
+

ecs/src/model/StopDiskReplicaPairRequest.cc

@@ -1,81 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/ecs/model/StopDiskReplicaPairRequest.h>
-
-using AlibabaCloud::Ecs::Model::StopDiskReplicaPairRequest;
-
-StopDiskReplicaPairRequest::StopDiskReplicaPairRequest()
-    : RpcServiceRequest("ecs", "2014-05-26", "StopDiskReplicaPair") {
-  setMethod(HttpRequest::Method::Post);
-}
-
-StopDiskReplicaPairRequest::~StopDiskReplicaPairRequest() {}
-
-long StopDiskReplicaPairRequest::getResourceOwnerId() const {
-  return resourceOwnerId_;
-}
-
-void StopDiskReplicaPairRequest::setResourceOwnerId(long resourceOwnerId) {
-  resourceOwnerId_ = resourceOwnerId;
-  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
-}
-
-std::string StopDiskReplicaPairRequest::getRegionId() const {
-  return regionId_;
-}
-
-void StopDiskReplicaPairRequest::setRegionId(const std::string &regionId) {
-  regionId_ = regionId;
-  setParameter(std::string("RegionId"), regionId);
-}
-
-std::string StopDiskReplicaPairRequest::getResourceOwnerAccount() const {
-  return resourceOwnerAccount_;
-}
-
-void StopDiskReplicaPairRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
-  resourceOwnerAccount_ = resourceOwnerAccount;
-  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
-}
-
-std::string StopDiskReplicaPairRequest::getOwnerAccount() const {
-  return ownerAccount_;
-}
-
-void StopDiskReplicaPairRequest::setOwnerAccount(const std::string &ownerAccount) {
-  ownerAccount_ = ownerAccount;
-  setParameter(std::string("OwnerAccount"), ownerAccount);
-}
-
-long StopDiskReplicaPairRequest::getOwnerId() const {
-  return ownerId_;
-}
-
-void StopDiskReplicaPairRequest::setOwnerId(long ownerId) {
-  ownerId_ = ownerId;
-  setParameter(std::string("OwnerId"), std::to_string(ownerId));
-}
-
-std::string StopDiskReplicaPairRequest::getReplicaPairId() const {
-  return replicaPairId_;
-}
-
-void StopDiskReplicaPairRequest::setReplicaPairId(const std::string &replicaPairId) {
-  replicaPairId_ = replicaPairId;
-  setParameter(std::string("ReplicaPairId"), replicaPairId);
-}
-

hbase/include/alibabacloud/hbase/model/DescribeInstancesRequest.h

@@ -53,6 +53,8 @@ namespace AlibabaCloud
 				void setPageSize(int pageSize);
 				std::vector<Tag> getTag()const;
 				void setTag(const std::vector<Tag>& tag);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
 				std::string getDbType()const;
 				void setDbType(const std::string& dbType);
 
@@ -63,6 +65,7 @@ namespace AlibabaCloud
 				std::string regionId_;
 				int pageSize_;
 				std::vector<Tag> tag_;
+				std::string clusterId_;
 				std::string dbType_;
 
 			};