Support ListSensitiveColumns, ListSensitiveColumnsDetail API.

dms-enterprise/CMakeLists.txt

@@ -81,6 +81,10 @@ set(dms-enterprise_public_header_model
 	include/alibabacloud/dms-enterprise/model/ListLogicTablesResult.h
 	include/alibabacloud/dms-enterprise/model/ListOrdersRequest.h
 	include/alibabacloud/dms-enterprise/model/ListOrdersResult.h
+	include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsRequest.h
+	include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsResult.h
+	include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsDetailRequest.h
+	include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsDetailResult.h
 	include/alibabacloud/dms-enterprise/model/ListTablesRequest.h
 	include/alibabacloud/dms-enterprise/model/ListTablesResult.h
 	include/alibabacloud/dms-enterprise/model/ListUserPermissionsRequest.h
@@ -176,6 +180,10 @@ set(dms-enterprise_src
 	src/model/ListLogicTablesResult.cc
 	src/model/ListOrdersRequest.cc
 	src/model/ListOrdersResult.cc
+	src/model/ListSensitiveColumnsRequest.cc
+	src/model/ListSensitiveColumnsResult.cc
+	src/model/ListSensitiveColumnsDetailRequest.cc
+	src/model/ListSensitiveColumnsDetailResult.cc
 	src/model/ListTablesRequest.cc
 	src/model/ListTablesResult.cc
 	src/model/ListUserPermissionsRequest.cc

dms-enterprise/include/alibabacloud/dms-enterprise/Dms_enterpriseClient.h

@@ -82,6 +82,10 @@
 #include "model/ListLogicTablesResult.h"
 #include "model/ListOrdersRequest.h"
 #include "model/ListOrdersResult.h"
+#include "model/ListSensitiveColumnsRequest.h"
+#include "model/ListSensitiveColumnsResult.h"
+#include "model/ListSensitiveColumnsDetailRequest.h"
+#include "model/ListSensitiveColumnsDetailResult.h"
 #include "model/ListTablesRequest.h"
 #include "model/ListTablesResult.h"
 #include "model/ListUserPermissionsRequest.h"
@@ -213,6 +217,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListOrdersResult> ListOrdersOutcome;
 			typedef std::future<ListOrdersOutcome> ListOrdersOutcomeCallable;
 			typedef std::function<void(const Dms_enterpriseClient*, const Model::ListOrdersRequest&, const ListOrdersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListOrdersAsyncHandler;
+			typedef Outcome<Error, Model::ListSensitiveColumnsResult> ListSensitiveColumnsOutcome;
+			typedef std::future<ListSensitiveColumnsOutcome> ListSensitiveColumnsOutcomeCallable;
+			typedef std::function<void(const Dms_enterpriseClient*, const Model::ListSensitiveColumnsRequest&, const ListSensitiveColumnsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSensitiveColumnsAsyncHandler;
+			typedef Outcome<Error, Model::ListSensitiveColumnsDetailResult> ListSensitiveColumnsDetailOutcome;
+			typedef std::future<ListSensitiveColumnsDetailOutcome> ListSensitiveColumnsDetailOutcomeCallable;
+			typedef std::function<void(const Dms_enterpriseClient*, const Model::ListSensitiveColumnsDetailRequest&, const ListSensitiveColumnsDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSensitiveColumnsDetailAsyncHandler;
 			typedef Outcome<Error, Model::ListTablesResult> ListTablesOutcome;
 			typedef std::future<ListTablesOutcome> ListTablesOutcomeCallable;
 			typedef std::function<void(const Dms_enterpriseClient*, const Model::ListTablesRequest&, const ListTablesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTablesAsyncHandler;
@@ -356,6 +366,12 @@ namespace AlibabaCloud
 			ListOrdersOutcome listOrders(const Model::ListOrdersRequest &request)const;
 			void listOrdersAsync(const Model::ListOrdersRequest& request, const ListOrdersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListOrdersOutcomeCallable listOrdersCallable(const Model::ListOrdersRequest& request) const;
+			ListSensitiveColumnsOutcome listSensitiveColumns(const Model::ListSensitiveColumnsRequest &request)const;
+			void listSensitiveColumnsAsync(const Model::ListSensitiveColumnsRequest& request, const ListSensitiveColumnsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSensitiveColumnsOutcomeCallable listSensitiveColumnsCallable(const Model::ListSensitiveColumnsRequest& request) const;
+			ListSensitiveColumnsDetailOutcome listSensitiveColumnsDetail(const Model::ListSensitiveColumnsDetailRequest &request)const;
+			void listSensitiveColumnsDetailAsync(const Model::ListSensitiveColumnsDetailRequest& request, const ListSensitiveColumnsDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSensitiveColumnsDetailOutcomeCallable listSensitiveColumnsDetailCallable(const Model::ListSensitiveColumnsDetailRequest& request) const;
 			ListTablesOutcome listTables(const Model::ListTablesRequest &request)const;
 			void listTablesAsync(const Model::ListTablesRequest& request, const ListTablesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListTablesOutcomeCallable listTablesCallable(const Model::ListTablesRequest& request) const;

dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsDetailRequest.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_DMS_ENTERPRISE_MODEL_LISTSENSITIVECOLUMNSDETAILREQUEST_H_
+#define ALIBABACLOUD_DMS_ENTERPRISE_MODEL_LISTSENSITIVECOLUMNSDETAILREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dms-enterprise/Dms_enterpriseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dms_enterprise
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DMS_ENTERPRISE_EXPORT ListSensitiveColumnsDetailRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListSensitiveColumnsDetailRequest();
+				~ListSensitiveColumnsDetailRequest();
+
+				std::string getSchemaName()const;
+				void setSchemaName(const std::string& schemaName);
+				std::string getTableName()const;
+				void setTableName(const std::string& tableName);
+				std::string getColumnName()const;
+				void setColumnName(const std::string& columnName);
+				long getTid()const;
+				void setTid(long tid);
+
+            private:
+				std::string schemaName_;
+				std::string tableName_;
+				std::string columnName_;
+				long tid_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DMS_ENTERPRISE_MODEL_LISTSENSITIVECOLUMNSDETAILREQUEST_H_

dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsDetailResult.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DMS_ENTERPRISE_MODEL_LISTSENSITIVECOLUMNSDETAILRESULT_H_
+#define ALIBABACLOUD_DMS_ENTERPRISE_MODEL_LISTSENSITIVECOLUMNSDETAILRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dms-enterprise/Dms_enterpriseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dms_enterprise
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DMS_ENTERPRISE_EXPORT ListSensitiveColumnsDetailResult : public ServiceResult
+			{
+			public:
+				struct SensitiveColumnsDetail
+				{
+					std::string tableName;
+					std::string columnName;
+					std::string columnType;
+					std::string searchName;
+					std::string columnDescription;
+					long dbId;
+					bool logic;
+					std::string schemaName;
+					std::string envType;
+					std::string dbType;
+				};
+
+
+				ListSensitiveColumnsDetailResult();
+				explicit ListSensitiveColumnsDetailResult(const std::string &payload);
+				~ListSensitiveColumnsDetailResult();
+				std::vector<SensitiveColumnsDetail> getSensitiveColumnsDetailList()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<SensitiveColumnsDetail> sensitiveColumnsDetailList_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DMS_ENTERPRISE_MODEL_LISTSENSITIVECOLUMNSDETAILRESULT_H_

dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsRequest.h

@@ -0,0 +1,66 @@
+/*
+ * 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_DMS_ENTERPRISE_MODEL_LISTSENSITIVECOLUMNSREQUEST_H_
+#define ALIBABACLOUD_DMS_ENTERPRISE_MODEL_LISTSENSITIVECOLUMNSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dms-enterprise/Dms_enterpriseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dms_enterprise
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DMS_ENTERPRISE_EXPORT ListSensitiveColumnsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListSensitiveColumnsRequest();
+				~ListSensitiveColumnsRequest();
+
+				std::string getSchemaName()const;
+				void setSchemaName(const std::string& schemaName);
+				std::string getSecurityLevel()const;
+				void setSecurityLevel(const std::string& securityLevel);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getTableName()const;
+				void setTableName(const std::string& tableName);
+				std::string getColumnName()const;
+				void setColumnName(const std::string& columnName);
+				long getTid()const;
+				void setTid(long tid);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+
+            private:
+				std::string schemaName_;
+				std::string securityLevel_;
+				int pageSize_;
+				std::string tableName_;
+				std::string columnName_;
+				long tid_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DMS_ENTERPRISE_MODEL_LISTSENSITIVECOLUMNSREQUEST_H_

dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsResult.h

@@ -0,0 +1,68 @@
+/*
+ * 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_DMS_ENTERPRISE_MODEL_LISTSENSITIVECOLUMNSRESULT_H_
+#define ALIBABACLOUD_DMS_ENTERPRISE_MODEL_LISTSENSITIVECOLUMNSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dms-enterprise/Dms_enterpriseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dms_enterprise
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DMS_ENTERPRISE_EXPORT ListSensitiveColumnsResult : public ServiceResult
+			{
+			public:
+				struct SensitiveColumn
+				{
+					std::string tableName;
+					std::string columnName;
+					long columnCount;
+					std::string securityLevel;
+					std::string functionType;
+					std::string schemaName;
+				};
+
+
+				ListSensitiveColumnsResult();
+				explicit ListSensitiveColumnsResult(const std::string &payload);
+				~ListSensitiveColumnsResult();
+				long getTotalCount()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				std::vector<SensitiveColumn> getSensitiveColumnList()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				std::vector<SensitiveColumn> sensitiveColumnList_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DMS_ENTERPRISE_MODEL_LISTSENSITIVECOLUMNSRESULT_H_

dms-enterprise/include/alibabacloud/dms-enterprise/model/ListUsersResult.h

@@ -34,13 +34,18 @@ namespace AlibabaCloud
 			public:
 				struct User
 				{
-					long uid;
-					std::vector<std::string> roleIdList;
-					std::string userId;
-					std::string state;
 					std::vector<std::string> roleNameList;
 					std::string nickName;
 					std::string mobile;
+					long maxExecuteCount;
+					long uid;
+					std::string lastLoginTime;
+					long curResultCount;
+					std::vector<std::string> roleIdList;
+					long maxResultCount;
+					std::string userId;
+					std::string state;
+					long curExecuteCount;
 					long parentUid;
 				};
 

dms-enterprise/include/alibabacloud/dms-enterprise/model/ListWorkFlowTemplatesResult.h

@@ -41,11 +41,13 @@ namespace AlibabaCloud
 						int position;
 						std::string nodeType;
 						long nodeId;
+						long createUserId;
 						long templateId;
 					};
 					std::string comment;
 					std::string templateName;
 					std::string enabled;
+					long createUserId;
 					int isSystem;
 					std::vector<WorkFlowTemplate::WorkflowNode> workflowNodes;
 					long templateId;

dms-enterprise/include/alibabacloud/dms-enterprise/model/UpdateUserRequest.h

@@ -39,6 +39,10 @@ namespace AlibabaCloud
 				void setRoleNames(const std::string& roleNames);
 				long getUid()const;
 				void setUid(long uid);
+				long getMaxResultCount()const;
+				void setMaxResultCount(long maxResultCount);
+				long getMaxExecuteCount()const;
+				void setMaxExecuteCount(long maxExecuteCount);
 				std::string getUserNick()const;
 				void setUserNick(const std::string& userNick);
 				std::string getMobile()const;
@@ -49,6 +53,8 @@ namespace AlibabaCloud
             private:
 				std::string roleNames_;
 				long uid_;
+				long maxResultCount_;
+				long maxExecuteCount_;
 				std::string userNick_;
 				std::string mobile_;
 				long tid_;

dms-enterprise/src/Dms-enterpriseClient.cc

@@ -31,21 +31,21 @@ Dms_enterpriseClient::Dms_enterpriseClient(const Credentials &credentials, const
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dmsenterprise");
 }
 
 Dms_enterpriseClient::Dms_enterpriseClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dmsenterprise");
 }
 
 Dms_enterpriseClient::Dms_enterpriseClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dmsenterprise");
 }
 
 Dms_enterpriseClient::~Dms_enterpriseClient()
@@ -1131,6 +1131,78 @@ Dms_enterpriseClient::ListOrdersOutcomeCallable Dms_enterpriseClient::listOrders
 	return task->get_future();
 }
 
+Dms_enterpriseClient::ListSensitiveColumnsOutcome Dms_enterpriseClient::listSensitiveColumns(const ListSensitiveColumnsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListSensitiveColumnsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListSensitiveColumnsOutcome(ListSensitiveColumnsResult(outcome.result()));
+	else
+		return ListSensitiveColumnsOutcome(outcome.error());
+}
+
+void Dms_enterpriseClient::listSensitiveColumnsAsync(const ListSensitiveColumnsRequest& request, const ListSensitiveColumnsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listSensitiveColumns(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dms_enterpriseClient::ListSensitiveColumnsOutcomeCallable Dms_enterpriseClient::listSensitiveColumnsCallable(const ListSensitiveColumnsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListSensitiveColumnsOutcome()>>(
+			[this, request]()
+			{
+			return this->listSensitiveColumns(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Dms_enterpriseClient::ListSensitiveColumnsDetailOutcome Dms_enterpriseClient::listSensitiveColumnsDetail(const ListSensitiveColumnsDetailRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListSensitiveColumnsDetailOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListSensitiveColumnsDetailOutcome(ListSensitiveColumnsDetailResult(outcome.result()));
+	else
+		return ListSensitiveColumnsDetailOutcome(outcome.error());
+}
+
+void Dms_enterpriseClient::listSensitiveColumnsDetailAsync(const ListSensitiveColumnsDetailRequest& request, const ListSensitiveColumnsDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listSensitiveColumnsDetail(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Dms_enterpriseClient::ListSensitiveColumnsDetailOutcomeCallable Dms_enterpriseClient::listSensitiveColumnsDetailCallable(const ListSensitiveColumnsDetailRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListSensitiveColumnsDetailOutcome()>>(
+			[this, request]()
+			{
+			return this->listSensitiveColumnsDetail(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Dms_enterpriseClient::ListTablesOutcome Dms_enterpriseClient::listTables(const ListTablesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

dms-enterprise/src/model/ListSensitiveColumnsDetailRequest.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/dms-enterprise/model/ListSensitiveColumnsDetailRequest.h>
+
+using AlibabaCloud::Dms_enterprise::Model::ListSensitiveColumnsDetailRequest;
+
+ListSensitiveColumnsDetailRequest::ListSensitiveColumnsDetailRequest() :
+	RpcServiceRequest("dms-enterprise", "2018-11-01", "ListSensitiveColumnsDetail")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListSensitiveColumnsDetailRequest::~ListSensitiveColumnsDetailRequest()
+{}
+
+std::string ListSensitiveColumnsDetailRequest::getSchemaName()const
+{
+	return schemaName_;
+}
+
+void ListSensitiveColumnsDetailRequest::setSchemaName(const std::string& schemaName)
+{
+	schemaName_ = schemaName;
+	setParameter("SchemaName", schemaName);
+}
+
+std::string ListSensitiveColumnsDetailRequest::getTableName()const
+{
+	return tableName_;
+}
+
+void ListSensitiveColumnsDetailRequest::setTableName(const std::string& tableName)
+{
+	tableName_ = tableName;
+	setParameter("TableName", tableName);
+}
+
+std::string ListSensitiveColumnsDetailRequest::getColumnName()const
+{
+	return columnName_;
+}
+
+void ListSensitiveColumnsDetailRequest::setColumnName(const std::string& columnName)
+{
+	columnName_ = columnName;
+	setParameter("ColumnName", columnName);
+}
+
+long ListSensitiveColumnsDetailRequest::getTid()const
+{
+	return tid_;
+}
+
+void ListSensitiveColumnsDetailRequest::setTid(long tid)
+{
+	tid_ = tid;
+	setParameter("Tid", std::to_string(tid));
+}
+

dms-enterprise/src/model/ListSensitiveColumnsDetailResult.cc

@@ -0,0 +1,96 @@
+/*
+ * 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/dms-enterprise/model/ListSensitiveColumnsDetailResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dms_enterprise;
+using namespace AlibabaCloud::Dms_enterprise::Model;
+
+ListSensitiveColumnsDetailResult::ListSensitiveColumnsDetailResult() :
+	ServiceResult()
+{}
+
+ListSensitiveColumnsDetailResult::ListSensitiveColumnsDetailResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListSensitiveColumnsDetailResult::~ListSensitiveColumnsDetailResult()
+{}
+
+void ListSensitiveColumnsDetailResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allSensitiveColumnsDetailListNode = value["SensitiveColumnsDetailList"]["SensitiveColumnsDetail"];
+	for (auto valueSensitiveColumnsDetailListSensitiveColumnsDetail : allSensitiveColumnsDetailListNode)
+	{
+		SensitiveColumnsDetail sensitiveColumnsDetailListObject;
+		if(!valueSensitiveColumnsDetailListSensitiveColumnsDetail["SchemaName"].isNull())
+			sensitiveColumnsDetailListObject.schemaName = valueSensitiveColumnsDetailListSensitiveColumnsDetail["SchemaName"].asString();
+		if(!valueSensitiveColumnsDetailListSensitiveColumnsDetail["TableName"].isNull())
+			sensitiveColumnsDetailListObject.tableName = valueSensitiveColumnsDetailListSensitiveColumnsDetail["TableName"].asString();
+		if(!valueSensitiveColumnsDetailListSensitiveColumnsDetail["ColumnName"].isNull())
+			sensitiveColumnsDetailListObject.columnName = valueSensitiveColumnsDetailListSensitiveColumnsDetail["ColumnName"].asString();
+		if(!valueSensitiveColumnsDetailListSensitiveColumnsDetail["SearchName"].isNull())
+			sensitiveColumnsDetailListObject.searchName = valueSensitiveColumnsDetailListSensitiveColumnsDetail["SearchName"].asString();
+		if(!valueSensitiveColumnsDetailListSensitiveColumnsDetail["DbId"].isNull())
+			sensitiveColumnsDetailListObject.dbId = std::stol(valueSensitiveColumnsDetailListSensitiveColumnsDetail["DbId"].asString());
+		if(!valueSensitiveColumnsDetailListSensitiveColumnsDetail["EnvType"].isNull())
+			sensitiveColumnsDetailListObject.envType = valueSensitiveColumnsDetailListSensitiveColumnsDetail["EnvType"].asString();
+		if(!valueSensitiveColumnsDetailListSensitiveColumnsDetail["DbType"].isNull())
+			sensitiveColumnsDetailListObject.dbType = valueSensitiveColumnsDetailListSensitiveColumnsDetail["DbType"].asString();
+		if(!valueSensitiveColumnsDetailListSensitiveColumnsDetail["Logic"].isNull())
+			sensitiveColumnsDetailListObject.logic = valueSensitiveColumnsDetailListSensitiveColumnsDetail["Logic"].asString() == "true";
+		if(!valueSensitiveColumnsDetailListSensitiveColumnsDetail["ColumnType"].isNull())
+			sensitiveColumnsDetailListObject.columnType = valueSensitiveColumnsDetailListSensitiveColumnsDetail["ColumnType"].asString();
+		if(!valueSensitiveColumnsDetailListSensitiveColumnsDetail["ColumnDescription"].isNull())
+			sensitiveColumnsDetailListObject.columnDescription = valueSensitiveColumnsDetailListSensitiveColumnsDetail["ColumnDescription"].asString();
+		sensitiveColumnsDetailList_.push_back(sensitiveColumnsDetailListObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+
+}
+
+std::vector<ListSensitiveColumnsDetailResult::SensitiveColumnsDetail> ListSensitiveColumnsDetailResult::getSensitiveColumnsDetailList()const
+{
+	return sensitiveColumnsDetailList_;
+}
+
+std::string ListSensitiveColumnsDetailResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListSensitiveColumnsDetailResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool ListSensitiveColumnsDetailResult::getSuccess()const
+{
+	return success_;
+}
+

dms-enterprise/src/model/ListSensitiveColumnsRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dms-enterprise/model/ListSensitiveColumnsRequest.h>
+
+using AlibabaCloud::Dms_enterprise::Model::ListSensitiveColumnsRequest;
+
+ListSensitiveColumnsRequest::ListSensitiveColumnsRequest() :
+	RpcServiceRequest("dms-enterprise", "2018-11-01", "ListSensitiveColumns")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListSensitiveColumnsRequest::~ListSensitiveColumnsRequest()
+{}
+
+std::string ListSensitiveColumnsRequest::getSchemaName()const
+{
+	return schemaName_;
+}
+
+void ListSensitiveColumnsRequest::setSchemaName(const std::string& schemaName)
+{
+	schemaName_ = schemaName;
+	setParameter("SchemaName", schemaName);
+}
+
+std::string ListSensitiveColumnsRequest::getSecurityLevel()const
+{
+	return securityLevel_;
+}
+
+void ListSensitiveColumnsRequest::setSecurityLevel(const std::string& securityLevel)
+{
+	securityLevel_ = securityLevel;
+	setParameter("SecurityLevel", securityLevel);
+}
+
+int ListSensitiveColumnsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListSensitiveColumnsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string ListSensitiveColumnsRequest::getTableName()const
+{
+	return tableName_;
+}
+
+void ListSensitiveColumnsRequest::setTableName(const std::string& tableName)
+{
+	tableName_ = tableName;
+	setParameter("TableName", tableName);
+}
+
+std::string ListSensitiveColumnsRequest::getColumnName()const
+{
+	return columnName_;
+}
+
+void ListSensitiveColumnsRequest::setColumnName(const std::string& columnName)
+{
+	columnName_ = columnName;
+	setParameter("ColumnName", columnName);
+}
+
+long ListSensitiveColumnsRequest::getTid()const
+{
+	return tid_;
+}
+
+void ListSensitiveColumnsRequest::setTid(long tid)
+{
+	tid_ = tid;
+	setParameter("Tid", std::to_string(tid));
+}
+
+int ListSensitiveColumnsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListSensitiveColumnsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+

dms-enterprise/src/model/ListSensitiveColumnsResult.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/dms-enterprise/model/ListSensitiveColumnsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dms_enterprise;
+using namespace AlibabaCloud::Dms_enterprise::Model;
+
+ListSensitiveColumnsResult::ListSensitiveColumnsResult() :
+	ServiceResult()
+{}
+
+ListSensitiveColumnsResult::ListSensitiveColumnsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListSensitiveColumnsResult::~ListSensitiveColumnsResult()
+{}
+
+void ListSensitiveColumnsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allSensitiveColumnListNode = value["SensitiveColumnList"]["SensitiveColumn"];
+	for (auto valueSensitiveColumnListSensitiveColumn : allSensitiveColumnListNode)
+	{
+		SensitiveColumn sensitiveColumnListObject;
+		if(!valueSensitiveColumnListSensitiveColumn["SchemaName"].isNull())
+			sensitiveColumnListObject.schemaName = valueSensitiveColumnListSensitiveColumn["SchemaName"].asString();
+		if(!valueSensitiveColumnListSensitiveColumn["TableName"].isNull())
+			sensitiveColumnListObject.tableName = valueSensitiveColumnListSensitiveColumn["TableName"].asString();
+		if(!valueSensitiveColumnListSensitiveColumn["ColumnName"].isNull())
+			sensitiveColumnListObject.columnName = valueSensitiveColumnListSensitiveColumn["ColumnName"].asString();
+		if(!valueSensitiveColumnListSensitiveColumn["SecurityLevel"].isNull())
+			sensitiveColumnListObject.securityLevel = valueSensitiveColumnListSensitiveColumn["SecurityLevel"].asString();
+		if(!valueSensitiveColumnListSensitiveColumn["ColumnCount"].isNull())
+			sensitiveColumnListObject.columnCount = std::stol(valueSensitiveColumnListSensitiveColumn["ColumnCount"].asString());
+		if(!valueSensitiveColumnListSensitiveColumn["FunctionType"].isNull())
+			sensitiveColumnListObject.functionType = valueSensitiveColumnListSensitiveColumn["FunctionType"].asString();
+		sensitiveColumnList_.push_back(sensitiveColumnListObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+
+}
+
+long ListSensitiveColumnsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::string ListSensitiveColumnsResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListSensitiveColumnsResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+std::vector<ListSensitiveColumnsResult::SensitiveColumn> ListSensitiveColumnsResult::getSensitiveColumnList()const
+{
+	return sensitiveColumnList_;
+}
+
+bool ListSensitiveColumnsResult::getSuccess()const
+{
+	return success_;
+}
+

dms-enterprise/src/model/ListUsersResult.cc

@@ -55,6 +55,16 @@ void ListUsersResult::parse(const std::string &payload)
 			userListObject.parentUid = std::stol(valueUserListUser["ParentUid"].asString());
 		if(!valueUserListUser["State"].isNull())
 			userListObject.state = valueUserListUser["State"].asString();
+		if(!valueUserListUser["LastLoginTime"].isNull())
+			userListObject.lastLoginTime = valueUserListUser["LastLoginTime"].asString();
+		if(!valueUserListUser["CurExecuteCount"].isNull())
+			userListObject.curExecuteCount = std::stol(valueUserListUser["CurExecuteCount"].asString());
+		if(!valueUserListUser["CurResultCount"].isNull())
+			userListObject.curResultCount = std::stol(valueUserListUser["CurResultCount"].asString());
+		if(!valueUserListUser["MaxExecuteCount"].isNull())
+			userListObject.maxExecuteCount = std::stol(valueUserListUser["MaxExecuteCount"].asString());
+		if(!valueUserListUser["MaxResultCount"].isNull())
+			userListObject.maxResultCount = std::stol(valueUserListUser["MaxResultCount"].asString());
 		auto allRoleIdList = value["RoleIdList"]["RoleIds"];
 		for (auto value : allRoleIdList)
 			userListObject.roleIdList.push_back(value.asString());

dms-enterprise/src/model/ListWorkFlowTemplatesResult.cc

@@ -53,6 +53,8 @@ void ListWorkFlowTemplatesResult::parse(const std::string &payload)
 			workFlowTemplatesObject.isSystem = std::stoi(valueWorkFlowTemplatesWorkFlowTemplate["IsSystem"].asString());
 		if(!valueWorkFlowTemplatesWorkFlowTemplate["Enabled"].isNull())
 			workFlowTemplatesObject.enabled = valueWorkFlowTemplatesWorkFlowTemplate["Enabled"].asString();
+		if(!valueWorkFlowTemplatesWorkFlowTemplate["CreateUserId"].isNull())
+			workFlowTemplatesObject.createUserId = std::stol(valueWorkFlowTemplatesWorkFlowTemplate["CreateUserId"].asString());
 		auto allWorkflowNodesNode = allWorkFlowTemplatesNode["WorkflowNodes"]["WorkflowNode"];
 		for (auto allWorkFlowTemplatesNodeWorkflowNodesWorkflowNode : allWorkflowNodesNode)
 		{
@@ -69,6 +71,8 @@ void ListWorkFlowTemplatesResult::parse(const std::string &payload)
 				workflowNodesObject.comment = allWorkFlowTemplatesNodeWorkflowNodesWorkflowNode["Comment"].asString();
 			if(!allWorkFlowTemplatesNodeWorkflowNodesWorkflowNode["Position"].isNull())
 				workflowNodesObject.position = std::stoi(allWorkFlowTemplatesNodeWorkflowNodesWorkflowNode["Position"].asString());
+			if(!allWorkFlowTemplatesNodeWorkflowNodesWorkflowNode["CreateUserId"].isNull())
+				workflowNodesObject.createUserId = std::stol(allWorkFlowTemplatesNodeWorkflowNodesWorkflowNode["CreateUserId"].asString());
 			workFlowTemplatesObject.workflowNodes.push_back(workflowNodesObject);
 		}
 		workFlowTemplates_.push_back(workFlowTemplatesObject);

dms-enterprise/src/model/UpdateUserRequest.cc

@@ -49,6 +49,28 @@ void UpdateUserRequest::setUid(long uid)
 	setParameter("Uid", std::to_string(uid));
 }
 
+long UpdateUserRequest::getMaxResultCount()const
+{
+	return maxResultCount_;
+}
+
+void UpdateUserRequest::setMaxResultCount(long maxResultCount)
+{
+	maxResultCount_ = maxResultCount;
+	setParameter("MaxResultCount", std::to_string(maxResultCount));
+}
+
+long UpdateUserRequest::getMaxExecuteCount()const
+{
+	return maxExecuteCount_;
+}
+
+void UpdateUserRequest::setMaxExecuteCount(long maxExecuteCount)
+{
+	maxExecuteCount_ = maxExecuteCount;
+	setParameter("MaxExecuteCount", std::to_string(maxExecuteCount));
+}
+
 std::string UpdateUserRequest::getUserNick()const
 {
 	return userNick_;