Support ListSensitiveColumns, ListSensitiveColumnsDetail API.

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_;