Generated 2020-05-18 for dataworks-public.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-12-03 Version: patch
+- Generated 2020-05-18 for `dataworks-public`.
+
 2020-12-03 Version: patch
 - Add new api.
 

dataworks-public/CMakeLists.txt

@@ -49,6 +49,8 @@ set(dataworks-public_public_header_model
 	include/alibabacloud/dataworks-public/model/CreateFileResult.h
 	include/alibabacloud/dataworks-public/model/CreateFolderRequest.h
 	include/alibabacloud/dataworks-public/model/CreateFolderResult.h
+	include/alibabacloud/dataworks-public/model/CreateManualDagRequest.h
+	include/alibabacloud/dataworks-public/model/CreateManualDagResult.h
 	include/alibabacloud/dataworks-public/model/CreateMetaCategoryRequest.h
 	include/alibabacloud/dataworks-public/model/CreateMetaCategoryResult.h
 	include/alibabacloud/dataworks-public/model/CreateProjectMemberRequest.h
@@ -119,6 +121,8 @@ set(dataworks-public_public_header_model
 	include/alibabacloud/dataworks-public/model/GetBusinessResult.h
 	include/alibabacloud/dataworks-public/model/GetDDLJobStatusRequest.h
 	include/alibabacloud/dataworks-public/model/GetDDLJobStatusResult.h
+	include/alibabacloud/dataworks-public/model/GetDagRequest.h
+	include/alibabacloud/dataworks-public/model/GetDagResult.h
 	include/alibabacloud/dataworks-public/model/GetDataServiceApiRequest.h
 	include/alibabacloud/dataworks-public/model/GetDataServiceApiResult.h
 	include/alibabacloud/dataworks-public/model/GetDataServiceApplicationRequest.h
@@ -149,6 +153,8 @@ set(dataworks-public_public_header_model
 	include/alibabacloud/dataworks-public/model/GetInstanceLogResult.h
 	include/alibabacloud/dataworks-public/model/GetInstanceStatusCountRequest.h
 	include/alibabacloud/dataworks-public/model/GetInstanceStatusCountResult.h
+	include/alibabacloud/dataworks-public/model/GetManualDagInstancesRequest.h
+	include/alibabacloud/dataworks-public/model/GetManualDagInstancesResult.h
 	include/alibabacloud/dataworks-public/model/GetMetaCategoryRequest.h
 	include/alibabacloud/dataworks-public/model/GetMetaCategoryResult.h
 	include/alibabacloud/dataworks-public/model/GetMetaColumnLineageRequest.h
@@ -271,8 +277,12 @@ set(dataworks-public_public_header_model
 	include/alibabacloud/dataworks-public/model/RestartInstanceResult.h
 	include/alibabacloud/dataworks-public/model/ResumeInstanceRequest.h
 	include/alibabacloud/dataworks-public/model/ResumeInstanceResult.h
+	include/alibabacloud/dataworks-public/model/RunTriggerNodeRequest.h
+	include/alibabacloud/dataworks-public/model/RunTriggerNodeResult.h
 	include/alibabacloud/dataworks-public/model/SearchMetaTablesRequest.h
 	include/alibabacloud/dataworks-public/model/SearchMetaTablesResult.h
+	include/alibabacloud/dataworks-public/model/SearchNodesByOutputRequest.h
+	include/alibabacloud/dataworks-public/model/SearchNodesByOutputResult.h
 	include/alibabacloud/dataworks-public/model/SetSuccessInstanceRequest.h
 	include/alibabacloud/dataworks-public/model/SetSuccessInstanceResult.h
 	include/alibabacloud/dataworks-public/model/StopInstanceRequest.h
@@ -344,6 +354,8 @@ set(dataworks-public_src
 	src/model/CreateFileResult.cc
 	src/model/CreateFolderRequest.cc
 	src/model/CreateFolderResult.cc
+	src/model/CreateManualDagRequest.cc
+	src/model/CreateManualDagResult.cc
 	src/model/CreateMetaCategoryRequest.cc
 	src/model/CreateMetaCategoryResult.cc
 	src/model/CreateProjectMemberRequest.cc
@@ -414,6 +426,8 @@ set(dataworks-public_src
 	src/model/GetBusinessResult.cc
 	src/model/GetDDLJobStatusRequest.cc
 	src/model/GetDDLJobStatusResult.cc
+	src/model/GetDagRequest.cc
+	src/model/GetDagResult.cc
 	src/model/GetDataServiceApiRequest.cc
 	src/model/GetDataServiceApiResult.cc
 	src/model/GetDataServiceApplicationRequest.cc
@@ -444,6 +458,8 @@ set(dataworks-public_src
 	src/model/GetInstanceLogResult.cc
 	src/model/GetInstanceStatusCountRequest.cc
 	src/model/GetInstanceStatusCountResult.cc
+	src/model/GetManualDagInstancesRequest.cc
+	src/model/GetManualDagInstancesResult.cc
 	src/model/GetMetaCategoryRequest.cc
 	src/model/GetMetaCategoryResult.cc
 	src/model/GetMetaColumnLineageRequest.cc
@@ -566,8 +582,12 @@ set(dataworks-public_src
 	src/model/RestartInstanceResult.cc
 	src/model/ResumeInstanceRequest.cc
 	src/model/ResumeInstanceResult.cc
+	src/model/RunTriggerNodeRequest.cc
+	src/model/RunTriggerNodeResult.cc
 	src/model/SearchMetaTablesRequest.cc
 	src/model/SearchMetaTablesResult.cc
+	src/model/SearchNodesByOutputRequest.cc
+	src/model/SearchNodesByOutputResult.cc
 	src/model/SetSuccessInstanceRequest.cc
 	src/model/SetSuccessInstanceResult.cc
 	src/model/StopInstanceRequest.cc

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

@@ -50,6 +50,8 @@
 #include "model/CreateFileResult.h"
 #include "model/CreateFolderRequest.h"
 #include "model/CreateFolderResult.h"
+#include "model/CreateManualDagRequest.h"
+#include "model/CreateManualDagResult.h"
 #include "model/CreateMetaCategoryRequest.h"
 #include "model/CreateMetaCategoryResult.h"
 #include "model/CreateProjectMemberRequest.h"
@@ -120,6 +122,8 @@
 #include "model/GetBusinessResult.h"
 #include "model/GetDDLJobStatusRequest.h"
 #include "model/GetDDLJobStatusResult.h"
+#include "model/GetDagRequest.h"
+#include "model/GetDagResult.h"
 #include "model/GetDataServiceApiRequest.h"
 #include "model/GetDataServiceApiResult.h"
 #include "model/GetDataServiceApplicationRequest.h"
@@ -150,6 +154,8 @@
 #include "model/GetInstanceLogResult.h"
 #include "model/GetInstanceStatusCountRequest.h"
 #include "model/GetInstanceStatusCountResult.h"
+#include "model/GetManualDagInstancesRequest.h"
+#include "model/GetManualDagInstancesResult.h"
 #include "model/GetMetaCategoryRequest.h"
 #include "model/GetMetaCategoryResult.h"
 #include "model/GetMetaColumnLineageRequest.h"
@@ -272,8 +278,12 @@
 #include "model/RestartInstanceResult.h"
 #include "model/ResumeInstanceRequest.h"
 #include "model/ResumeInstanceResult.h"
+#include "model/RunTriggerNodeRequest.h"
+#include "model/RunTriggerNodeResult.h"
 #include "model/SearchMetaTablesRequest.h"
 #include "model/SearchMetaTablesResult.h"
+#include "model/SearchNodesByOutputRequest.h"
+#include "model/SearchNodesByOutputResult.h"
 #include "model/SetSuccessInstanceRequest.h"
 #include "model/SetSuccessInstanceResult.h"
 #include "model/StopInstanceRequest.h"
@@ -365,6 +375,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateFolderResult> CreateFolderOutcome;
 			typedef std::future<CreateFolderOutcome> CreateFolderOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateFolderRequest&, const CreateFolderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFolderAsyncHandler;
+			typedef Outcome<Error, Model::CreateManualDagResult> CreateManualDagOutcome;
+			typedef std::future<CreateManualDagOutcome> CreateManualDagOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateManualDagRequest&, const CreateManualDagOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateManualDagAsyncHandler;
 			typedef Outcome<Error, Model::CreateMetaCategoryResult> CreateMetaCategoryOutcome;
 			typedef std::future<CreateMetaCategoryOutcome> CreateMetaCategoryOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateMetaCategoryRequest&, const CreateMetaCategoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMetaCategoryAsyncHandler;
@@ -470,6 +483,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetDDLJobStatusResult> GetDDLJobStatusOutcome;
 			typedef std::future<GetDDLJobStatusOutcome> GetDDLJobStatusOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::GetDDLJobStatusRequest&, const GetDDLJobStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDDLJobStatusAsyncHandler;
+			typedef Outcome<Error, Model::GetDagResult> GetDagOutcome;
+			typedef std::future<GetDagOutcome> GetDagOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetDagRequest&, const GetDagOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDagAsyncHandler;
 			typedef Outcome<Error, Model::GetDataServiceApiResult> GetDataServiceApiOutcome;
 			typedef std::future<GetDataServiceApiOutcome> GetDataServiceApiOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::GetDataServiceApiRequest&, const GetDataServiceApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDataServiceApiAsyncHandler;
@@ -515,6 +531,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetInstanceStatusCountResult> GetInstanceStatusCountOutcome;
 			typedef std::future<GetInstanceStatusCountOutcome> GetInstanceStatusCountOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::GetInstanceStatusCountRequest&, const GetInstanceStatusCountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInstanceStatusCountAsyncHandler;
+			typedef Outcome<Error, Model::GetManualDagInstancesResult> GetManualDagInstancesOutcome;
+			typedef std::future<GetManualDagInstancesOutcome> GetManualDagInstancesOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::GetManualDagInstancesRequest&, const GetManualDagInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetManualDagInstancesAsyncHandler;
 			typedef Outcome<Error, Model::GetMetaCategoryResult> GetMetaCategoryOutcome;
 			typedef std::future<GetMetaCategoryOutcome> GetMetaCategoryOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::GetMetaCategoryRequest&, const GetMetaCategoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetaCategoryAsyncHandler;
@@ -698,9 +717,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ResumeInstanceResult> ResumeInstanceOutcome;
 			typedef std::future<ResumeInstanceOutcome> ResumeInstanceOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::ResumeInstanceRequest&, const ResumeInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResumeInstanceAsyncHandler;
+			typedef Outcome<Error, Model::RunTriggerNodeResult> RunTriggerNodeOutcome;
+			typedef std::future<RunTriggerNodeOutcome> RunTriggerNodeOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::RunTriggerNodeRequest&, const RunTriggerNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RunTriggerNodeAsyncHandler;
 			typedef Outcome<Error, Model::SearchMetaTablesResult> SearchMetaTablesOutcome;
 			typedef std::future<SearchMetaTablesOutcome> SearchMetaTablesOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::SearchMetaTablesRequest&, const SearchMetaTablesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchMetaTablesAsyncHandler;
+			typedef Outcome<Error, Model::SearchNodesByOutputResult> SearchNodesByOutputOutcome;
+			typedef std::future<SearchNodesByOutputOutcome> SearchNodesByOutputOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::SearchNodesByOutputRequest&, const SearchNodesByOutputOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchNodesByOutputAsyncHandler;
 			typedef Outcome<Error, Model::SetSuccessInstanceResult> SetSuccessInstanceOutcome;
 			typedef std::future<SetSuccessInstanceOutcome> SetSuccessInstanceOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::SetSuccessInstanceRequest&, const SetSuccessInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetSuccessInstanceAsyncHandler;
@@ -808,6 +833,9 @@ namespace AlibabaCloud
 			CreateFolderOutcome createFolder(const Model::CreateFolderRequest &request)const;
 			void createFolderAsync(const Model::CreateFolderRequest& request, const CreateFolderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateFolderOutcomeCallable createFolderCallable(const Model::CreateFolderRequest& request) const;
+			CreateManualDagOutcome createManualDag(const Model::CreateManualDagRequest &request)const;
+			void createManualDagAsync(const Model::CreateManualDagRequest& request, const CreateManualDagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateManualDagOutcomeCallable createManualDagCallable(const Model::CreateManualDagRequest& request) const;
 			CreateMetaCategoryOutcome createMetaCategory(const Model::CreateMetaCategoryRequest &request)const;
 			void createMetaCategoryAsync(const Model::CreateMetaCategoryRequest& request, const CreateMetaCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateMetaCategoryOutcomeCallable createMetaCategoryCallable(const Model::CreateMetaCategoryRequest& request) const;
@@ -913,6 +941,9 @@ namespace AlibabaCloud
 			GetDDLJobStatusOutcome getDDLJobStatus(const Model::GetDDLJobStatusRequest &request)const;
 			void getDDLJobStatusAsync(const Model::GetDDLJobStatusRequest& request, const GetDDLJobStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetDDLJobStatusOutcomeCallable getDDLJobStatusCallable(const Model::GetDDLJobStatusRequest& request) const;
+			GetDagOutcome getDag(const Model::GetDagRequest &request)const;
+			void getDagAsync(const Model::GetDagRequest& request, const GetDagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDagOutcomeCallable getDagCallable(const Model::GetDagRequest& request) const;
 			GetDataServiceApiOutcome getDataServiceApi(const Model::GetDataServiceApiRequest &request)const;
 			void getDataServiceApiAsync(const Model::GetDataServiceApiRequest& request, const GetDataServiceApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetDataServiceApiOutcomeCallable getDataServiceApiCallable(const Model::GetDataServiceApiRequest& request) const;
@@ -958,6 +989,9 @@ namespace AlibabaCloud
 			GetInstanceStatusCountOutcome getInstanceStatusCount(const Model::GetInstanceStatusCountRequest &request)const;
 			void getInstanceStatusCountAsync(const Model::GetInstanceStatusCountRequest& request, const GetInstanceStatusCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetInstanceStatusCountOutcomeCallable getInstanceStatusCountCallable(const Model::GetInstanceStatusCountRequest& request) const;
+			GetManualDagInstancesOutcome getManualDagInstances(const Model::GetManualDagInstancesRequest &request)const;
+			void getManualDagInstancesAsync(const Model::GetManualDagInstancesRequest& request, const GetManualDagInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetManualDagInstancesOutcomeCallable getManualDagInstancesCallable(const Model::GetManualDagInstancesRequest& request) const;
 			GetMetaCategoryOutcome getMetaCategory(const Model::GetMetaCategoryRequest &request)const;
 			void getMetaCategoryAsync(const Model::GetMetaCategoryRequest& request, const GetMetaCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetMetaCategoryOutcomeCallable getMetaCategoryCallable(const Model::GetMetaCategoryRequest& request) const;
@@ -1141,9 +1175,15 @@ namespace AlibabaCloud
 			ResumeInstanceOutcome resumeInstance(const Model::ResumeInstanceRequest &request)const;
 			void resumeInstanceAsync(const Model::ResumeInstanceRequest& request, const ResumeInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ResumeInstanceOutcomeCallable resumeInstanceCallable(const Model::ResumeInstanceRequest& request) const;
+			RunTriggerNodeOutcome runTriggerNode(const Model::RunTriggerNodeRequest &request)const;
+			void runTriggerNodeAsync(const Model::RunTriggerNodeRequest& request, const RunTriggerNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RunTriggerNodeOutcomeCallable runTriggerNodeCallable(const Model::RunTriggerNodeRequest& request) const;
 			SearchMetaTablesOutcome searchMetaTables(const Model::SearchMetaTablesRequest &request)const;
 			void searchMetaTablesAsync(const Model::SearchMetaTablesRequest& request, const SearchMetaTablesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SearchMetaTablesOutcomeCallable searchMetaTablesCallable(const Model::SearchMetaTablesRequest& request) const;
+			SearchNodesByOutputOutcome searchNodesByOutput(const Model::SearchNodesByOutputRequest &request)const;
+			void searchNodesByOutputAsync(const Model::SearchNodesByOutputRequest& request, const SearchNodesByOutputAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SearchNodesByOutputOutcomeCallable searchNodesByOutputCallable(const Model::SearchNodesByOutputRequest& request) const;
 			SetSuccessInstanceOutcome setSuccessInstance(const Model::SetSuccessInstanceRequest &request)const;
 			void setSuccessInstanceAsync(const Model::SetSuccessInstanceRequest& request, const SetSuccessInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetSuccessInstanceOutcomeCallable setSuccessInstanceCallable(const Model::SetSuccessInstanceRequest& request) const;

dataworks-public/include/alibabacloud/dataworks-public/model/CreateManualDagRequest.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_CREATEMANUALDAGREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEMANUALDAGREQUEST_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 CreateManualDagRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateManualDagRequest();
+				~CreateManualDagRequest();
+
+				std::string getProjectEnv()const;
+				void setProjectEnv(const std::string& projectEnv);
+				std::string getProjectName()const;
+				void setProjectName(const std::string& projectName);
+				std::string getBizDate()const;
+				void setBizDate(const std::string& bizDate);
+				std::string getFlowName()const;
+				void setFlowName(const std::string& flowName);
+				std::string getDagParameters()const;
+				void setDagParameters(const std::string& dagParameters);
+				std::string getNodeParameters()const;
+				void setNodeParameters(const std::string& nodeParameters);
+
+            private:
+				std::string projectEnv_;
+				std::string projectName_;
+				std::string bizDate_;
+				std::string flowName_;
+				std::string dagParameters_;
+				std::string nodeParameters_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEMANUALDAGREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateManualDagResult.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_CREATEMANUALDAGRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEMANUALDAGRESULT_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 CreateManualDagResult : public ServiceResult
+			{
+			public:
+
+
+				CreateManualDagResult();
+				explicit CreateManualDagResult(const std::string &payload);
+				~CreateManualDagResult();
+				long getDagId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long dagId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEMANUALDAGRESULT_H_

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

@@ -79,6 +79,8 @@ namespace AlibabaCloud
 				void setHasPart(int hasPart);
 				std::string getLocation()const;
 				void setLocation(const std::string& location);
+				std::string getComment()const;
+				void setComment(const std::string& comment);
 				std::string getTableName()const;
 				void setTableName(const std::string& tableName);
 				std::string getAppGuid()const;
@@ -102,6 +104,7 @@ namespace AlibabaCloud
 				int envType_;
 				int hasPart_;
 				std::string location_;
+				std::string comment_;
 				std::string tableName_;
 				std::string appGuid_;
 				long projectId_;

dataworks-public/include/alibabacloud/dataworks-public/model/GetDagRequest.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_GETDAGREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETDAGREQUEST_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 GetDagRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetDagRequest();
+				~GetDagRequest();
+
+				std::string getProjectEnv()const;
+				void setProjectEnv(const std::string& projectEnv);
+				long getDagId()const;
+				void setDagId(long dagId);
+
+            private:
+				std::string projectEnv_;
+				long dagId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETDAGREQUEST_H_

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

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_GETDAGRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETDAGRESULT_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 GetDagResult : public ServiceResult
+			{
+			public:
+				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;
+				};
+
+
+				GetDagResult();
+				explicit GetDagResult(const std::string &payload);
+				~GetDagResult();
+				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_GETDAGRESULT_H_

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

@@ -35,20 +35,29 @@ namespace AlibabaCloud
 				struct Data
 				{
 					std::string status;
+					long baselineId;
 					long modifyTime;
 					long instanceId;
 					std::string dagType;
 					std::string nodeName;
+					int priority;
+					int dqcType;
 					std::string paramValues;
 					long createTime;
+					std::string connection;
+					long relatedFlowId;
 					long cycTime;
 					long beginWaitTimeTime;
 					long dagId;
 					long bizdate;
 					long beginRunningTime;
+					bool repeatability;
 					long finishTime;
+					std::string dqcDescription;
 					long nodeId;
 					long beginWaitResTime;
+					std::string errorMessage;
+					long repeatInterval;
 				};
 
 

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

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMANUALDAGINSTANCESREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMANUALDAGINSTANCESREQUEST_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 GetManualDagInstancesRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetManualDagInstancesRequest();
+				~GetManualDagInstancesRequest();
+
+				std::string getProjectEnv()const;
+				void setProjectEnv(const std::string& projectEnv);
+				std::string getProjectName()const;
+				void setProjectName(const std::string& projectName);
+				std::string getDagId()const;
+				void setDagId(const std::string& dagId);
+
+            private:
+				std::string projectEnv_;
+				std::string projectName_;
+				std::string dagId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMANUALDAGINSTANCESREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesResult.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_GETMANUALDAGINSTANCESRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMANUALDAGINSTANCESRESULT_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 GetManualDagInstancesResult : public ServiceResult
+			{
+			public:
+				struct InstancesItem
+				{
+					std::string status;
+					long modifyTime;
+					long instanceId;
+					std::string dagType;
+					std::string nodeName;
+					long createTime;
+					std::string paramValues;
+					long cycTime;
+					long beginWaitTimeTime;
+					long dagId;
+					long beginRunningTime;
+					long finishTime;
+					long nodeId;
+					long beginWaitResTime;
+					long bizDate;
+				};
+
+
+				GetManualDagInstancesResult();
+				explicit GetManualDagInstancesResult(const std::string &payload);
+				~GetManualDagInstancesResult();
+				std::vector<InstancesItem> getInstances()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<InstancesItem> instances_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMANUALDAGINSTANCESRESULT_H_

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

@@ -34,17 +34,24 @@ namespace AlibabaCloud
 			public:
 				struct Data
 				{
-					std::string repeatability;
+					long baselineId;
 					std::string description;
 					std::string resGroupName;
-					std::string ownerId;
 					std::string nodeName;
+					int priority;
+					int dqcType;
 					std::string paramValues;
-					long nodeId;
 					long projectId;
-					std::string programType;
+					std::string connection;
 					std::string schedulerType;
+					long relatedFlowId;
 					std::string cronExpress;
+					std::string repeatability;
+					std::string ownerId;
+					std::string dqcDescription;
+					long nodeId;
+					std::string programType;
+					long repeatInterval;
 				};
 
 

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

@@ -41,6 +41,8 @@ namespace AlibabaCloud
 				void setOwner(const std::string& owner);
 				std::string getBizName()const;
 				void setBizName(const std::string& bizName);
+				long getDagId()const;
+				void setDagId(long dagId);
 				int getPageNumber()const;
 				void setPageNumber(int pageNumber);
 				std::string getNodeName()const;
@@ -58,6 +60,7 @@ namespace AlibabaCloud
 				std::string projectEnv_;
 				std::string owner_;
 				std::string bizName_;
+				long dagId_;
 				int pageNumber_;
 				std::string nodeName_;
 				std::string programType_;

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

@@ -37,20 +37,29 @@ namespace AlibabaCloud
 					struct Instance
 					{
 						std::string status;
+						long baselineId;
 						long modifyTime;
 						long instanceId;
 						std::string dagType;
 						std::string nodeName;
+						int priority;
+						int dqcType;
 						long createTime;
 						std::string paramValues;
+						std::string connection;
+						long relatedFlowId;
 						long cycTime;
 						long beginWaitTimeTime;
 						int dagId;
 						long bizdate;
 						long beginRunningTime;
+						bool repeatability;
 						long finishTime;
+						std::string dqcDescription;
 						int nodeId;
 						long beginWaitResTime;
+						std::string errorMessage;
+						long repeatInterval;
 					};
 					std::vector<Instance> instances;
 					int totalCount;

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

@@ -35,6 +35,7 @@ namespace AlibabaCloud
 				struct DataItem
 				{
 					std::string tableName;
+					long nodeId;
 					std::string data;
 				};
 

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

@@ -36,17 +36,24 @@ namespace AlibabaCloud
 				{
 					struct NodesItem
 					{
-						bool repeatability;
+						long baselineId;
 						std::string description;
 						std::string resGroupName;
-						std::string ownerId;
 						std::string nodeName;
+						int priority;
+						int dqcType;
 						std::string paramValues;
-						long nodeId;
 						long projectId;
+						std::string connection;
 						std::string schedulerType;
-						std::string programType;
+						long relatedFlowId;
 						std::string cronExpress;
+						bool repeatability;
+						std::string ownerId;
+						std::string dqcDescription;
+						long nodeId;
+						std::string programType;
+						long repeatInterval;
 					};
 					int totalCount;
 					int pageSize;

dataworks-public/include/alibabacloud/dataworks-public/model/RunTriggerNodeRequest.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_RUNTRIGGERNODEREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_RUNTRIGGERNODEREQUEST_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 RunTriggerNodeRequest : public RpcServiceRequest
+			{
+
+			public:
+				RunTriggerNodeRequest();
+				~RunTriggerNodeRequest();
+
+				long getBizDate()const;
+				void setBizDate(long bizDate);
+				long getAppId()const;
+				void setAppId(long appId);
+				long getCycleTime()const;
+				void setCycleTime(long cycleTime);
+				long getNodeId()const;
+				void setNodeId(long nodeId);
+
+            private:
+				long bizDate_;
+				long appId_;
+				long cycleTime_;
+				long nodeId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_RUNTRIGGERNODEREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/RunTriggerNodeResult.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_RUNTRIGGERNODERESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_RUNTRIGGERNODERESULT_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 RunTriggerNodeResult : public ServiceResult
+			{
+			public:
+
+
+				RunTriggerNodeResult();
+				explicit RunTriggerNodeResult(const std::string &payload);
+				~RunTriggerNodeResult();
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_RUNTRIGGERNODERESULT_H_

dataworks-public/include/alibabacloud/dataworks-public/model/SearchNodesByOutputRequest.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_SEARCHNODESBYOUTPUTREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_SEARCHNODESBYOUTPUTREQUEST_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 SearchNodesByOutputRequest : public RpcServiceRequest
+			{
+
+			public:
+				SearchNodesByOutputRequest();
+				~SearchNodesByOutputRequest();
+
+				std::string getProjectEnv()const;
+				void setProjectEnv(const std::string& projectEnv);
+				std::string getOutputs()const;
+				void setOutputs(const std::string& outputs);
+
+            private:
+				std::string projectEnv_;
+				std::string outputs_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_SEARCHNODESBYOUTPUTREQUEST_H_

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

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_SEARCHNODESBYOUTPUTRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_SEARCHNODESBYOUTPUTRESULT_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 SearchNodesByOutputResult : public ServiceResult
+			{
+			public:
+
+
+				SearchNodesByOutputResult();
+				explicit SearchNodesByOutputResult(const std::string &payload);
+				~SearchNodesByOutputResult();
+				int getHttpStatusCode()const;
+				std::string getData()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int httpStatusCode_;
+				std::string data_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_SEARCHNODESBYOUTPUTRESULT_H_

dataworks-public/src/Dataworks-publicClient.cc

@@ -555,6 +555,42 @@ Dataworks_publicClient::CreateFolderOutcomeCallable Dataworks_publicClient::crea
 	return task->get_future();
 }
 
+Dataworks_publicClient::CreateManualDagOutcome Dataworks_publicClient::createManualDag(const CreateManualDagRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateManualDagOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateManualDagOutcome(CreateManualDagResult(outcome.result()));
+	else
+		return CreateManualDagOutcome(outcome.error());
+}
+
+void Dataworks_publicClient::createManualDagAsync(const CreateManualDagRequest& request, const CreateManualDagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createManualDag(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dataworks_publicClient::CreateManualDagOutcomeCallable Dataworks_publicClient::createManualDagCallable(const CreateManualDagRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateManualDagOutcome()>>(
+			[this, request]()
+			{
+			return this->createManualDag(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dataworks_publicClient::CreateMetaCategoryOutcome Dataworks_publicClient::createMetaCategory(const CreateMetaCategoryRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1815,6 +1851,42 @@ Dataworks_publicClient::GetDDLJobStatusOutcomeCallable Dataworks_publicClient::g
 	return task->get_future();
 }
 
+Dataworks_publicClient::GetDagOutcome Dataworks_publicClient::getDag(const GetDagRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetDagOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetDagOutcome(GetDagResult(outcome.result()));
+	else
+		return GetDagOutcome(outcome.error());
+}
+
+void Dataworks_publicClient::getDagAsync(const GetDagRequest& request, const GetDagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getDag(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dataworks_publicClient::GetDagOutcomeCallable Dataworks_publicClient::getDagCallable(const GetDagRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetDagOutcome()>>(
+			[this, request]()
+			{
+			return this->getDag(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dataworks_publicClient::GetDataServiceApiOutcome Dataworks_publicClient::getDataServiceApi(const GetDataServiceApiRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2355,6 +2427,42 @@ Dataworks_publicClient::GetInstanceStatusCountOutcomeCallable Dataworks_publicCl
 	return task->get_future();
 }
 
+Dataworks_publicClient::GetManualDagInstancesOutcome Dataworks_publicClient::getManualDagInstances(const GetManualDagInstancesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetManualDagInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetManualDagInstancesOutcome(GetManualDagInstancesResult(outcome.result()));
+	else
+		return GetManualDagInstancesOutcome(outcome.error());
+}
+
+void Dataworks_publicClient::getManualDagInstancesAsync(const GetManualDagInstancesRequest& request, const GetManualDagInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getManualDagInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dataworks_publicClient::GetManualDagInstancesOutcomeCallable Dataworks_publicClient::getManualDagInstancesCallable(const GetManualDagInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetManualDagInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->getManualDagInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dataworks_publicClient::GetMetaCategoryOutcome Dataworks_publicClient::getMetaCategory(const GetMetaCategoryRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4551,6 +4659,42 @@ Dataworks_publicClient::ResumeInstanceOutcomeCallable Dataworks_publicClient::re
 	return task->get_future();
 }
 
+Dataworks_publicClient::RunTriggerNodeOutcome Dataworks_publicClient::runTriggerNode(const RunTriggerNodeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RunTriggerNodeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RunTriggerNodeOutcome(RunTriggerNodeResult(outcome.result()));
+	else
+		return RunTriggerNodeOutcome(outcome.error());
+}
+
+void Dataworks_publicClient::runTriggerNodeAsync(const RunTriggerNodeRequest& request, const RunTriggerNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, runTriggerNode(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dataworks_publicClient::RunTriggerNodeOutcomeCallable Dataworks_publicClient::runTriggerNodeCallable(const RunTriggerNodeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RunTriggerNodeOutcome()>>(
+			[this, request]()
+			{
+			return this->runTriggerNode(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dataworks_publicClient::SearchMetaTablesOutcome Dataworks_publicClient::searchMetaTables(const SearchMetaTablesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4587,6 +4731,42 @@ Dataworks_publicClient::SearchMetaTablesOutcomeCallable Dataworks_publicClient::
 	return task->get_future();
 }
 
+Dataworks_publicClient::SearchNodesByOutputOutcome Dataworks_publicClient::searchNodesByOutput(const SearchNodesByOutputRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SearchNodesByOutputOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SearchNodesByOutputOutcome(SearchNodesByOutputResult(outcome.result()));
+	else
+		return SearchNodesByOutputOutcome(outcome.error());
+}
+
+void Dataworks_publicClient::searchNodesByOutputAsync(const SearchNodesByOutputRequest& request, const SearchNodesByOutputAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, searchNodesByOutput(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dataworks_publicClient::SearchNodesByOutputOutcomeCallable Dataworks_publicClient::searchNodesByOutputCallable(const SearchNodesByOutputRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SearchNodesByOutputOutcome()>>(
+			[this, request]()
+			{
+			return this->searchNodesByOutput(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dataworks_publicClient::SetSuccessInstanceOutcome Dataworks_publicClient::setSuccessInstance(const SetSuccessInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

dataworks-public/src/model/CreateManualDagRequest.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/CreateManualDagRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::CreateManualDagRequest;
+
+CreateManualDagRequest::CreateManualDagRequest() :
+	RpcServiceRequest("dataworks-public", "2020-05-18", "CreateManualDag")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateManualDagRequest::~CreateManualDagRequest()
+{}
+
+std::string CreateManualDagRequest::getProjectEnv()const
+{
+	return projectEnv_;
+}
+
+void CreateManualDagRequest::setProjectEnv(const std::string& projectEnv)
+{
+	projectEnv_ = projectEnv;
+	setBodyParameter("ProjectEnv", projectEnv);
+}
+
+std::string CreateManualDagRequest::getProjectName()const
+{
+	return projectName_;
+}
+
+void CreateManualDagRequest::setProjectName(const std::string& projectName)
+{
+	projectName_ = projectName;
+	setBodyParameter("ProjectName", projectName);
+}
+
+std::string CreateManualDagRequest::getBizDate()const
+{
+	return bizDate_;
+}
+
+void CreateManualDagRequest::setBizDate(const std::string& bizDate)
+{
+	bizDate_ = bizDate;
+	setBodyParameter("BizDate", bizDate);
+}
+
+std::string CreateManualDagRequest::getFlowName()const
+{
+	return flowName_;
+}
+
+void CreateManualDagRequest::setFlowName(const std::string& flowName)
+{
+	flowName_ = flowName;
+	setBodyParameter("FlowName", flowName);
+}
+
+std::string CreateManualDagRequest::getDagParameters()const
+{
+	return dagParameters_;
+}
+
+void CreateManualDagRequest::setDagParameters(const std::string& dagParameters)
+{
+	dagParameters_ = dagParameters;
+	setBodyParameter("DagParameters", dagParameters);
+}
+
+std::string CreateManualDagRequest::getNodeParameters()const
+{
+	return nodeParameters_;
+}
+
+void CreateManualDagRequest::setNodeParameters(const std::string& nodeParameters)
+{
+	nodeParameters_ = nodeParameters;
+	setBodyParameter("NodeParameters", nodeParameters);
+}
+

dataworks-public/src/model/CreateManualDagResult.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/CreateManualDagResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dataworks_public;
+using namespace AlibabaCloud::Dataworks_public::Model;
+
+CreateManualDagResult::CreateManualDagResult() :
+	ServiceResult()
+{}
+
+CreateManualDagResult::CreateManualDagResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateManualDagResult::~CreateManualDagResult()
+{}
+
+void CreateManualDagResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["DagId"].isNull())
+		dagId_ = std::stol(value["DagId"].asString());
+
+}
+
+long CreateManualDagResult::getDagId()const
+{
+	return dagId_;
+}
+

dataworks-public/src/model/CreateTableRequest.cc

@@ -187,6 +187,17 @@ void CreateTableRequest::setLocation(const std::string& location)
 	setParameter("Location", location);
 }
 
+std::string CreateTableRequest::getComment()const
+{
+	return comment_;
+}
+
+void CreateTableRequest::setComment(const std::string& comment)
+{
+	comment_ = comment;
+	setParameter("Comment", comment);
+}
+
 std::string CreateTableRequest::getTableName()const
 {
 	return tableName_;

dataworks-public/src/model/GetBaselineKeyPathResult.cc

@@ -59,56 +59,56 @@ void GetBaselineKeyPathResult::parse(const std::string &payload)
 			dataObject.owner = valueDataDataItem["Owner"].asString();
 		if(!valueDataDataItem["PrgType"].isNull())
 			dataObject.prgType = std::stoi(valueDataDataItem["PrgType"].asString());
-		auto allRunsNode = allDataNode["Runs"]["RunsItem"];
-		for (auto allDataNodeRunsRunsItem : allRunsNode)
+		auto allRunsNode = valueDataDataItem["Runs"]["RunsItem"];
+		for (auto valueDataDataItemRunsRunsItem : allRunsNode)
 		{
 			DataItem::RunsItem runsObject;
-			if(!allDataNodeRunsRunsItem["AbsTime"].isNull())
-				runsObject.absTime = std::stol(allDataNodeRunsRunsItem["AbsTime"].asString());
-			if(!allDataNodeRunsRunsItem["BeginCast"].isNull())
-				runsObject.beginCast = std::stol(allDataNodeRunsRunsItem["BeginCast"].asString());
-			if(!allDataNodeRunsRunsItem["BeginRunningTime"].isNull())
-				runsObject.beginRunningTime = std::stol(allDataNodeRunsRunsItem["BeginRunningTime"].asString());
-			if(!allDataNodeRunsRunsItem["BeginWaitResTime"].isNull())
-				runsObject.beginWaitResTime = std::stol(allDataNodeRunsRunsItem["BeginWaitResTime"].asString());
-			if(!allDataNodeRunsRunsItem["BeginWaitTimeTime"].isNull())
-				runsObject.beginWaitTimeTime = std::stol(allDataNodeRunsRunsItem["BeginWaitTimeTime"].asString());
-			if(!allDataNodeRunsRunsItem["Bizdate"].isNull())
-				runsObject.bizdate = std::stol(allDataNodeRunsRunsItem["Bizdate"].asString());
-			if(!allDataNodeRunsRunsItem["CycTime"].isNull())
-				runsObject.cycTime = std::stol(allDataNodeRunsRunsItem["CycTime"].asString());
-			if(!allDataNodeRunsRunsItem["EndCast"].isNull())
-				runsObject.endCast = std::stol(allDataNodeRunsRunsItem["EndCast"].asString());
-			if(!allDataNodeRunsRunsItem["FinishTime"].isNull())
-				runsObject.finishTime = std::stol(allDataNodeRunsRunsItem["FinishTime"].asString());
-			if(!allDataNodeRunsRunsItem["InGroupId"].isNull())
-				runsObject.inGroupId = std::stoi(allDataNodeRunsRunsItem["InGroupId"].asString());
-			if(!allDataNodeRunsRunsItem["InstanceId"].isNull())
-				runsObject.instanceId = std::stol(allDataNodeRunsRunsItem["InstanceId"].asString());
-			if(!allDataNodeRunsRunsItem["NodeId"].isNull())
-				runsObject.nodeId = std::stol(allDataNodeRunsRunsItem["NodeId"].asString());
-			if(!allDataNodeRunsRunsItem["NodeName"].isNull())
-				runsObject.nodeName = allDataNodeRunsRunsItem["NodeName"].asString();
-			if(!allDataNodeRunsRunsItem["Owner"].isNull())
-				runsObject.owner = allDataNodeRunsRunsItem["Owner"].asString();
-			if(!allDataNodeRunsRunsItem["ProjectId"].isNull())
-				runsObject.projectId = std::stol(allDataNodeRunsRunsItem["ProjectId"].asString());
-			if(!allDataNodeRunsRunsItem["Status"].isNull())
-				runsObject.status = allDataNodeRunsRunsItem["Status"].asString();
+			if(!valueDataDataItemRunsRunsItem["AbsTime"].isNull())
+				runsObject.absTime = std::stol(valueDataDataItemRunsRunsItem["AbsTime"].asString());
+			if(!valueDataDataItemRunsRunsItem["BeginCast"].isNull())
+				runsObject.beginCast = std::stol(valueDataDataItemRunsRunsItem["BeginCast"].asString());
+			if(!valueDataDataItemRunsRunsItem["BeginRunningTime"].isNull())
+				runsObject.beginRunningTime = std::stol(valueDataDataItemRunsRunsItem["BeginRunningTime"].asString());
+			if(!valueDataDataItemRunsRunsItem["BeginWaitResTime"].isNull())
+				runsObject.beginWaitResTime = std::stol(valueDataDataItemRunsRunsItem["BeginWaitResTime"].asString());
+			if(!valueDataDataItemRunsRunsItem["BeginWaitTimeTime"].isNull())
+				runsObject.beginWaitTimeTime = std::stol(valueDataDataItemRunsRunsItem["BeginWaitTimeTime"].asString());
+			if(!valueDataDataItemRunsRunsItem["Bizdate"].isNull())
+				runsObject.bizdate = std::stol(valueDataDataItemRunsRunsItem["Bizdate"].asString());
+			if(!valueDataDataItemRunsRunsItem["CycTime"].isNull())
+				runsObject.cycTime = std::stol(valueDataDataItemRunsRunsItem["CycTime"].asString());
+			if(!valueDataDataItemRunsRunsItem["EndCast"].isNull())
+				runsObject.endCast = std::stol(valueDataDataItemRunsRunsItem["EndCast"].asString());
+			if(!valueDataDataItemRunsRunsItem["FinishTime"].isNull())
+				runsObject.finishTime = std::stol(valueDataDataItemRunsRunsItem["FinishTime"].asString());
+			if(!valueDataDataItemRunsRunsItem["InGroupId"].isNull())
+				runsObject.inGroupId = std::stoi(valueDataDataItemRunsRunsItem["InGroupId"].asString());
+			if(!valueDataDataItemRunsRunsItem["InstanceId"].isNull())
+				runsObject.instanceId = std::stol(valueDataDataItemRunsRunsItem["InstanceId"].asString());
+			if(!valueDataDataItemRunsRunsItem["NodeId"].isNull())
+				runsObject.nodeId = std::stol(valueDataDataItemRunsRunsItem["NodeId"].asString());
+			if(!valueDataDataItemRunsRunsItem["NodeName"].isNull())
+				runsObject.nodeName = valueDataDataItemRunsRunsItem["NodeName"].asString();
+			if(!valueDataDataItemRunsRunsItem["Owner"].isNull())
+				runsObject.owner = valueDataDataItemRunsRunsItem["Owner"].asString();
+			if(!valueDataDataItemRunsRunsItem["ProjectId"].isNull())
+				runsObject.projectId = std::stol(valueDataDataItemRunsRunsItem["ProjectId"].asString());
+			if(!valueDataDataItemRunsRunsItem["Status"].isNull())
+				runsObject.status = valueDataDataItemRunsRunsItem["Status"].asString();
 			dataObject.runs.push_back(runsObject);
 		}
-		auto allTopicsNode = allDataNode["Topics"]["TopicsItem"];
-		for (auto allDataNodeTopicsTopicsItem : allTopicsNode)
+		auto allTopicsNode = valueDataDataItem["Topics"]["TopicsItem"];
+		for (auto valueDataDataItemTopicsTopicsItem : allTopicsNode)
 		{
 			DataItem::TopicsItem topicsObject;
-			if(!allDataNodeTopicsTopicsItem["InstanceId"].isNull())
-				topicsObject.instanceId = std::stol(allDataNodeTopicsTopicsItem["InstanceId"].asString());
-			if(!allDataNodeTopicsTopicsItem["TopicId"].isNull())
-				topicsObject.topicId = std::stol(allDataNodeTopicsTopicsItem["TopicId"].asString());
-			if(!allDataNodeTopicsTopicsItem["TopicName"].isNull())
-				topicsObject.topicName = std::stol(allDataNodeTopicsTopicsItem["TopicName"].asString());
-			if(!allDataNodeTopicsTopicsItem["AddTime"].isNull())
-				topicsObject.addTime = std::stol(allDataNodeTopicsTopicsItem["AddTime"].asString());
+			if(!valueDataDataItemTopicsTopicsItem["InstanceId"].isNull())
+				topicsObject.instanceId = std::stol(valueDataDataItemTopicsTopicsItem["InstanceId"].asString());
+			if(!valueDataDataItemTopicsTopicsItem["TopicId"].isNull())
+				topicsObject.topicId = std::stol(valueDataDataItemTopicsTopicsItem["TopicId"].asString());
+			if(!valueDataDataItemTopicsTopicsItem["TopicName"].isNull())
+				topicsObject.topicName = std::stol(valueDataDataItemTopicsTopicsItem["TopicName"].asString());
+			if(!valueDataDataItemTopicsTopicsItem["AddTime"].isNull())
+				topicsObject.addTime = std::stol(valueDataDataItemTopicsTopicsItem["AddTime"].asString());
 			dataObject.topics.push_back(topicsObject);
 		}
 		data_.push_back(dataObject);

dataworks-public/src/model/GetDagRequest.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/GetDagRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::GetDagRequest;
+
+GetDagRequest::GetDagRequest() :
+	RpcServiceRequest("dataworks-public", "2020-05-18", "GetDag")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetDagRequest::~GetDagRequest()
+{}
+
+std::string GetDagRequest::getProjectEnv()const
+{
+	return projectEnv_;
+}
+
+void GetDagRequest::setProjectEnv(const std::string& projectEnv)
+{
+	projectEnv_ = projectEnv;
+	setBodyParameter("ProjectEnv", projectEnv);
+}
+
+long GetDagRequest::getDagId()const
+{
+	return dagId_;
+}
+
+void GetDagRequest::setDagId(long dagId)
+{
+	dagId_ = dagId;
+	setBodyParameter("DagId", std::to_string(dagId));
+}
+

dataworks-public/src/model/GetDagResult.cc

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

dataworks-public/src/model/GetInstanceResult.cc

@@ -70,6 +70,24 @@ void GetInstanceResult::parse(const std::string &payload)
 		data_.modifyTime = std::stol(dataNode["ModifyTime"].asString());
 	if(!dataNode["NodeName"].isNull())
 		data_.nodeName = dataNode["NodeName"].asString();
+	if(!dataNode["Priority"].isNull())
+		data_.priority = std::stoi(dataNode["Priority"].asString());
+	if(!dataNode["BaselineId"].isNull())
+		data_.baselineId = std::stol(dataNode["BaselineId"].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["RelatedFlowId"].isNull())
+		data_.relatedFlowId = std::stol(dataNode["RelatedFlowId"].asString());
 	if(!value["ErrorCode"].isNull())
 		errorCode_ = value["ErrorCode"].asString();
 	if(!value["ErrorMessage"].isNull())

dataworks-public/src/model/GetManualDagInstancesRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dataworks-public/model/GetManualDagInstancesRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::GetManualDagInstancesRequest;
+
+GetManualDagInstancesRequest::GetManualDagInstancesRequest() :
+	RpcServiceRequest("dataworks-public", "2020-05-18", "GetManualDagInstances")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetManualDagInstancesRequest::~GetManualDagInstancesRequest()
+{}
+
+std::string GetManualDagInstancesRequest::getProjectEnv()const
+{
+	return projectEnv_;
+}
+
+void GetManualDagInstancesRequest::setProjectEnv(const std::string& projectEnv)
+{
+	projectEnv_ = projectEnv;
+	setBodyParameter("ProjectEnv", projectEnv);
+}
+
+std::string GetManualDagInstancesRequest::getProjectName()const
+{
+	return projectName_;
+}
+
+void GetManualDagInstancesRequest::setProjectName(const std::string& projectName)
+{
+	projectName_ = projectName;
+	setBodyParameter("ProjectName", projectName);
+}
+
+std::string GetManualDagInstancesRequest::getDagId()const
+{
+	return dagId_;
+}
+
+void GetManualDagInstancesRequest::setDagId(const std::string& dagId)
+{
+	dagId_ = dagId;
+	setBodyParameter("DagId", dagId);
+}
+

dataworks-public/src/model/GetManualDagInstancesResult.cc

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/GetManualDagInstancesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dataworks_public;
+using namespace AlibabaCloud::Dataworks_public::Model;
+
+GetManualDagInstancesResult::GetManualDagInstancesResult() :
+	ServiceResult()
+{}
+
+GetManualDagInstancesResult::GetManualDagInstancesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetManualDagInstancesResult::~GetManualDagInstancesResult()
+{}
+
+void GetManualDagInstancesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allInstancesNode = value["Instances"]["InstancesItem"];
+	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["BizDate"].isNull())
+			instancesObject.bizDate = std::stol(valueInstancesInstancesItem["BizDate"].asString());
+		if(!valueInstancesInstancesItem["CycTime"].isNull())
+			instancesObject.cycTime = std::stol(valueInstancesInstancesItem["CycTime"].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["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());
+		instances_.push_back(instancesObject);
+	}
+
+}
+
+std::vector<GetManualDagInstancesResult::InstancesItem> GetManualDagInstancesResult::getInstances()const
+{
+	return instances_;
+}
+

dataworks-public/src/model/GetNodeResult.cc

@@ -62,6 +62,20 @@ void GetNodeResult::parse(const std::string &payload)
 		data_.schedulerType = dataNode["SchedulerType"].asString();
 	if(!dataNode["ParamValues"].isNull())
 		data_.paramValues = dataNode["ParamValues"].asString();
+	if(!dataNode["Priority"].isNull())
+		data_.priority = std::stoi(dataNode["Priority"].asString());
+	if(!dataNode["BaselineId"].isNull())
+		data_.baselineId = std::stol(dataNode["BaselineId"].asString());
+	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["RelatedFlowId"].isNull())
+		data_.relatedFlowId = std::stol(dataNode["RelatedFlowId"].asString());
 	if(!value["Success"].isNull())
 		success_ = value["Success"].asString() == "true";
 	if(!value["ErrorCode"].isNull())

dataworks-public/src/model/ListAlertMessagesResult.cc

@@ -68,52 +68,52 @@ void ListAlertMessagesResult::parse(const std::string &payload)
 			alertMessagesItemObject.alertMessageStatus = dataNodeAlertMessagesAlertMessagesItem["AlertMessageStatus"].asString();
 		if(!dataNodeAlertMessagesAlertMessagesItem["Content"].isNull())
 			alertMessagesItemObject.content = dataNodeAlertMessagesAlertMessagesItem["Content"].asString();
-		auto allInstancesNode = allAlertMessagesNode["Instances"]["InstancesItem"];
-		for (auto allAlertMessagesNodeInstancesInstancesItem : allInstancesNode)
+		auto allInstancesNode = dataNodeAlertMessagesAlertMessagesItem["Instances"]["InstancesItem"];
+		for (auto dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem : allInstancesNode)
 		{
 			Data::AlertMessagesItem::InstancesItem instancesObject;
-			if(!allAlertMessagesNodeInstancesInstancesItem["NodeId"].isNull())
-				instancesObject.nodeId = std::stol(allAlertMessagesNodeInstancesInstancesItem["NodeId"].asString());
-			if(!allAlertMessagesNodeInstancesInstancesItem["NodeName"].isNull())
-				instancesObject.nodeName = allAlertMessagesNodeInstancesInstancesItem["NodeName"].asString();
-			if(!allAlertMessagesNodeInstancesInstancesItem["ProjectId"].isNull())
-				instancesObject.projectId = std::stol(allAlertMessagesNodeInstancesInstancesItem["ProjectId"].asString());
-			if(!allAlertMessagesNodeInstancesInstancesItem["Status"].isNull())
-				instancesObject.status = allAlertMessagesNodeInstancesInstancesItem["Status"].asString();
-			if(!allAlertMessagesNodeInstancesInstancesItem["InstanceId"].isNull())
-				instancesObject.instanceId = std::stol(allAlertMessagesNodeInstancesInstancesItem["InstanceId"].asString());
+			if(!dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["NodeId"].isNull())
+				instancesObject.nodeId = std::stol(dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["NodeId"].asString());
+			if(!dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["NodeName"].isNull())
+				instancesObject.nodeName = dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["NodeName"].asString();
+			if(!dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["ProjectId"].isNull())
+				instancesObject.projectId = std::stol(dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["ProjectId"].asString());
+			if(!dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["Status"].isNull())
+				instancesObject.status = dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["Status"].asString();
+			if(!dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["InstanceId"].isNull())
+				instancesObject.instanceId = std::stol(dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["InstanceId"].asString());
 			alertMessagesItemObject.instances.push_back(instancesObject);
 		}
-		auto allTopicsNode = allAlertMessagesNode["Topics"]["TopicsItem"];
-		for (auto allAlertMessagesNodeTopicsTopicsItem : allTopicsNode)
+		auto allTopicsNode = dataNodeAlertMessagesAlertMessagesItem["Topics"]["TopicsItem"];
+		for (auto dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem : allTopicsNode)
 		{
 			Data::AlertMessagesItem::TopicsItem topicsObject;
-			if(!allAlertMessagesNodeTopicsTopicsItem["NodeId"].isNull())
-				topicsObject.nodeId = std::stol(allAlertMessagesNodeTopicsTopicsItem["NodeId"].asString());
-			if(!allAlertMessagesNodeTopicsTopicsItem["InstanceId"].isNull())
-				topicsObject.instanceId = std::stol(allAlertMessagesNodeTopicsTopicsItem["InstanceId"].asString());
-			if(!allAlertMessagesNodeTopicsTopicsItem["TopicId"].isNull())
-				topicsObject.topicId = std::stol(allAlertMessagesNodeTopicsTopicsItem["TopicId"].asString());
-			if(!allAlertMessagesNodeTopicsTopicsItem["TopicName"].isNull())
-				topicsObject.topicName = allAlertMessagesNodeTopicsTopicsItem["TopicName"].asString();
-			if(!allAlertMessagesNodeTopicsTopicsItem["TopicOwner"].isNull())
-				topicsObject.topicOwner = allAlertMessagesNodeTopicsTopicsItem["TopicOwner"].asString();
-			if(!allAlertMessagesNodeTopicsTopicsItem["TopicStatus"].isNull())
-				topicsObject.topicStatus = allAlertMessagesNodeTopicsTopicsItem["TopicStatus"].asString();
+			if(!dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["NodeId"].isNull())
+				topicsObject.nodeId = std::stol(dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["NodeId"].asString());
+			if(!dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["InstanceId"].isNull())
+				topicsObject.instanceId = std::stol(dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["InstanceId"].asString());
+			if(!dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicId"].isNull())
+				topicsObject.topicId = std::stol(dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicId"].asString());
+			if(!dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicName"].isNull())
+				topicsObject.topicName = dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicName"].asString();
+			if(!dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicOwner"].isNull())
+				topicsObject.topicOwner = dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicOwner"].asString();
+			if(!dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicStatus"].isNull())
+				topicsObject.topicStatus = dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicStatus"].asString();
 			alertMessagesItemObject.topics.push_back(topicsObject);
 		}
-		auto allNodesNode = allAlertMessagesNode["Nodes"]["NodesItem"];
-		for (auto allAlertMessagesNodeNodesNodesItem : allNodesNode)
+		auto allNodesNode = dataNodeAlertMessagesAlertMessagesItem["Nodes"]["NodesItem"];
+		for (auto dataNodeAlertMessagesAlertMessagesItemNodesNodesItem : allNodesNode)
 		{
 			Data::AlertMessagesItem::NodesItem nodesObject;
-			if(!allAlertMessagesNodeNodesNodesItem["NodeId"].isNull())
-				nodesObject.nodeId = std::stol(allAlertMessagesNodeNodesNodesItem["NodeId"].asString());
-			if(!allAlertMessagesNodeNodesNodesItem["NodeName"].isNull())
-				nodesObject.nodeName = allAlertMessagesNodeNodesNodesItem["NodeName"].asString();
-			if(!allAlertMessagesNodeNodesNodesItem["Owner"].isNull())
-				nodesObject.owner = allAlertMessagesNodeNodesNodesItem["Owner"].asString();
-			if(!allAlertMessagesNodeNodesNodesItem["ProjectId"].isNull())
-				nodesObject.projectId = std::stol(allAlertMessagesNodeNodesNodesItem["ProjectId"].asString());
+			if(!dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["NodeId"].isNull())
+				nodesObject.nodeId = std::stol(dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["NodeId"].asString());
+			if(!dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["NodeName"].isNull())
+				nodesObject.nodeName = dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["NodeName"].asString();
+			if(!dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["Owner"].isNull())
+				nodesObject.owner = dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["Owner"].asString();
+			if(!dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["ProjectId"].isNull())
+				nodesObject.projectId = std::stol(dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["ProjectId"].asString());
 			alertMessagesItemObject.nodes.push_back(nodesObject);
 		}
 		auto slaAlertNode = value["SlaAlert"];

dataworks-public/src/model/ListDataServiceApiAuthoritiesResult.cc

@@ -70,18 +70,18 @@ void ListDataServiceApiAuthoritiesResult::parse(const std::string &payload)
 			apiAuthorizationObject.projectId = std::stol(dataNodeApiAuthorizationListApiAuthorization["ProjectId"].asString());
 		if(!dataNodeApiAuthorizationListApiAuthorization["TenantId"].isNull())
 			apiAuthorizationObject.tenantId = std::stol(dataNodeApiAuthorizationListApiAuthorization["TenantId"].asString());
-		auto allAuthorizationRecordsNode = allApiAuthorizationListNode["AuthorizationRecords"]["AuthorizationRecord"];
-		for (auto allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord : allAuthorizationRecordsNode)
+		auto allAuthorizationRecordsNode = dataNodeApiAuthorizationListApiAuthorization["AuthorizationRecords"]["AuthorizationRecord"];
+		for (auto dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord : allAuthorizationRecordsNode)
 		{
 			Data::ApiAuthorization::AuthorizationRecord authorizationRecordsObject;
-			if(!allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["CreatedTime"].isNull())
-				authorizationRecordsObject.createdTime = allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["CreatedTime"].asString();
-			if(!allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["CreatorId"].isNull())
-				authorizationRecordsObject.creatorId = allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["CreatorId"].asString();
-			if(!allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["EndTime"].isNull())
-				authorizationRecordsObject.endTime = allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["EndTime"].asString();
-			if(!allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["ProjectId"].isNull())
-				authorizationRecordsObject.projectId = std::stol(allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["ProjectId"].asString());
+			if(!dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["CreatedTime"].isNull())
+				authorizationRecordsObject.createdTime = dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["CreatedTime"].asString();
+			if(!dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["CreatorId"].isNull())
+				authorizationRecordsObject.creatorId = dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["CreatorId"].asString();
+			if(!dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["EndTime"].isNull())
+				authorizationRecordsObject.endTime = dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["EndTime"].asString();
+			if(!dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["ProjectId"].isNull())
+				authorizationRecordsObject.projectId = std::stol(dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["ProjectId"].asString());
 			apiAuthorizationObject.authorizationRecords.push_back(authorizationRecordsObject);
 		}
 		data_.apiAuthorizationList.push_back(apiAuthorizationObject);

dataworks-public/src/model/ListInstancesRequest.cc

@@ -60,6 +60,17 @@ void ListInstancesRequest::setBizName(const std::string& bizName)
 	setBodyParameter("BizName", bizName);
 }
 
+long ListInstancesRequest::getDagId()const
+{
+	return dagId_;
+}
+
+void ListInstancesRequest::setDagId(long dagId)
+{
+	dagId_ = dagId;
+	setBodyParameter("DagId", std::to_string(dagId));
+}
+
 int ListInstancesRequest::getPageNumber()const
 {
 	return pageNumber_;

dataworks-public/src/model/ListInstancesResult.cc

@@ -80,6 +80,24 @@ void ListInstancesResult::parse(const std::string &payload)
 			instanceObject.paramValues = dataNodeInstancesInstance["ParamValues"].asString();
 		if(!dataNodeInstancesInstance["FinishTime"].isNull())
 			instanceObject.finishTime = std::stol(dataNodeInstancesInstance["FinishTime"].asString());
+		if(!dataNodeInstancesInstance["Priority"].isNull())
+			instanceObject.priority = std::stoi(dataNodeInstancesInstance["Priority"].asString());
+		if(!dataNodeInstancesInstance["BaselineId"].isNull())
+			instanceObject.baselineId = std::stol(dataNodeInstancesInstance["BaselineId"].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["RelatedFlowId"].isNull())
+			instanceObject.relatedFlowId = std::stol(dataNodeInstancesInstance["RelatedFlowId"].asString());
 		data_.instances.push_back(instanceObject);
 	}
 	if(!value["Success"].isNull())

dataworks-public/src/model/ListNodeIOResult.cc

@@ -47,6 +47,8 @@ void ListNodeIOResult::parse(const std::string &payload)
 			dataObject.tableName = valueDataDataItem["TableName"].asString();
 		if(!valueDataDataItem["Data"].isNull())
 			dataObject.data = valueDataDataItem["Data"].asString();
+		if(!valueDataDataItem["NodeId"].isNull())
+			dataObject.nodeId = std::stol(valueDataDataItem["NodeId"].asString());
 		data_.push_back(dataObject);
 	}
 	if(!value["Success"].isNull())

dataworks-public/src/model/ListNodesResult.cc

@@ -72,6 +72,20 @@ void ListNodesResult::parse(const std::string &payload)
 			nodesItemObject.description = dataNodeNodesNodesItem["Description"].asString();
 		if(!dataNodeNodesNodesItem["ResGroupName"].isNull())
 			nodesItemObject.resGroupName = dataNodeNodesNodesItem["ResGroupName"].asString();
+		if(!dataNodeNodesNodesItem["Priority"].isNull())
+			nodesItemObject.priority = std::stoi(dataNodeNodesNodesItem["Priority"].asString());
+		if(!dataNodeNodesNodesItem["BaselineId"].isNull())
+			nodesItemObject.baselineId = std::stol(dataNodeNodesNodesItem["BaselineId"].asString());
+		if(!dataNodeNodesNodesItem["RepeatInterval"].isNull())
+			nodesItemObject.repeatInterval = std::stol(dataNodeNodesNodesItem["RepeatInterval"].asString());
+		if(!dataNodeNodesNodesItem["Connection"].isNull())
+			nodesItemObject.connection = dataNodeNodesNodesItem["Connection"].asString();
+		if(!dataNodeNodesNodesItem["DqcType"].isNull())
+			nodesItemObject.dqcType = std::stoi(dataNodeNodesNodesItem["DqcType"].asString());
+		if(!dataNodeNodesNodesItem["DqcDescription"].isNull())
+			nodesItemObject.dqcDescription = dataNodeNodesNodesItem["DqcDescription"].asString();
+		if(!dataNodeNodesNodesItem["RelatedFlowId"].isNull())
+			nodesItemObject.relatedFlowId = std::stol(dataNodeNodesNodesItem["RelatedFlowId"].asString());
 		data_.nodes.push_back(nodesItemObject);
 	}
 	if(!value["Success"].isNull())

dataworks-public/src/model/ListProjectMembersResult.cc

@@ -60,18 +60,18 @@ void ListProjectMembersResult::parse(const std::string &payload)
 			projectMemberObject.projectMemberType = dataNodeProjectMemberListProjectMember["ProjectMemberType"].asString();
 		if(!dataNodeProjectMemberListProjectMember["Status"].isNull())
 			projectMemberObject.status = dataNodeProjectMemberListProjectMember["Status"].asString();
-		auto allProjectRoleListNode = allProjectMemberListNode["ProjectRoleList"]["Role"];
-		for (auto allProjectMemberListNodeProjectRoleListRole : allProjectRoleListNode)
+		auto allProjectRoleListNode = dataNodeProjectMemberListProjectMember["ProjectRoleList"]["Role"];
+		for (auto dataNodeProjectMemberListProjectMemberProjectRoleListRole : allProjectRoleListNode)
 		{
 			Data::ProjectMember::Role projectRoleListObject;
-			if(!allProjectMemberListNodeProjectRoleListRole["ProjectRoleCode"].isNull())
-				projectRoleListObject.projectRoleCode = allProjectMemberListNodeProjectRoleListRole["ProjectRoleCode"].asString();
-			if(!allProjectMemberListNodeProjectRoleListRole["ProjectRoleId"].isNull())
-				projectRoleListObject.projectRoleId = std::stoi(allProjectMemberListNodeProjectRoleListRole["ProjectRoleId"].asString());
-			if(!allProjectMemberListNodeProjectRoleListRole["ProjectRoleName"].isNull())
-				projectRoleListObject.projectRoleName = allProjectMemberListNodeProjectRoleListRole["ProjectRoleName"].asString();
-			if(!allProjectMemberListNodeProjectRoleListRole["ProjectRoleType"].isNull())
-				projectRoleListObject.projectRoleType = allProjectMemberListNodeProjectRoleListRole["ProjectRoleType"].asString();
+			if(!dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleCode"].isNull())
+				projectRoleListObject.projectRoleCode = dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleCode"].asString();
+			if(!dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleId"].isNull())
+				projectRoleListObject.projectRoleId = std::stoi(dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleId"].asString());
+			if(!dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleName"].isNull())
+				projectRoleListObject.projectRoleName = dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleName"].asString();
+			if(!dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleType"].isNull())
+				projectRoleListObject.projectRoleType = dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleType"].asString();
 			projectMemberObject.projectRoleList.push_back(projectRoleListObject);
 		}
 		data_.projectMemberList.push_back(projectMemberObject);

dataworks-public/src/model/ListQualityResultsByEntityResult.cc

@@ -128,32 +128,32 @@ void ListQualityResultsByEntityResult::parse(const std::string &payload)
 			ruleChecksItemObject.lowerValue = std::stof(qualityResultsNodeRuleChecksRuleChecksItem["LowerValue"].asString());
 		if(!qualityResultsNodeRuleChecksRuleChecksItem["CheckerName"].isNull())
 			ruleChecksItemObject.checkerName = qualityResultsNodeRuleChecksRuleChecksItem["CheckerName"].asString();
-		auto allReferenceValueNode = allRuleChecksNode["ReferenceValue"]["ReferenceValueItem"];
-		for (auto allRuleChecksNodeReferenceValueReferenceValueItem : allReferenceValueNode)
+		auto allReferenceValueNode = qualityResultsNodeRuleChecksRuleChecksItem["ReferenceValue"]["ReferenceValueItem"];
+		for (auto qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem : allReferenceValueNode)
 		{
 			QualityResults::RuleChecksItem::ReferenceValueItem referenceValueObject;
-			if(!allRuleChecksNodeReferenceValueReferenceValueItem["BizDate"].isNull())
-				referenceValueObject.bizDate = std::stol(allRuleChecksNodeReferenceValueReferenceValueItem["BizDate"].asString());
-			if(!allRuleChecksNodeReferenceValueReferenceValueItem["DiscreteProperty"].isNull())
-				referenceValueObject.discreteProperty = allRuleChecksNodeReferenceValueReferenceValueItem["DiscreteProperty"].asString();
-			if(!allRuleChecksNodeReferenceValueReferenceValueItem["Value"].isNull())
-				referenceValueObject.value = std::stof(allRuleChecksNodeReferenceValueReferenceValueItem["Value"].asString());
-			if(!allRuleChecksNodeReferenceValueReferenceValueItem["Threshold"].isNull())
-				referenceValueObject.threshold = std::stof(allRuleChecksNodeReferenceValueReferenceValueItem["Threshold"].asString());
-			if(!allRuleChecksNodeReferenceValueReferenceValueItem["SingleCheckResult"].isNull())
-				referenceValueObject.singleCheckResult = std::stoi(allRuleChecksNodeReferenceValueReferenceValueItem["SingleCheckResult"].asString());
+			if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].isNull())
+				referenceValueObject.bizDate = std::stol(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].asString());
+			if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].isNull())
+				referenceValueObject.discreteProperty = qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].asString();
+			if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].isNull())
+				referenceValueObject.value = std::stof(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].asString());
+			if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].isNull())
+				referenceValueObject.threshold = std::stof(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].asString());
+			if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].isNull())
+				referenceValueObject.singleCheckResult = std::stoi(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].asString());
 			ruleChecksItemObject.referenceValue.push_back(referenceValueObject);
 		}
-		auto allSampleValueNode = allRuleChecksNode["SampleValue"]["SampleValueItem"];
-		for (auto allRuleChecksNodeSampleValueSampleValueItem : allSampleValueNode)
+		auto allSampleValueNode = qualityResultsNodeRuleChecksRuleChecksItem["SampleValue"]["SampleValueItem"];
+		for (auto qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem : allSampleValueNode)
 		{
 			QualityResults::RuleChecksItem::SampleValueItem sampleValueObject;
-			if(!allRuleChecksNodeSampleValueSampleValueItem["BizDate"].isNull())
-				sampleValueObject.bizDate = std::stol(allRuleChecksNodeSampleValueSampleValueItem["BizDate"].asString());
-			if(!allRuleChecksNodeSampleValueSampleValueItem["DiscreteProperty"].isNull())
-				sampleValueObject.discreteProperty = allRuleChecksNodeSampleValueSampleValueItem["DiscreteProperty"].asString();
-			if(!allRuleChecksNodeSampleValueSampleValueItem["Value"].isNull())
-				sampleValueObject.value = std::stof(allRuleChecksNodeSampleValueSampleValueItem["Value"].asString());
+			if(!qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].isNull())
+				sampleValueObject.bizDate = std::stol(qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].asString());
+			if(!qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].isNull())
+				sampleValueObject.discreteProperty = qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].asString();
+			if(!qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].isNull())
+				sampleValueObject.value = std::stof(qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].asString());
 			ruleChecksItemObject.sampleValue.push_back(sampleValueObject);
 		}
 		qualityResults_.ruleChecks.push_back(ruleChecksItemObject);

dataworks-public/src/model/ListQualityResultsByRuleResult.cc

@@ -128,32 +128,32 @@ void ListQualityResultsByRuleResult::parse(const std::string &payload)
 			ruleChecksItemObject.lowerValue = std::stof(qualityResultsNodeRuleChecksRuleChecksItem["LowerValue"].asString());
 		if(!qualityResultsNodeRuleChecksRuleChecksItem["CheckerName"].isNull())
 			ruleChecksItemObject.checkerName = qualityResultsNodeRuleChecksRuleChecksItem["CheckerName"].asString();
-		auto allReferenceValueNode = allRuleChecksNode["ReferenceValue"]["ReferenceValueItem"];
-		for (auto allRuleChecksNodeReferenceValueReferenceValueItem : allReferenceValueNode)
+		auto allReferenceValueNode = qualityResultsNodeRuleChecksRuleChecksItem["ReferenceValue"]["ReferenceValueItem"];
+		for (auto qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem : allReferenceValueNode)
 		{
 			QualityResults::RuleChecksItem::ReferenceValueItem referenceValueObject;
-			if(!allRuleChecksNodeReferenceValueReferenceValueItem["BizDate"].isNull())
-				referenceValueObject.bizDate = std::stol(allRuleChecksNodeReferenceValueReferenceValueItem["BizDate"].asString());
-			if(!allRuleChecksNodeReferenceValueReferenceValueItem["DiscreteProperty"].isNull())
-				referenceValueObject.discreteProperty = allRuleChecksNodeReferenceValueReferenceValueItem["DiscreteProperty"].asString();
-			if(!allRuleChecksNodeReferenceValueReferenceValueItem["Value"].isNull())
-				referenceValueObject.value = std::stof(allRuleChecksNodeReferenceValueReferenceValueItem["Value"].asString());
-			if(!allRuleChecksNodeReferenceValueReferenceValueItem["Threshold"].isNull())
-				referenceValueObject.threshold = std::stof(allRuleChecksNodeReferenceValueReferenceValueItem["Threshold"].asString());
-			if(!allRuleChecksNodeReferenceValueReferenceValueItem["SingleCheckResult"].isNull())
-				referenceValueObject.singleCheckResult = std::stoi(allRuleChecksNodeReferenceValueReferenceValueItem["SingleCheckResult"].asString());
+			if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].isNull())
+				referenceValueObject.bizDate = std::stol(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].asString());
+			if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].isNull())
+				referenceValueObject.discreteProperty = qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].asString();
+			if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].isNull())
+				referenceValueObject.value = std::stof(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].asString());
+			if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].isNull())
+				referenceValueObject.threshold = std::stof(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].asString());
+			if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].isNull())
+				referenceValueObject.singleCheckResult = std::stoi(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].asString());
 			ruleChecksItemObject.referenceValue.push_back(referenceValueObject);
 		}
-		auto allSampleValueNode = allRuleChecksNode["SampleValue"]["SampleValueItem"];
-		for (auto allRuleChecksNodeSampleValueSampleValueItem : allSampleValueNode)
+		auto allSampleValueNode = qualityResultsNodeRuleChecksRuleChecksItem["SampleValue"]["SampleValueItem"];
+		for (auto qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem : allSampleValueNode)
 		{
 			QualityResults::RuleChecksItem::SampleValueItem sampleValueObject;
-			if(!allRuleChecksNodeSampleValueSampleValueItem["BizDate"].isNull())
-				sampleValueObject.bizDate = std::stol(allRuleChecksNodeSampleValueSampleValueItem["BizDate"].asString());
-			if(!allRuleChecksNodeSampleValueSampleValueItem["DiscreteProperty"].isNull())
-				sampleValueObject.discreteProperty = allRuleChecksNodeSampleValueSampleValueItem["DiscreteProperty"].asString();
-			if(!allRuleChecksNodeSampleValueSampleValueItem["Value"].isNull())
-				sampleValueObject.value = std::stof(allRuleChecksNodeSampleValueSampleValueItem["Value"].asString());
+			if(!qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].isNull())
+				sampleValueObject.bizDate = std::stol(qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].asString());
+			if(!qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].isNull())
+				sampleValueObject.discreteProperty = qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].asString();
+			if(!qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].isNull())
+				sampleValueObject.value = std::stof(qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].asString());
 			ruleChecksItemObject.sampleValue.push_back(sampleValueObject);
 		}
 		qualityResults_.ruleChecks.push_back(ruleChecksItemObject);

dataworks-public/src/model/RunTriggerNodeRequest.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/RunTriggerNodeRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::RunTriggerNodeRequest;
+
+RunTriggerNodeRequest::RunTriggerNodeRequest() :
+	RpcServiceRequest("dataworks-public", "2020-05-18", "RunTriggerNode")
+{
+	setMethod(HttpRequest::Method::Put);
+}
+
+RunTriggerNodeRequest::~RunTriggerNodeRequest()
+{}
+
+long RunTriggerNodeRequest::getBizDate()const
+{
+	return bizDate_;
+}
+
+void RunTriggerNodeRequest::setBizDate(long bizDate)
+{
+	bizDate_ = bizDate;
+	setBodyParameter("BizDate", std::to_string(bizDate));
+}
+
+long RunTriggerNodeRequest::getAppId()const
+{
+	return appId_;
+}
+
+void RunTriggerNodeRequest::setAppId(long appId)
+{
+	appId_ = appId;
+	setBodyParameter("AppId", std::to_string(appId));
+}
+
+long RunTriggerNodeRequest::getCycleTime()const
+{
+	return cycleTime_;
+}
+
+void RunTriggerNodeRequest::setCycleTime(long cycleTime)
+{
+	cycleTime_ = cycleTime;
+	setBodyParameter("CycleTime", std::to_string(cycleTime));
+}
+
+long RunTriggerNodeRequest::getNodeId()const
+{
+	return nodeId_;
+}
+
+void RunTriggerNodeRequest::setNodeId(long nodeId)
+{
+	nodeId_ = nodeId;
+	setBodyParameter("NodeId", std::to_string(nodeId));
+}
+

dataworks-public/src/model/RunTriggerNodeResult.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/RunTriggerNodeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dataworks_public;
+using namespace AlibabaCloud::Dataworks_public::Model;
+
+RunTriggerNodeResult::RunTriggerNodeResult() :
+	ServiceResult()
+{}
+
+RunTriggerNodeResult::RunTriggerNodeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RunTriggerNodeResult::~RunTriggerNodeResult()
+{}
+
+void RunTriggerNodeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool RunTriggerNodeResult::getSuccess()const
+{
+	return success_;
+}
+

dataworks-public/src/model/SearchNodesByOutputRequest.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/SearchNodesByOutputRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::SearchNodesByOutputRequest;
+
+SearchNodesByOutputRequest::SearchNodesByOutputRequest() :
+	RpcServiceRequest("dataworks-public", "2020-05-18", "SearchNodesByOutput")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+SearchNodesByOutputRequest::~SearchNodesByOutputRequest()
+{}
+
+std::string SearchNodesByOutputRequest::getProjectEnv()const
+{
+	return projectEnv_;
+}
+
+void SearchNodesByOutputRequest::setProjectEnv(const std::string& projectEnv)
+{
+	projectEnv_ = projectEnv;
+	setBodyParameter("ProjectEnv", projectEnv);
+}
+
+std::string SearchNodesByOutputRequest::getOutputs()const
+{
+	return outputs_;
+}
+
+void SearchNodesByOutputRequest::setOutputs(const std::string& outputs)
+{
+	outputs_ = outputs;
+	setBodyParameter("Outputs", outputs);
+}
+

dataworks-public/src/model/SearchNodesByOutputResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/dataworks-public/model/SearchNodesByOutputResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dataworks_public;
+using namespace AlibabaCloud::Dataworks_public::Model;
+
+SearchNodesByOutputResult::SearchNodesByOutputResult() :
+	ServiceResult()
+{}
+
+SearchNodesByOutputResult::SearchNodesByOutputResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SearchNodesByOutputResult::~SearchNodesByOutputResult()
+{}
+
+void SearchNodesByOutputResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["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["Data"].isNull())
+		data_ = value["Data"].asString();
+
+}
+
+int SearchNodesByOutputResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string SearchNodesByOutputResult::getData()const
+{
+	return data_;
+}
+
+std::string SearchNodesByOutputResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string SearchNodesByOutputResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool SearchNodesByOutputResult::getSuccess()const
+{
+	return success_;
+}
+