Generated 2020-05-18 for dataworks-public.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-07-07 Version: 1.36.504
+- Generated 2020-05-18 for `dataworks-public`.
+
 2020-07-03 Version: 1.36.503
 - Supported UpdateUserBucketConfig.
 

VERSION

@@ -1 +1 @@
-1.36.503
+1.36.504

dataworks-public/CMakeLists.txt

@@ -31,6 +31,10 @@ set(dataworks-public_public_header_model
 	include/alibabacloud/dataworks-public/model/CheckMetaTableResult.h
 	include/alibabacloud/dataworks-public/model/CreateConnectionRequest.h
 	include/alibabacloud/dataworks-public/model/CreateConnectionResult.h
+	include/alibabacloud/dataworks-public/model/CreateDagComplementRequest.h
+	include/alibabacloud/dataworks-public/model/CreateDagComplementResult.h
+	include/alibabacloud/dataworks-public/model/CreateDagTestRequest.h
+	include/alibabacloud/dataworks-public/model/CreateDagTestResult.h
 	include/alibabacloud/dataworks-public/model/CreateDataServiceApiRequest.h
 	include/alibabacloud/dataworks-public/model/CreateDataServiceApiResult.h
 	include/alibabacloud/dataworks-public/model/CreateFileRequest.h
@@ -39,10 +43,6 @@ set(dataworks-public_public_header_model
 	include/alibabacloud/dataworks-public/model/CreateFolderResult.h
 	include/alibabacloud/dataworks-public/model/CreateMetaCategoryRequest.h
 	include/alibabacloud/dataworks-public/model/CreateMetaCategoryResult.h
-	include/alibabacloud/dataworks-public/model/CreateNodeComplementRequest.h
-	include/alibabacloud/dataworks-public/model/CreateNodeComplementResult.h
-	include/alibabacloud/dataworks-public/model/CreateNodeTestRequest.h
-	include/alibabacloud/dataworks-public/model/CreateNodeTestResult.h
 	include/alibabacloud/dataworks-public/model/CreateQualityEntityRequest.h
 	include/alibabacloud/dataworks-public/model/CreateQualityEntityResult.h
 	include/alibabacloud/dataworks-public/model/CreateQualityFollowerRequest.h
@@ -246,6 +246,10 @@ set(dataworks-public_src
 	src/model/CheckMetaTableResult.cc
 	src/model/CreateConnectionRequest.cc
 	src/model/CreateConnectionResult.cc
+	src/model/CreateDagComplementRequest.cc
+	src/model/CreateDagComplementResult.cc
+	src/model/CreateDagTestRequest.cc
+	src/model/CreateDagTestResult.cc
 	src/model/CreateDataServiceApiRequest.cc
 	src/model/CreateDataServiceApiResult.cc
 	src/model/CreateFileRequest.cc
@@ -254,10 +258,6 @@ set(dataworks-public_src
 	src/model/CreateFolderResult.cc
 	src/model/CreateMetaCategoryRequest.cc
 	src/model/CreateMetaCategoryResult.cc
-	src/model/CreateNodeComplementRequest.cc
-	src/model/CreateNodeComplementResult.cc
-	src/model/CreateNodeTestRequest.cc
-	src/model/CreateNodeTestResult.cc
 	src/model/CreateQualityEntityRequest.cc
 	src/model/CreateQualityEntityResult.cc
 	src/model/CreateQualityFollowerRequest.cc

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

@@ -32,6 +32,10 @@
 #include "model/CheckMetaTableResult.h"
 #include "model/CreateConnectionRequest.h"
 #include "model/CreateConnectionResult.h"
+#include "model/CreateDagComplementRequest.h"
+#include "model/CreateDagComplementResult.h"
+#include "model/CreateDagTestRequest.h"
+#include "model/CreateDagTestResult.h"
 #include "model/CreateDataServiceApiRequest.h"
 #include "model/CreateDataServiceApiResult.h"
 #include "model/CreateFileRequest.h"
@@ -40,10 +44,6 @@
 #include "model/CreateFolderResult.h"
 #include "model/CreateMetaCategoryRequest.h"
 #include "model/CreateMetaCategoryResult.h"
-#include "model/CreateNodeComplementRequest.h"
-#include "model/CreateNodeComplementResult.h"
-#include "model/CreateNodeTestRequest.h"
-#include "model/CreateNodeTestResult.h"
 #include "model/CreateQualityEntityRequest.h"
 #include "model/CreateQualityEntityResult.h"
 #include "model/CreateQualityFollowerRequest.h"
@@ -258,6 +258,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateConnectionResult> CreateConnectionOutcome;
 			typedef std::future<CreateConnectionOutcome> CreateConnectionOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateConnectionRequest&, const CreateConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateConnectionAsyncHandler;
+			typedef Outcome<Error, Model::CreateDagComplementResult> CreateDagComplementOutcome;
+			typedef std::future<CreateDagComplementOutcome> CreateDagComplementOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateDagComplementRequest&, const CreateDagComplementOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDagComplementAsyncHandler;
+			typedef Outcome<Error, Model::CreateDagTestResult> CreateDagTestOutcome;
+			typedef std::future<CreateDagTestOutcome> CreateDagTestOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateDagTestRequest&, const CreateDagTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDagTestAsyncHandler;
 			typedef Outcome<Error, Model::CreateDataServiceApiResult> CreateDataServiceApiOutcome;
 			typedef std::future<CreateDataServiceApiOutcome> CreateDataServiceApiOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateDataServiceApiRequest&, const CreateDataServiceApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDataServiceApiAsyncHandler;
@@ -270,12 +276,6 @@ namespace AlibabaCloud
 			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;
-			typedef Outcome<Error, Model::CreateNodeComplementResult> CreateNodeComplementOutcome;
-			typedef std::future<CreateNodeComplementOutcome> CreateNodeComplementOutcomeCallable;
-			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateNodeComplementRequest&, const CreateNodeComplementOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNodeComplementAsyncHandler;
-			typedef Outcome<Error, Model::CreateNodeTestResult> CreateNodeTestOutcome;
-			typedef std::future<CreateNodeTestOutcome> CreateNodeTestOutcomeCallable;
-			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateNodeTestRequest&, const CreateNodeTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNodeTestAsyncHandler;
 			typedef Outcome<Error, Model::CreateQualityEntityResult> CreateQualityEntityOutcome;
 			typedef std::future<CreateQualityEntityOutcome> CreateQualityEntityOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::CreateQualityEntityRequest&, const CreateQualityEntityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateQualityEntityAsyncHandler;
@@ -581,6 +581,12 @@ namespace AlibabaCloud
 			CreateConnectionOutcome createConnection(const Model::CreateConnectionRequest &request)const;
 			void createConnectionAsync(const Model::CreateConnectionRequest& request, const CreateConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateConnectionOutcomeCallable createConnectionCallable(const Model::CreateConnectionRequest& request) const;
+			CreateDagComplementOutcome createDagComplement(const Model::CreateDagComplementRequest &request)const;
+			void createDagComplementAsync(const Model::CreateDagComplementRequest& request, const CreateDagComplementAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDagComplementOutcomeCallable createDagComplementCallable(const Model::CreateDagComplementRequest& request) const;
+			CreateDagTestOutcome createDagTest(const Model::CreateDagTestRequest &request)const;
+			void createDagTestAsync(const Model::CreateDagTestRequest& request, const CreateDagTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDagTestOutcomeCallable createDagTestCallable(const Model::CreateDagTestRequest& request) const;
 			CreateDataServiceApiOutcome createDataServiceApi(const Model::CreateDataServiceApiRequest &request)const;
 			void createDataServiceApiAsync(const Model::CreateDataServiceApiRequest& request, const CreateDataServiceApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDataServiceApiOutcomeCallable createDataServiceApiCallable(const Model::CreateDataServiceApiRequest& request) const;
@@ -593,12 +599,6 @@ namespace AlibabaCloud
 			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;
-			CreateNodeComplementOutcome createNodeComplement(const Model::CreateNodeComplementRequest &request)const;
-			void createNodeComplementAsync(const Model::CreateNodeComplementRequest& request, const CreateNodeComplementAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateNodeComplementOutcomeCallable createNodeComplementCallable(const Model::CreateNodeComplementRequest& request) const;
-			CreateNodeTestOutcome createNodeTest(const Model::CreateNodeTestRequest &request)const;
-			void createNodeTestAsync(const Model::CreateNodeTestRequest& request, const CreateNodeTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateNodeTestOutcomeCallable createNodeTestCallable(const Model::CreateNodeTestRequest& request) const;
 			CreateQualityEntityOutcome createQualityEntity(const Model::CreateQualityEntityRequest &request)const;
 			void createQualityEntityAsync(const Model::CreateQualityEntityRequest& request, const CreateQualityEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateQualityEntityOutcomeCallable createQualityEntityCallable(const Model::CreateQualityEntityRequest& request) const;

dataworks-public/include/alibabacloud/dataworks-public/model/CreateNodeComplementRequest.h → dataworks-public/include/alibabacloud/dataworks-public/model/CreateDagComplementRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODECOMPLEMENTREQUEST_H_
-#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODECOMPLEMENTREQUEST_H_
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDAGCOMPLEMENTREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDAGCOMPLEMENTREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,12 +28,12 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateNodeComplementRequest : public RpcServiceRequest
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateDagComplementRequest : public RpcServiceRequest
 			{
 
 			public:
-				CreateNodeComplementRequest();
-				~CreateNodeComplementRequest();
+				CreateDagComplementRequest();
+				~CreateDagComplementRequest();
 
 				std::string getProjectEnv()const;
 				void setProjectEnv(const std::string& projectEnv);
@@ -41,6 +41,8 @@ namespace AlibabaCloud
 				void setStartBizDate(const std::string& startBizDate);
 				bool getParallelism()const;
 				void setParallelism(bool parallelism);
+				long getRootNodeId()const;
+				void setRootNodeId(long rootNodeId);
 				std::string getBizBeginTime()const;
 				void setBizBeginTime(const std::string& bizBeginTime);
 				std::string getEndBizDate()const;
@@ -53,26 +55,24 @@ namespace AlibabaCloud
 				void setName(const std::string& name);
 				std::string getExcludeNodeIds()const;
 				void setExcludeNodeIds(const std::string& excludeNodeIds);
-				long getNodeId()const;
-				void setNodeId(long nodeId);
-				long getNodeProjectId()const;
-				void setNodeProjectId(long nodeProjectId);
+				std::string getNodeParams()const;
+				void setNodeParams(const std::string& nodeParams);
 
             private:
 				std::string projectEnv_;
 				std::string startBizDate_;
 				bool parallelism_;
+				long rootNodeId_;
 				std::string bizBeginTime_;
 				std::string endBizDate_;
 				std::string includeNodeIds_;
 				std::string bizEndTime_;
 				std::string name_;
 				std::string excludeNodeIds_;
-				long nodeId_;
-				long nodeProjectId_;
+				std::string nodeParams_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODECOMPLEMENTREQUEST_H_
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDAGCOMPLEMENTREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateNodeComplementResult.h → dataworks-public/include/alibabacloud/dataworks-public/model/CreateDagComplementResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODECOMPLEMENTRESULT_H_
-#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODECOMPLEMENTRESULT_H_
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDAGCOMPLEMENTRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDAGCOMPLEMENTRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,16 +29,16 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateNodeComplementResult : public ServiceResult
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateDagComplementResult : public ServiceResult
 			{
 			public:
 
 
-				CreateNodeComplementResult();
-				explicit CreateNodeComplementResult(const std::string &payload);
-				~CreateNodeComplementResult();
+				CreateDagComplementResult();
+				explicit CreateDagComplementResult(const std::string &payload);
+				~CreateDagComplementResult();
 				int getHttpStatusCode()const;
-				long getData()const;
+				std::vector<std::string> getData()const;
 				std::string getErrorCode()const;
 				std::string getErrorMessage()const;
 				bool getSuccess()const;
@@ -47,7 +47,7 @@ namespace AlibabaCloud
 				void parse(const std::string &payload);
 			private:
 				int httpStatusCode_;
-				long data_;
+				std::vector<std::string> data_;
 				std::string errorCode_;
 				std::string errorMessage_;
 				bool success_;
@@ -56,4 +56,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODECOMPLEMENTRESULT_H_
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDAGCOMPLEMENTRESULT_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateNodeTestRequest.h → dataworks-public/include/alibabacloud/dataworks-public/model/CreateDagTestRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODETESTREQUEST_H_
-#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODETESTREQUEST_H_
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDAGTESTREQUEST_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDAGTESTREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,48 +28,33 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateNodeTestRequest : public RpcServiceRequest
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateDagTestRequest : public RpcServiceRequest
 			{
 
 			public:
-				CreateNodeTestRequest();
-				~CreateNodeTestRequest();
+				CreateDagTestRequest();
+				~CreateDagTestRequest();
 
 				std::string getProjectEnv()const;
 				void setProjectEnv(const std::string& projectEnv);
-				bool getParallelism()const;
-				void setParallelism(bool parallelism);
-				std::string getBizBeginTime()const;
-				void setBizBeginTime(const std::string& bizBeginTime);
-				std::string getIncludeNodeIds()const;
-				void setIncludeNodeIds(const std::string& includeNodeIds);
 				std::string getBizdate()const;
 				void setBizdate(const std::string& bizdate);
-				std::string getBizEndTime()const;
-				void setBizEndTime(const std::string& bizEndTime);
 				std::string getName()const;
 				void setName(const std::string& name);
-				std::string getExcludeNodeIds()const;
-				void setExcludeNodeIds(const std::string& excludeNodeIds);
+				std::string getNodeParams()const;
+				void setNodeParams(const std::string& nodeParams);
 				long getNodeId()const;
 				void setNodeId(long nodeId);
-				long getNodeProjectId()const;
-				void setNodeProjectId(long nodeProjectId);
 
             private:
 				std::string projectEnv_;
-				bool parallelism_;
-				std::string bizBeginTime_;
-				std::string includeNodeIds_;
 				std::string bizdate_;
-				std::string bizEndTime_;
 				std::string name_;
-				std::string excludeNodeIds_;
+				std::string nodeParams_;
 				long nodeId_;
-				long nodeProjectId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODETESTREQUEST_H_
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDAGTESTREQUEST_H_

dataworks-public/include/alibabacloud/dataworks-public/model/CreateNodeTestResult.h → dataworks-public/include/alibabacloud/dataworks-public/model/CreateDagTestResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODETESTRESULT_H_
-#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODETESTRESULT_H_
+#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDAGTESTRESULT_H_
+#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDAGTESTRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,14 +29,14 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateNodeTestResult : public ServiceResult
+			class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateDagTestResult : public ServiceResult
 			{
 			public:
 
 
-				CreateNodeTestResult();
-				explicit CreateNodeTestResult(const std::string &payload);
-				~CreateNodeTestResult();
+				CreateDagTestResult();
+				explicit CreateDagTestResult(const std::string &payload);
+				~CreateDagTestResult();
 				int getHttpStatusCode()const;
 				long getData()const;
 				std::string getErrorCode()const;
@@ -56,4 +56,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATENODETESTRESULT_H_
+#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEDAGTESTRESULT_H_

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

@@ -37,6 +37,8 @@ namespace AlibabaCloud
 
 				int getFileType()const;
 				void setFileType(int fileType);
+				std::string getDependentNodeIdList()const;
+				void setDependentNodeIdList(const std::string& dependentNodeIdList);
 				std::string getContent()const;
 				void setContent(const std::string& content);
 				std::string getProjectIdentifier()const;
@@ -51,8 +53,6 @@ namespace AlibabaCloud
 				void setOwner(const std::string& owner);
 				int getAutoRerunIntervalMillis()const;
 				void setAutoRerunIntervalMillis(int autoRerunIntervalMillis);
-				std::string getDependentCloudUuidList()const;
-				void setDependentCloudUuidList(const std::string& dependentCloudUuidList);
 				std::string getInputList()const;
 				void setInputList(const std::string& inputList);
 				std::string getRerunMode()const;
@@ -78,6 +78,7 @@ namespace AlibabaCloud
 
             private:
 				int fileType_;
+				std::string dependentNodeIdList_;
 				std::string content_;
 				std::string projectIdentifier_;
 				long projectId_;
@@ -85,7 +86,6 @@ namespace AlibabaCloud
 				std::string cycleType_;
 				std::string owner_;
 				int autoRerunIntervalMillis_;
-				std::string dependentCloudUuidList_;
 				std::string inputList_;
 				std::string rerunMode_;
 				std::string paraValue_;

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

@@ -40,7 +40,7 @@ namespace AlibabaCloud
 						std::string owner;
 						long createTime;
 						std::string fileName;
-						int useType;
+						std::string useType;
 						int currentVersion;
 						std::string createUser;
 						bool isMaxCompute;
@@ -66,16 +66,16 @@ namespace AlibabaCloud
 							std::string output;
 							std::string refTableName;
 						};
-						int taskRerunTime;
-						int taskRerunIntervalMillis;
 						std::string cycleType;
 						std::vector<NodeInputOutput> inputList;
 						bool stop;
 						std::string dependentType;
 						std::string cronExpress;
 						long endEffectDate;
+						int autoRerunIntervalMillis;
 						std::string dependentNodeIdList;
 						long startEffectDate;
+						int autoRerunTimes;
 						std::string rerunMode;
 						std::string paraValue;
 						std::vector<NodeInputOutput1> outputList;

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

@@ -34,32 +34,22 @@ namespace AlibabaCloud
 			public:
 				struct Data
 				{
-					int destination;
+					std::string projectIdentifier;
+					int status;
 					std::string projectOwnerBaseId;
+					int schedulerMaxRetryTimes;
 					std::string projectName;
 					int isAllowDownload;
 					std::string gmtModified;
-					int developmentType;
-					bool disableDevelopment;
-					bool baseProject;
-					int projectMode;
-					std::string projectDescription;
-					std::string devStorageQuota;
-					int isDefault;
-					std::string projectIdentifier;
-					int status;
-					int schedulerMaxRetryTimes;
 					int projectId;
+					int developmentType;
 					std::string residentArea;
-					bool useProxyOdpsAccount;
 					std::string gmtCreate;
 					long tenantId;
-					int maxFlowNode;
 					int protectedMode;
-					std::string appkey;
-					int tablePrivacyMode;
-					std::string prodStorageQuota;
 					std::string defaultDiResourceGroupIdentifier;
+					int projectMode;
+					std::string projectDescription;
 					std::vector<std::string> envTypes;
 					int schedulerRetryInterval;
 				};

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

@@ -52,6 +52,7 @@ namespace AlibabaCloud
 						std::string name;
 						std::string gmtCreate;
 						long tenantId;
+						std::string content;
 						int id;
 					};
 					std::vector<ConnectionsItem> connections;

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

@@ -51,8 +51,8 @@ namespace AlibabaCloud
 				void setKeyword(const std::string& keyword);
 				long getProjectId()const;
 				void setProjectId(long projectId);
-				int getUseType()const;
-				void setUseType(int useType);
+				std::string getUseType()const;
+				void setUseType(const std::string& useType);
 
             private:
 				std::string owner_;
@@ -63,7 +63,7 @@ namespace AlibabaCloud
 				int pageSize_;
 				std::string keyword_;
 				long projectId_;
-				int useType_;
+				std::string useType_;
 
 			};
 		}

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

@@ -40,7 +40,7 @@ namespace AlibabaCloud
 						std::string owner;
 						long createTime;
 						std::string fileName;
-						int useType;
+						std::string useType;
 						int currentVersion;
 						std::string createUser;
 						bool isMaxCompute;

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

@@ -37,10 +37,10 @@ namespace AlibabaCloud
 
 				std::string getProjectEnv()const;
 				void setProjectEnv(const std::string& projectEnv);
+				std::string getOwner()const;
+				void setOwner(const std::string& owner);
 				std::string getBizName()const;
 				void setBizName(const std::string& bizName);
-				std::string getOwnerId()const;
-				void setOwnerId(const std::string& ownerId);
 				int getPageNumber()const;
 				void setPageNumber(int pageNumber);
 				std::string getNodeName()const;
@@ -56,8 +56,8 @@ namespace AlibabaCloud
 
             private:
 				std::string projectEnv_;
+				std::string owner_;
 				std::string bizName_;
-				std::string ownerId_;
 				int pageNumber_;
 				std::string nodeName_;
 				std::string programType_;

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

@@ -34,7 +34,7 @@ namespace AlibabaCloud
 			public:
 				struct Data
 				{
-					struct InstancesItem
+					struct Instance
 					{
 						std::string status;
 						long modifyTime;
@@ -52,7 +52,7 @@ namespace AlibabaCloud
 						int nodeId;
 						long beginWaitResTime;
 					};
-					std::vector<InstancesItem> instances;
+					std::vector<Instance> instances;
 					int totalCount;
 					int pageSize;
 					int pageNumber;

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

@@ -37,15 +37,15 @@ namespace AlibabaCloud
 
 				std::string getProjectEnv()const;
 				void setProjectEnv(const std::string& projectEnv);
-				std::string getType()const;
-				void setType(const std::string& type);
 				long getNodeId()const;
 				void setNodeId(long nodeId);
+				std::string getIoType()const;
+				void setIoType(const std::string& ioType);
 
             private:
 				std::string projectEnv_;
-				std::string type_;
 				long nodeId_;
+				std::string ioType_;
 
 			};
 		}

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

@@ -35,12 +35,12 @@ namespace AlibabaCloud
 				ListNodesRequest();
 				~ListNodesRequest();
 
+				std::string getOwner()const;
+				void setOwner(const std::string& owner);
 				std::string getProjectEnv()const;
 				void setProjectEnv(const std::string& projectEnv);
 				std::string getBizName()const;
 				void setBizName(const std::string& bizName);
-				std::string getOwnerId()const;
-				void setOwnerId(const std::string& ownerId);
 				int getPageNumber()const;
 				void setPageNumber(int pageNumber);
 				std::string getNodeName()const;
@@ -53,9 +53,9 @@ namespace AlibabaCloud
 				void setProjectId(long projectId);
 
             private:
+				std::string owner_;
 				std::string projectEnv_;
 				std::string bizName_;
-				std::string ownerId_;
 				int pageNumber_;
 				std::string nodeName_;
 				std::string programType_;

dataworks-public/src/Dataworks-publicClient.cc

@@ -231,216 +231,216 @@ Dataworks_publicClient::CreateConnectionOutcomeCallable Dataworks_publicClient::
 	return task->get_future();
 }
 
-Dataworks_publicClient::CreateDataServiceApiOutcome Dataworks_publicClient::createDataServiceApi(const CreateDataServiceApiRequest &request) const
+Dataworks_publicClient::CreateDagComplementOutcome Dataworks_publicClient::createDagComplement(const CreateDagComplementRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return CreateDataServiceApiOutcome(endpointOutcome.error());
+		return CreateDagComplementOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return CreateDataServiceApiOutcome(CreateDataServiceApiResult(outcome.result()));
+		return CreateDagComplementOutcome(CreateDagComplementResult(outcome.result()));
 	else
-		return CreateDataServiceApiOutcome(outcome.error());
+		return CreateDagComplementOutcome(outcome.error());
 }
 
-void Dataworks_publicClient::createDataServiceApiAsync(const CreateDataServiceApiRequest& request, const CreateDataServiceApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void Dataworks_publicClient::createDagComplementAsync(const CreateDagComplementRequest& request, const CreateDagComplementAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, createDataServiceApi(request), context);
+		handler(this, request, createDagComplement(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-Dataworks_publicClient::CreateDataServiceApiOutcomeCallable Dataworks_publicClient::createDataServiceApiCallable(const CreateDataServiceApiRequest &request) const
+Dataworks_publicClient::CreateDagComplementOutcomeCallable Dataworks_publicClient::createDagComplementCallable(const CreateDagComplementRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<CreateDataServiceApiOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<CreateDagComplementOutcome()>>(
 			[this, request]()
 			{
-			return this->createDataServiceApi(request);
+			return this->createDagComplement(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-Dataworks_publicClient::CreateFileOutcome Dataworks_publicClient::createFile(const CreateFileRequest &request) const
+Dataworks_publicClient::CreateDagTestOutcome Dataworks_publicClient::createDagTest(const CreateDagTestRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return CreateFileOutcome(endpointOutcome.error());
+		return CreateDagTestOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return CreateFileOutcome(CreateFileResult(outcome.result()));
+		return CreateDagTestOutcome(CreateDagTestResult(outcome.result()));
 	else
-		return CreateFileOutcome(outcome.error());
+		return CreateDagTestOutcome(outcome.error());
 }
 
-void Dataworks_publicClient::createFileAsync(const CreateFileRequest& request, const CreateFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void Dataworks_publicClient::createDagTestAsync(const CreateDagTestRequest& request, const CreateDagTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, createFile(request), context);
+		handler(this, request, createDagTest(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-Dataworks_publicClient::CreateFileOutcomeCallable Dataworks_publicClient::createFileCallable(const CreateFileRequest &request) const
+Dataworks_publicClient::CreateDagTestOutcomeCallable Dataworks_publicClient::createDagTestCallable(const CreateDagTestRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<CreateFileOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<CreateDagTestOutcome()>>(
 			[this, request]()
 			{
-			return this->createFile(request);
+			return this->createDagTest(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-Dataworks_publicClient::CreateFolderOutcome Dataworks_publicClient::createFolder(const CreateFolderRequest &request) const
+Dataworks_publicClient::CreateDataServiceApiOutcome Dataworks_publicClient::createDataServiceApi(const CreateDataServiceApiRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return CreateFolderOutcome(endpointOutcome.error());
+		return CreateDataServiceApiOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return CreateFolderOutcome(CreateFolderResult(outcome.result()));
+		return CreateDataServiceApiOutcome(CreateDataServiceApiResult(outcome.result()));
 	else
-		return CreateFolderOutcome(outcome.error());
+		return CreateDataServiceApiOutcome(outcome.error());
 }
 
-void Dataworks_publicClient::createFolderAsync(const CreateFolderRequest& request, const CreateFolderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void Dataworks_publicClient::createDataServiceApiAsync(const CreateDataServiceApiRequest& request, const CreateDataServiceApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, createFolder(request), context);
+		handler(this, request, createDataServiceApi(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-Dataworks_publicClient::CreateFolderOutcomeCallable Dataworks_publicClient::createFolderCallable(const CreateFolderRequest &request) const
+Dataworks_publicClient::CreateDataServiceApiOutcomeCallable Dataworks_publicClient::createDataServiceApiCallable(const CreateDataServiceApiRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<CreateFolderOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<CreateDataServiceApiOutcome()>>(
 			[this, request]()
 			{
-			return this->createFolder(request);
+			return this->createDataServiceApi(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-Dataworks_publicClient::CreateMetaCategoryOutcome Dataworks_publicClient::createMetaCategory(const CreateMetaCategoryRequest &request) const
+Dataworks_publicClient::CreateFileOutcome Dataworks_publicClient::createFile(const CreateFileRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return CreateMetaCategoryOutcome(endpointOutcome.error());
+		return CreateFileOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return CreateMetaCategoryOutcome(CreateMetaCategoryResult(outcome.result()));
+		return CreateFileOutcome(CreateFileResult(outcome.result()));
 	else
-		return CreateMetaCategoryOutcome(outcome.error());
+		return CreateFileOutcome(outcome.error());
 }
 
-void Dataworks_publicClient::createMetaCategoryAsync(const CreateMetaCategoryRequest& request, const CreateMetaCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void Dataworks_publicClient::createFileAsync(const CreateFileRequest& request, const CreateFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, createMetaCategory(request), context);
+		handler(this, request, createFile(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-Dataworks_publicClient::CreateMetaCategoryOutcomeCallable Dataworks_publicClient::createMetaCategoryCallable(const CreateMetaCategoryRequest &request) const
+Dataworks_publicClient::CreateFileOutcomeCallable Dataworks_publicClient::createFileCallable(const CreateFileRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<CreateMetaCategoryOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<CreateFileOutcome()>>(
 			[this, request]()
 			{
-			return this->createMetaCategory(request);
+			return this->createFile(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-Dataworks_publicClient::CreateNodeComplementOutcome Dataworks_publicClient::createNodeComplement(const CreateNodeComplementRequest &request) const
+Dataworks_publicClient::CreateFolderOutcome Dataworks_publicClient::createFolder(const CreateFolderRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return CreateNodeComplementOutcome(endpointOutcome.error());
+		return CreateFolderOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return CreateNodeComplementOutcome(CreateNodeComplementResult(outcome.result()));
+		return CreateFolderOutcome(CreateFolderResult(outcome.result()));
 	else
-		return CreateNodeComplementOutcome(outcome.error());
+		return CreateFolderOutcome(outcome.error());
 }
 
-void Dataworks_publicClient::createNodeComplementAsync(const CreateNodeComplementRequest& request, const CreateNodeComplementAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void Dataworks_publicClient::createFolderAsync(const CreateFolderRequest& request, const CreateFolderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, createNodeComplement(request), context);
+		handler(this, request, createFolder(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-Dataworks_publicClient::CreateNodeComplementOutcomeCallable Dataworks_publicClient::createNodeComplementCallable(const CreateNodeComplementRequest &request) const
+Dataworks_publicClient::CreateFolderOutcomeCallable Dataworks_publicClient::createFolderCallable(const CreateFolderRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<CreateNodeComplementOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<CreateFolderOutcome()>>(
 			[this, request]()
 			{
-			return this->createNodeComplement(request);
+			return this->createFolder(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-Dataworks_publicClient::CreateNodeTestOutcome Dataworks_publicClient::createNodeTest(const CreateNodeTestRequest &request) const
+Dataworks_publicClient::CreateMetaCategoryOutcome Dataworks_publicClient::createMetaCategory(const CreateMetaCategoryRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return CreateNodeTestOutcome(endpointOutcome.error());
+		return CreateMetaCategoryOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return CreateNodeTestOutcome(CreateNodeTestResult(outcome.result()));
+		return CreateMetaCategoryOutcome(CreateMetaCategoryResult(outcome.result()));
 	else
-		return CreateNodeTestOutcome(outcome.error());
+		return CreateMetaCategoryOutcome(outcome.error());
 }
 
-void Dataworks_publicClient::createNodeTestAsync(const CreateNodeTestRequest& request, const CreateNodeTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void Dataworks_publicClient::createMetaCategoryAsync(const CreateMetaCategoryRequest& request, const CreateMetaCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, createNodeTest(request), context);
+		handler(this, request, createMetaCategory(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-Dataworks_publicClient::CreateNodeTestOutcomeCallable Dataworks_publicClient::createNodeTestCallable(const CreateNodeTestRequest &request) const
+Dataworks_publicClient::CreateMetaCategoryOutcomeCallable Dataworks_publicClient::createMetaCategoryCallable(const CreateMetaCategoryRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<CreateNodeTestOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<CreateMetaCategoryOutcome()>>(
 			[this, request]()
 			{
-			return this->createNodeTest(request);
+			return this->createMetaCategory(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));

dataworks-public/src/model/CreateDagComplementRequest.cc

@@ -0,0 +1,150 @@
+/*
+ * 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/CreateDagComplementRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::CreateDagComplementRequest;
+
+CreateDagComplementRequest::CreateDagComplementRequest() :
+	RpcServiceRequest("dataworks-public", "2020-05-18", "CreateDagComplement")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateDagComplementRequest::~CreateDagComplementRequest()
+{}
+
+std::string CreateDagComplementRequest::getProjectEnv()const
+{
+	return projectEnv_;
+}
+
+void CreateDagComplementRequest::setProjectEnv(const std::string& projectEnv)
+{
+	projectEnv_ = projectEnv;
+	setBodyParameter("ProjectEnv", projectEnv);
+}
+
+std::string CreateDagComplementRequest::getStartBizDate()const
+{
+	return startBizDate_;
+}
+
+void CreateDagComplementRequest::setStartBizDate(const std::string& startBizDate)
+{
+	startBizDate_ = startBizDate;
+	setBodyParameter("StartBizDate", startBizDate);
+}
+
+bool CreateDagComplementRequest::getParallelism()const
+{
+	return parallelism_;
+}
+
+void CreateDagComplementRequest::setParallelism(bool parallelism)
+{
+	parallelism_ = parallelism;
+	setBodyParameter("Parallelism", parallelism ? "true" : "false");
+}
+
+long CreateDagComplementRequest::getRootNodeId()const
+{
+	return rootNodeId_;
+}
+
+void CreateDagComplementRequest::setRootNodeId(long rootNodeId)
+{
+	rootNodeId_ = rootNodeId;
+	setBodyParameter("RootNodeId", std::to_string(rootNodeId));
+}
+
+std::string CreateDagComplementRequest::getBizBeginTime()const
+{
+	return bizBeginTime_;
+}
+
+void CreateDagComplementRequest::setBizBeginTime(const std::string& bizBeginTime)
+{
+	bizBeginTime_ = bizBeginTime;
+	setBodyParameter("BizBeginTime", bizBeginTime);
+}
+
+std::string CreateDagComplementRequest::getEndBizDate()const
+{
+	return endBizDate_;
+}
+
+void CreateDagComplementRequest::setEndBizDate(const std::string& endBizDate)
+{
+	endBizDate_ = endBizDate;
+	setBodyParameter("EndBizDate", endBizDate);
+}
+
+std::string CreateDagComplementRequest::getIncludeNodeIds()const
+{
+	return includeNodeIds_;
+}
+
+void CreateDagComplementRequest::setIncludeNodeIds(const std::string& includeNodeIds)
+{
+	includeNodeIds_ = includeNodeIds;
+	setBodyParameter("IncludeNodeIds", includeNodeIds);
+}
+
+std::string CreateDagComplementRequest::getBizEndTime()const
+{
+	return bizEndTime_;
+}
+
+void CreateDagComplementRequest::setBizEndTime(const std::string& bizEndTime)
+{
+	bizEndTime_ = bizEndTime;
+	setBodyParameter("BizEndTime", bizEndTime);
+}
+
+std::string CreateDagComplementRequest::getName()const
+{
+	return name_;
+}
+
+void CreateDagComplementRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setBodyParameter("Name", name);
+}
+
+std::string CreateDagComplementRequest::getExcludeNodeIds()const
+{
+	return excludeNodeIds_;
+}
+
+void CreateDagComplementRequest::setExcludeNodeIds(const std::string& excludeNodeIds)
+{
+	excludeNodeIds_ = excludeNodeIds;
+	setBodyParameter("ExcludeNodeIds", excludeNodeIds);
+}
+
+std::string CreateDagComplementRequest::getNodeParams()const
+{
+	return nodeParams_;
+}
+
+void CreateDagComplementRequest::setNodeParams(const std::string& nodeParams)
+{
+	nodeParams_ = nodeParams;
+	setBodyParameter("NodeParams", nodeParams);
+}
+

dataworks-public/src/model/CreateNodeComplementResult.cc → dataworks-public/src/model/CreateDagComplementResult.cc

@@ -14,31 +14,34 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/dataworks-public/model/CreateNodeComplementResult.h>
+#include <alibabacloud/dataworks-public/model/CreateDagComplementResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Dataworks_public;
 using namespace AlibabaCloud::Dataworks_public::Model;
 
-CreateNodeComplementResult::CreateNodeComplementResult() :
+CreateDagComplementResult::CreateDagComplementResult() :
 	ServiceResult()
 {}
 
-CreateNodeComplementResult::CreateNodeComplementResult(const std::string &payload) :
+CreateDagComplementResult::CreateDagComplementResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateNodeComplementResult::~CreateNodeComplementResult()
+CreateDagComplementResult::~CreateDagComplementResult()
 {}
 
-void CreateNodeComplementResult::parse(const std::string &payload)
+void CreateDagComplementResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	auto allData = value["Data"]["dagId"];
+	for (const auto &item : allData)
+		data_.push_back(item.asString());
 	if(!value["ErrorCode"].isNull())
 		errorCode_ = value["ErrorCode"].asString();
 	if(!value["ErrorMessage"].isNull())
@@ -47,32 +50,30 @@ void CreateNodeComplementResult::parse(const std::string &payload)
 		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
 	if(!value["Success"].isNull())
 		success_ = value["Success"].asString() == "true";
-	if(!value["Data"].isNull())
-		data_ = std::stol(value["Data"].asString());
 
 }
 
-int CreateNodeComplementResult::getHttpStatusCode()const
+int CreateDagComplementResult::getHttpStatusCode()const
 {
 	return httpStatusCode_;
 }
 
-long CreateNodeComplementResult::getData()const
+std::vector<std::string> CreateDagComplementResult::getData()const
 {
 	return data_;
 }
 
-std::string CreateNodeComplementResult::getErrorCode()const
+std::string CreateDagComplementResult::getErrorCode()const
 {
 	return errorCode_;
 }
 
-std::string CreateNodeComplementResult::getErrorMessage()const
+std::string CreateDagComplementResult::getErrorMessage()const
 {
 	return errorMessage_;
 }
 
-bool CreateNodeComplementResult::getSuccess()const
+bool CreateDagComplementResult::getSuccess()const
 {
 	return success_;
 }

dataworks-public/src/model/CreateDagTestRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * 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/CreateDagTestRequest.h>
+
+using AlibabaCloud::Dataworks_public::Model::CreateDagTestRequest;
+
+CreateDagTestRequest::CreateDagTestRequest() :
+	RpcServiceRequest("dataworks-public", "2020-05-18", "CreateDagTest")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateDagTestRequest::~CreateDagTestRequest()
+{}
+
+std::string CreateDagTestRequest::getProjectEnv()const
+{
+	return projectEnv_;
+}
+
+void CreateDagTestRequest::setProjectEnv(const std::string& projectEnv)
+{
+	projectEnv_ = projectEnv;
+	setBodyParameter("ProjectEnv", projectEnv);
+}
+
+std::string CreateDagTestRequest::getBizdate()const
+{
+	return bizdate_;
+}
+
+void CreateDagTestRequest::setBizdate(const std::string& bizdate)
+{
+	bizdate_ = bizdate;
+	setBodyParameter("Bizdate", bizdate);
+}
+
+std::string CreateDagTestRequest::getName()const
+{
+	return name_;
+}
+
+void CreateDagTestRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setBodyParameter("Name", name);
+}
+
+std::string CreateDagTestRequest::getNodeParams()const
+{
+	return nodeParams_;
+}
+
+void CreateDagTestRequest::setNodeParams(const std::string& nodeParams)
+{
+	nodeParams_ = nodeParams;
+	setBodyParameter("NodeParams", nodeParams);
+}
+
+long CreateDagTestRequest::getNodeId()const
+{
+	return nodeId_;
+}
+
+void CreateDagTestRequest::setNodeId(long nodeId)
+{
+	nodeId_ = nodeId;
+	setBodyParameter("NodeId", std::to_string(nodeId));
+}
+

dataworks-public/src/model/CreateNodeTestResult.cc → dataworks-public/src/model/CreateDagTestResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/dataworks-public/model/CreateNodeTestResult.h>
+#include <alibabacloud/dataworks-public/model/CreateDagTestResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Dataworks_public;
 using namespace AlibabaCloud::Dataworks_public::Model;
 
-CreateNodeTestResult::CreateNodeTestResult() :
+CreateDagTestResult::CreateDagTestResult() :
 	ServiceResult()
 {}
 
-CreateNodeTestResult::CreateNodeTestResult(const std::string &payload) :
+CreateDagTestResult::CreateDagTestResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateNodeTestResult::~CreateNodeTestResult()
+CreateDagTestResult::~CreateDagTestResult()
 {}
 
-void CreateNodeTestResult::parse(const std::string &payload)
+void CreateDagTestResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
@@ -52,27 +52,27 @@ void CreateNodeTestResult::parse(const std::string &payload)
 
 }
 
-int CreateNodeTestResult::getHttpStatusCode()const
+int CreateDagTestResult::getHttpStatusCode()const
 {
 	return httpStatusCode_;
 }
 
-long CreateNodeTestResult::getData()const
+long CreateDagTestResult::getData()const
 {
 	return data_;
 }
 
-std::string CreateNodeTestResult::getErrorCode()const
+std::string CreateDagTestResult::getErrorCode()const
 {
 	return errorCode_;
 }
 
-std::string CreateNodeTestResult::getErrorMessage()const
+std::string CreateDagTestResult::getErrorMessage()const
 {
 	return errorMessage_;
 }
 
-bool CreateNodeTestResult::getSuccess()const
+bool CreateDagTestResult::getSuccess()const
 {
 	return success_;
 }

dataworks-public/src/model/CreateFileRequest.cc

@@ -38,6 +38,17 @@ void CreateFileRequest::setFileType(int fileType)
 	setBodyParameter("FileType", std::to_string(fileType));
 }
 
+std::string CreateFileRequest::getDependentNodeIdList()const
+{
+	return dependentNodeIdList_;
+}
+
+void CreateFileRequest::setDependentNodeIdList(const std::string& dependentNodeIdList)
+{
+	dependentNodeIdList_ = dependentNodeIdList;
+	setBodyParameter("DependentNodeIdList", dependentNodeIdList);
+}
+
 std::string CreateFileRequest::getContent()const
 {
 	return content_;
@@ -115,17 +126,6 @@ void CreateFileRequest::setAutoRerunIntervalMillis(int autoRerunIntervalMillis)
 	setBodyParameter("AutoRerunIntervalMillis", std::to_string(autoRerunIntervalMillis));
 }
 
-std::string CreateFileRequest::getDependentCloudUuidList()const
-{
-	return dependentCloudUuidList_;
-}
-
-void CreateFileRequest::setDependentCloudUuidList(const std::string& dependentCloudUuidList)
-{
-	dependentCloudUuidList_ = dependentCloudUuidList;
-	setBodyParameter("DependentCloudUuidList", dependentCloudUuidList);
-}
-
 std::string CreateFileRequest::getInputList()const
 {
 	return inputList_;

dataworks-public/src/model/CreateNodeComplementRequest.cc

@@ -1,150 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/dataworks-public/model/CreateNodeComplementRequest.h>
-
-using AlibabaCloud::Dataworks_public::Model::CreateNodeComplementRequest;
-
-CreateNodeComplementRequest::CreateNodeComplementRequest() :
-	RpcServiceRequest("dataworks-public", "2020-05-18", "CreateNodeComplement")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateNodeComplementRequest::~CreateNodeComplementRequest()
-{}
-
-std::string CreateNodeComplementRequest::getProjectEnv()const
-{
-	return projectEnv_;
-}
-
-void CreateNodeComplementRequest::setProjectEnv(const std::string& projectEnv)
-{
-	projectEnv_ = projectEnv;
-	setBodyParameter("ProjectEnv", projectEnv);
-}
-
-std::string CreateNodeComplementRequest::getStartBizDate()const
-{
-	return startBizDate_;
-}
-
-void CreateNodeComplementRequest::setStartBizDate(const std::string& startBizDate)
-{
-	startBizDate_ = startBizDate;
-	setBodyParameter("StartBizDate", startBizDate);
-}
-
-bool CreateNodeComplementRequest::getParallelism()const
-{
-	return parallelism_;
-}
-
-void CreateNodeComplementRequest::setParallelism(bool parallelism)
-{
-	parallelism_ = parallelism;
-	setBodyParameter("Parallelism", parallelism ? "true" : "false");
-}
-
-std::string CreateNodeComplementRequest::getBizBeginTime()const
-{
-	return bizBeginTime_;
-}
-
-void CreateNodeComplementRequest::setBizBeginTime(const std::string& bizBeginTime)
-{
-	bizBeginTime_ = bizBeginTime;
-	setBodyParameter("BizBeginTime", bizBeginTime);
-}
-
-std::string CreateNodeComplementRequest::getEndBizDate()const
-{
-	return endBizDate_;
-}
-
-void CreateNodeComplementRequest::setEndBizDate(const std::string& endBizDate)
-{
-	endBizDate_ = endBizDate;
-	setBodyParameter("EndBizDate", endBizDate);
-}
-
-std::string CreateNodeComplementRequest::getIncludeNodeIds()const
-{
-	return includeNodeIds_;
-}
-
-void CreateNodeComplementRequest::setIncludeNodeIds(const std::string& includeNodeIds)
-{
-	includeNodeIds_ = includeNodeIds;
-	setBodyParameter("IncludeNodeIds", includeNodeIds);
-}
-
-std::string CreateNodeComplementRequest::getBizEndTime()const
-{
-	return bizEndTime_;
-}
-
-void CreateNodeComplementRequest::setBizEndTime(const std::string& bizEndTime)
-{
-	bizEndTime_ = bizEndTime;
-	setBodyParameter("BizEndTime", bizEndTime);
-}
-
-std::string CreateNodeComplementRequest::getName()const
-{
-	return name_;
-}
-
-void CreateNodeComplementRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setBodyParameter("Name", name);
-}
-
-std::string CreateNodeComplementRequest::getExcludeNodeIds()const
-{
-	return excludeNodeIds_;
-}
-
-void CreateNodeComplementRequest::setExcludeNodeIds(const std::string& excludeNodeIds)
-{
-	excludeNodeIds_ = excludeNodeIds;
-	setBodyParameter("ExcludeNodeIds", excludeNodeIds);
-}
-
-long CreateNodeComplementRequest::getNodeId()const
-{
-	return nodeId_;
-}
-
-void CreateNodeComplementRequest::setNodeId(long nodeId)
-{
-	nodeId_ = nodeId;
-	setBodyParameter("NodeId", std::to_string(nodeId));
-}
-
-long CreateNodeComplementRequest::getNodeProjectId()const
-{
-	return nodeProjectId_;
-}
-
-void CreateNodeComplementRequest::setNodeProjectId(long nodeProjectId)
-{
-	nodeProjectId_ = nodeProjectId;
-	setBodyParameter("NodeProjectId", std::to_string(nodeProjectId));
-}
-

dataworks-public/src/model/CreateNodeTestRequest.cc

@@ -1,139 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <alibabacloud/dataworks-public/model/CreateNodeTestRequest.h>
-
-using AlibabaCloud::Dataworks_public::Model::CreateNodeTestRequest;
-
-CreateNodeTestRequest::CreateNodeTestRequest() :
-	RpcServiceRequest("dataworks-public", "2020-05-18", "CreateNodeTest")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateNodeTestRequest::~CreateNodeTestRequest()
-{}
-
-std::string CreateNodeTestRequest::getProjectEnv()const
-{
-	return projectEnv_;
-}
-
-void CreateNodeTestRequest::setProjectEnv(const std::string& projectEnv)
-{
-	projectEnv_ = projectEnv;
-	setBodyParameter("ProjectEnv", projectEnv);
-}
-
-bool CreateNodeTestRequest::getParallelism()const
-{
-	return parallelism_;
-}
-
-void CreateNodeTestRequest::setParallelism(bool parallelism)
-{
-	parallelism_ = parallelism;
-	setBodyParameter("Parallelism", parallelism ? "true" : "false");
-}
-
-std::string CreateNodeTestRequest::getBizBeginTime()const
-{
-	return bizBeginTime_;
-}
-
-void CreateNodeTestRequest::setBizBeginTime(const std::string& bizBeginTime)
-{
-	bizBeginTime_ = bizBeginTime;
-	setBodyParameter("BizBeginTime", bizBeginTime);
-}
-
-std::string CreateNodeTestRequest::getIncludeNodeIds()const
-{
-	return includeNodeIds_;
-}
-
-void CreateNodeTestRequest::setIncludeNodeIds(const std::string& includeNodeIds)
-{
-	includeNodeIds_ = includeNodeIds;
-	setBodyParameter("IncludeNodeIds", includeNodeIds);
-}
-
-std::string CreateNodeTestRequest::getBizdate()const
-{
-	return bizdate_;
-}
-
-void CreateNodeTestRequest::setBizdate(const std::string& bizdate)
-{
-	bizdate_ = bizdate;
-	setBodyParameter("Bizdate", bizdate);
-}
-
-std::string CreateNodeTestRequest::getBizEndTime()const
-{
-	return bizEndTime_;
-}
-
-void CreateNodeTestRequest::setBizEndTime(const std::string& bizEndTime)
-{
-	bizEndTime_ = bizEndTime;
-	setBodyParameter("BizEndTime", bizEndTime);
-}
-
-std::string CreateNodeTestRequest::getName()const
-{
-	return name_;
-}
-
-void CreateNodeTestRequest::setName(const std::string& name)
-{
-	name_ = name;
-	setBodyParameter("Name", name);
-}
-
-std::string CreateNodeTestRequest::getExcludeNodeIds()const
-{
-	return excludeNodeIds_;
-}
-
-void CreateNodeTestRequest::setExcludeNodeIds(const std::string& excludeNodeIds)
-{
-	excludeNodeIds_ = excludeNodeIds;
-	setBodyParameter("ExcludeNodeIds", excludeNodeIds);
-}
-
-long CreateNodeTestRequest::getNodeId()const
-{
-	return nodeId_;
-}
-
-void CreateNodeTestRequest::setNodeId(long nodeId)
-{
-	nodeId_ = nodeId;
-	setBodyParameter("NodeId", std::to_string(nodeId));
-}
-
-long CreateNodeTestRequest::getNodeProjectId()const
-{
-	return nodeProjectId_;
-}
-
-void CreateNodeTestRequest::setNodeProjectId(long nodeProjectId)
-{
-	nodeProjectId_ = nodeProjectId;
-	setBodyParameter("NodeProjectId", std::to_string(nodeProjectId));
-}
-

dataworks-public/src/model/GetFileResult.cc

@@ -60,7 +60,7 @@ void GetFileResult::parse(const std::string &payload)
 	if(!fileNode["FileType"].isNull())
 		data_.file.fileType = std::stoi(fileNode["FileType"].asString());
 	if(!fileNode["UseType"].isNull())
-		data_.file.useType = std::stoi(fileNode["UseType"].asString());
+		data_.file.useType = fileNode["UseType"].asString();
 	if(!fileNode["FileDescription"].isNull())
 		data_.file.fileDescription = fileNode["FileDescription"].asString();
 	if(!fileNode["Content"].isNull())
@@ -78,10 +78,10 @@ void GetFileResult::parse(const std::string &payload)
 	if(!fileNode["CommitStatus"].isNull())
 		data_.file.commitStatus = std::stoi(fileNode["CommitStatus"].asString());
 	auto nodeConfigurationNode = dataNode["NodeConfiguration"];
-	if(!nodeConfigurationNode["TaskRerunTime"].isNull())
-		data_.nodeConfiguration.taskRerunTime = std::stoi(nodeConfigurationNode["TaskRerunTime"].asString());
-	if(!nodeConfigurationNode["TaskRerunIntervalMillis"].isNull())
-		data_.nodeConfiguration.taskRerunIntervalMillis = std::stoi(nodeConfigurationNode["TaskRerunIntervalMillis"].asString());
+	if(!nodeConfigurationNode["AutoRerunTimes"].isNull())
+		data_.nodeConfiguration.autoRerunTimes = std::stoi(nodeConfigurationNode["AutoRerunTimes"].asString());
+	if(!nodeConfigurationNode["AutoRerunIntervalMillis"].isNull())
+		data_.nodeConfiguration.autoRerunIntervalMillis = std::stoi(nodeConfigurationNode["AutoRerunIntervalMillis"].asString());
 	if(!nodeConfigurationNode["RerunMode"].isNull())
 		data_.nodeConfiguration.rerunMode = nodeConfigurationNode["RerunMode"].asString();
 	if(!nodeConfigurationNode["Stop"].isNull())

dataworks-public/src/model/GetProjectDetailResult.cc

@@ -42,46 +42,26 @@ void GetProjectDetailResult::parse(const std::string &payload)
 	auto dataNode = value["Data"];
 	if(!dataNode["GmtModified"].isNull())
 		data_.gmtModified = dataNode["GmtModified"].asString();
-	if(!dataNode["MaxFlowNode"].isNull())
-		data_.maxFlowNode = std::stoi(dataNode["MaxFlowNode"].asString());
 	if(!dataNode["DefaultDiResourceGroupIdentifier"].isNull())
 		data_.defaultDiResourceGroupIdentifier = dataNode["DefaultDiResourceGroupIdentifier"].asString();
-	if(!dataNode["Destination"].isNull())
-		data_.destination = std::stoi(dataNode["Destination"].asString());
 	if(!dataNode["IsAllowDownload"].isNull())
 		data_.isAllowDownload = std::stoi(dataNode["IsAllowDownload"].asString());
-	if(!dataNode["ProdStorageQuota"].isNull())
-		data_.prodStorageQuota = dataNode["ProdStorageQuota"].asString();
 	if(!dataNode["SchedulerRetryInterval"].isNull())
 		data_.schedulerRetryInterval = std::stoi(dataNode["SchedulerRetryInterval"].asString());
 	if(!dataNode["ResidentArea"].isNull())
 		data_.residentArea = dataNode["ResidentArea"].asString();
-	if(!dataNode["TablePrivacyMode"].isNull())
-		data_.tablePrivacyMode = std::stoi(dataNode["TablePrivacyMode"].asString());
 	if(!dataNode["ProjectOwnerBaseId"].isNull())
 		data_.projectOwnerBaseId = dataNode["ProjectOwnerBaseId"].asString();
-	if(!dataNode["UseProxyOdpsAccount"].isNull())
-		data_.useProxyOdpsAccount = dataNode["UseProxyOdpsAccount"].asString() == "true";
-	if(!dataNode["DisableDevelopment"].isNull())
-		data_.disableDevelopment = dataNode["DisableDevelopment"].asString() == "true";
 	if(!dataNode["ProjectMode"].isNull())
 		data_.projectMode = std::stoi(dataNode["ProjectMode"].asString());
 	if(!dataNode["GmtCreate"].isNull())
 		data_.gmtCreate = dataNode["GmtCreate"].asString();
-	if(!dataNode["DevStorageQuota"].isNull())
-		data_.devStorageQuota = dataNode["DevStorageQuota"].asString();
-	if(!dataNode["IsDefault"].isNull())
-		data_.isDefault = std::stoi(dataNode["IsDefault"].asString());
 	if(!dataNode["ProtectedMode"].isNull())
 		data_.protectedMode = std::stoi(dataNode["ProtectedMode"].asString());
-	if(!dataNode["BaseProject"].isNull())
-		data_.baseProject = dataNode["BaseProject"].asString() == "true";
 	if(!dataNode["TenantId"].isNull())
 		data_.tenantId = std::stol(dataNode["TenantId"].asString());
 	if(!dataNode["ProjectDescription"].isNull())
 		data_.projectDescription = dataNode["ProjectDescription"].asString();
-	if(!dataNode["Appkey"].isNull())
-		data_.appkey = dataNode["Appkey"].asString();
 	if(!dataNode["SchedulerMaxRetryTimes"].isNull())
 		data_.schedulerMaxRetryTimes = std::stoi(dataNode["SchedulerMaxRetryTimes"].asString());
 	if(!dataNode["ProjectName"].isNull())

dataworks-public/src/model/ListConnectionsResult.cc

@@ -84,6 +84,8 @@ void ListConnectionsResult::parse(const std::string &payload)
 			connectionsItemObject.projectId = std::stoi(dataNodeConnectionsConnectionsItem["ProjectId"].asString());
 		if(!dataNodeConnectionsConnectionsItem["Status"].isNull())
 			connectionsItemObject.status = std::stoi(dataNodeConnectionsConnectionsItem["Status"].asString());
+		if(!dataNodeConnectionsConnectionsItem["Content"].isNull())
+			connectionsItemObject.content = dataNodeConnectionsConnectionsItem["Content"].asString();
 		data_.connections.push_back(connectionsItemObject);
 	}
 	if(!value["HttpStatusCode"].isNull())

dataworks-public/src/model/ListFilesRequest.cc

@@ -115,14 +115,14 @@ void ListFilesRequest::setProjectId(long projectId)
 	setBodyParameter("ProjectId", std::to_string(projectId));
 }
 
-int ListFilesRequest::getUseType()const
+std::string ListFilesRequest::getUseType()const
 {
 	return useType_;
 }
 
-void ListFilesRequest::setUseType(int useType)
+void ListFilesRequest::setUseType(const std::string& useType)
 {
 	useType_ = useType;
-	setBodyParameter("UseType", std::to_string(useType));
+	setBodyParameter("UseType", useType);
 }
 

dataworks-public/src/model/ListFilesResult.cc

@@ -69,7 +69,7 @@ void ListFilesResult::parse(const std::string &payload)
 		if(!dataNodeFilesFile["FileType"].isNull())
 			fileObject.fileType = std::stoi(dataNodeFilesFile["FileType"].asString());
 		if(!dataNodeFilesFile["UseType"].isNull())
-			fileObject.useType = std::stoi(dataNodeFilesFile["UseType"].asString());
+			fileObject.useType = dataNodeFilesFile["UseType"].asString();
 		if(!dataNodeFilesFile["FileDescription"].isNull())
 			fileObject.fileDescription = dataNodeFilesFile["FileDescription"].asString();
 		if(!dataNodeFilesFile["Content"].isNull())

dataworks-public/src/model/ListInstancesRequest.cc

@@ -38,26 +38,26 @@ void ListInstancesRequest::setProjectEnv(const std::string& projectEnv)
 	setBodyParameter("ProjectEnv", projectEnv);
 }
 
-std::string ListInstancesRequest::getBizName()const
+std::string ListInstancesRequest::getOwner()const
 {
-	return bizName_;
+	return owner_;
 }
 
-void ListInstancesRequest::setBizName(const std::string& bizName)
+void ListInstancesRequest::setOwner(const std::string& owner)
 {
-	bizName_ = bizName;
-	setBodyParameter("BizName", bizName);
+	owner_ = owner;
+	setBodyParameter("Owner", owner);
 }
 
-std::string ListInstancesRequest::getOwnerId()const
+std::string ListInstancesRequest::getBizName()const
 {
-	return ownerId_;
+	return bizName_;
 }
 
-void ListInstancesRequest::setOwnerId(const std::string& ownerId)
+void ListInstancesRequest::setBizName(const std::string& bizName)
 {
-	ownerId_ = ownerId;
-	setBodyParameter("OwnerId", ownerId);
+	bizName_ = bizName;
+	setBodyParameter("BizName", bizName);
 }
 
 int ListInstancesRequest::getPageNumber()const
@@ -68,7 +68,7 @@ int ListInstancesRequest::getPageNumber()const
 void ListInstancesRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+	setBodyParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string ListInstancesRequest::getNodeName()const
@@ -101,7 +101,7 @@ int ListInstancesRequest::getPageSize()const
 void ListInstancesRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+	setBodyParameter("PageSize", std::to_string(pageSize));
 }
 
 long ListInstancesRequest::getNodeId()const

dataworks-public/src/model/ListInstancesResult.cc

@@ -46,41 +46,41 @@ void ListInstancesResult::parse(const std::string &payload)
 		data_.pageSize = std::stoi(dataNode["PageSize"].asString());
 	if(!dataNode["TotalCount"].isNull())
 		data_.totalCount = std::stoi(dataNode["TotalCount"].asString());
-	auto allInstancesNode = dataNode["Instances"]["InstancesItem"];
-	for (auto dataNodeInstancesInstancesItem : allInstancesNode)
+	auto allInstancesNode = dataNode["Instances"]["Instance"];
+	for (auto dataNodeInstancesInstance : allInstancesNode)
 	{
-		Data::InstancesItem instancesItemObject;
-		if(!dataNodeInstancesInstancesItem["NodeId"].isNull())
-			instancesItemObject.nodeId = std::stoi(dataNodeInstancesInstancesItem["NodeId"].asString());
-		if(!dataNodeInstancesInstancesItem["InstanceId"].isNull())
-			instancesItemObject.instanceId = std::stol(dataNodeInstancesInstancesItem["InstanceId"].asString());
-		if(!dataNodeInstancesInstancesItem["DagId"].isNull())
-			instancesItemObject.dagId = std::stoi(dataNodeInstancesInstancesItem["DagId"].asString());
-		if(!dataNodeInstancesInstancesItem["DagType"].isNull())
-			instancesItemObject.dagType = dataNodeInstancesInstancesItem["DagType"].asString();
-		if(!dataNodeInstancesInstancesItem["Status"].isNull())
-			instancesItemObject.status = dataNodeInstancesInstancesItem["Status"].asString();
-		if(!dataNodeInstancesInstancesItem["Bizdate"].isNull())
-			instancesItemObject.bizdate = std::stol(dataNodeInstancesInstancesItem["Bizdate"].asString());
-		if(!dataNodeInstancesInstancesItem["CycTime"].isNull())
-			instancesItemObject.cycTime = std::stol(dataNodeInstancesInstancesItem["CycTime"].asString());
-		if(!dataNodeInstancesInstancesItem["CreateTime"].isNull())
-			instancesItemObject.createTime = std::stol(dataNodeInstancesInstancesItem["CreateTime"].asString());
-		if(!dataNodeInstancesInstancesItem["ModifyTime"].isNull())
-			instancesItemObject.modifyTime = std::stol(dataNodeInstancesInstancesItem["ModifyTime"].asString());
-		if(!dataNodeInstancesInstancesItem["NodeName"].isNull())
-			instancesItemObject.nodeName = dataNodeInstancesInstancesItem["NodeName"].asString();
-		if(!dataNodeInstancesInstancesItem["BeginWaitTimeTime"].isNull())
-			instancesItemObject.beginWaitTimeTime = std::stol(dataNodeInstancesInstancesItem["BeginWaitTimeTime"].asString());
-		if(!dataNodeInstancesInstancesItem["BeginWaitResTime"].isNull())
-			instancesItemObject.beginWaitResTime = std::stol(dataNodeInstancesInstancesItem["BeginWaitResTime"].asString());
-		if(!dataNodeInstancesInstancesItem["BeginRunningTime"].isNull())
-			instancesItemObject.beginRunningTime = std::stol(dataNodeInstancesInstancesItem["BeginRunningTime"].asString());
-		if(!dataNodeInstancesInstancesItem["ParamValues"].isNull())
-			instancesItemObject.paramValues = dataNodeInstancesInstancesItem["ParamValues"].asString();
-		if(!dataNodeInstancesInstancesItem["FinishTime"].isNull())
-			instancesItemObject.finishTime = std::stol(dataNodeInstancesInstancesItem["FinishTime"].asString());
-		data_.instances.push_back(instancesItemObject);
+		Data::Instance instanceObject;
+		if(!dataNodeInstancesInstance["NodeId"].isNull())
+			instanceObject.nodeId = std::stoi(dataNodeInstancesInstance["NodeId"].asString());
+		if(!dataNodeInstancesInstance["InstanceId"].isNull())
+			instanceObject.instanceId = std::stol(dataNodeInstancesInstance["InstanceId"].asString());
+		if(!dataNodeInstancesInstance["DagId"].isNull())
+			instanceObject.dagId = std::stoi(dataNodeInstancesInstance["DagId"].asString());
+		if(!dataNodeInstancesInstance["DagType"].isNull())
+			instanceObject.dagType = dataNodeInstancesInstance["DagType"].asString();
+		if(!dataNodeInstancesInstance["Status"].isNull())
+			instanceObject.status = dataNodeInstancesInstance["Status"].asString();
+		if(!dataNodeInstancesInstance["Bizdate"].isNull())
+			instanceObject.bizdate = std::stol(dataNodeInstancesInstance["Bizdate"].asString());
+		if(!dataNodeInstancesInstance["CycTime"].isNull())
+			instanceObject.cycTime = std::stol(dataNodeInstancesInstance["CycTime"].asString());
+		if(!dataNodeInstancesInstance["CreateTime"].isNull())
+			instanceObject.createTime = std::stol(dataNodeInstancesInstance["CreateTime"].asString());
+		if(!dataNodeInstancesInstance["ModifyTime"].isNull())
+			instanceObject.modifyTime = std::stol(dataNodeInstancesInstance["ModifyTime"].asString());
+		if(!dataNodeInstancesInstance["NodeName"].isNull())
+			instanceObject.nodeName = dataNodeInstancesInstance["NodeName"].asString();
+		if(!dataNodeInstancesInstance["BeginWaitTimeTime"].isNull())
+			instanceObject.beginWaitTimeTime = std::stol(dataNodeInstancesInstance["BeginWaitTimeTime"].asString());
+		if(!dataNodeInstancesInstance["BeginWaitResTime"].isNull())
+			instanceObject.beginWaitResTime = std::stol(dataNodeInstancesInstance["BeginWaitResTime"].asString());
+		if(!dataNodeInstancesInstance["BeginRunningTime"].isNull())
+			instanceObject.beginRunningTime = std::stol(dataNodeInstancesInstance["BeginRunningTime"].asString());
+		if(!dataNodeInstancesInstance["ParamValues"].isNull())
+			instanceObject.paramValues = dataNodeInstancesInstance["ParamValues"].asString();
+		if(!dataNodeInstancesInstance["FinishTime"].isNull())
+			instanceObject.finishTime = std::stol(dataNodeInstancesInstance["FinishTime"].asString());
+		data_.instances.push_back(instanceObject);
 	}
 	if(!value["Success"].isNull())
 		success_ = value["Success"].asString() == "true";

dataworks-public/src/model/ListNodeIORequest.cc

@@ -38,25 +38,25 @@ void ListNodeIORequest::setProjectEnv(const std::string& projectEnv)
 	setBodyParameter("ProjectEnv", projectEnv);
 }
 
-std::string ListNodeIORequest::getType()const
+long ListNodeIORequest::getNodeId()const
 {
-	return type_;
+	return nodeId_;
 }
 
-void ListNodeIORequest::setType(const std::string& type)
+void ListNodeIORequest::setNodeId(long nodeId)
 {
-	type_ = type;
-	setBodyParameter("Type", type);
+	nodeId_ = nodeId;
+	setBodyParameter("NodeId", std::to_string(nodeId));
 }
 
-long ListNodeIORequest::getNodeId()const
+std::string ListNodeIORequest::getIoType()const
 {
-	return nodeId_;
+	return ioType_;
 }
 
-void ListNodeIORequest::setNodeId(long nodeId)
+void ListNodeIORequest::setIoType(const std::string& ioType)
 {
-	nodeId_ = nodeId;
-	setBodyParameter("NodeId", std::to_string(nodeId));
+	ioType_ = ioType;
+	setBodyParameter("IoType", ioType);
 }
 

dataworks-public/src/model/ListNodesRequest.cc

@@ -27,6 +27,17 @@ ListNodesRequest::ListNodesRequest() :
 ListNodesRequest::~ListNodesRequest()
 {}
 
+std::string ListNodesRequest::getOwner()const
+{
+	return owner_;
+}
+
+void ListNodesRequest::setOwner(const std::string& owner)
+{
+	owner_ = owner;
+	setBodyParameter("Owner", owner);
+}
+
 std::string ListNodesRequest::getProjectEnv()const
 {
 	return projectEnv_;
@@ -49,17 +60,6 @@ void ListNodesRequest::setBizName(const std::string& bizName)
 	setBodyParameter("BizName", bizName);
 }
 
-std::string ListNodesRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void ListNodesRequest::setOwnerId(const std::string& ownerId)
-{
-	ownerId_ = ownerId;
-	setBodyParameter("OwnerId", ownerId);
-}
-
 int ListNodesRequest::getPageNumber()const
 {
 	return pageNumber_;