From 18dc3cd7d9dfee3408cc644f4d636721341bffb7 Mon Sep 17 00:00:00 2001 From: sdk-team Date: Tue, 14 Apr 2020 21:52:24 +0800 Subject: [PATCH] Support ListSensitiveColumns, ListSensitiveColumnsDetail API. --- CHANGELOG | 6 + VERSION | 2 +- dms-enterprise/CMakeLists.txt | 8 ++ .../dms-enterprise/Dms_enterpriseClient.h | 16 +++ .../model/ListSensitiveColumnsDetailRequest.h | 57 ++++++++++ .../model/ListSensitiveColumnsDetailResult.h | 70 ++++++++++++ .../model/ListSensitiveColumnsRequest.h | 66 +++++++++++ .../model/ListSensitiveColumnsResult.h | 68 +++++++++++ .../dms-enterprise/model/ListUsersResult.h | 13 ++- .../model/ListWorkFlowTemplatesResult.h | 2 + .../dms-enterprise/model/UpdateUserRequest.h | 6 + dms-enterprise/src/Dms-enterpriseClient.cc | 78 ++++++++++++- .../ListSensitiveColumnsDetailRequest.cc | 73 ++++++++++++ .../model/ListSensitiveColumnsDetailResult.cc | 96 ++++++++++++++++ .../src/model/ListSensitiveColumnsRequest.cc | 106 ++++++++++++++++++ .../src/model/ListSensitiveColumnsResult.cc | 95 ++++++++++++++++ dms-enterprise/src/model/ListUsersResult.cc | 10 ++ .../src/model/ListWorkFlowTemplatesResult.cc | 4 + dms-enterprise/src/model/UpdateUserRequest.cc | 22 ++++ 19 files changed, 790 insertions(+), 8 deletions(-) create mode 100644 dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsDetailRequest.h create mode 100644 dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsDetailResult.h create mode 100644 dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsRequest.h create mode 100644 dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsResult.h create mode 100644 dms-enterprise/src/model/ListSensitiveColumnsDetailRequest.cc create mode 100644 dms-enterprise/src/model/ListSensitiveColumnsDetailResult.cc create mode 100644 dms-enterprise/src/model/ListSensitiveColumnsRequest.cc create mode 100644 dms-enterprise/src/model/ListSensitiveColumnsResult.cc diff --git a/CHANGELOG b/CHANGELOG index a5dd9e32e..81bc45b35 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,9 @@ +2020-04-14 Version: 1.36.355 +- Support ListSensitiveColumns, ListSensitiveColumnsDetail API. +- ListUsers API return user execute query count information. +- Fix ListWorkFlowTemplates to return create user information. +- UpdateUser API support to update user max execute query count. + 2020-04-14 Version: 1.36.354 - Supported CreateSegmentBodyJob. diff --git a/VERSION b/VERSION index 5674f8c88..f6ab52434 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.354 \ No newline at end of file +1.36.355 \ No newline at end of file diff --git a/dms-enterprise/CMakeLists.txt b/dms-enterprise/CMakeLists.txt index 75fa309b1..446399e34 100644 --- a/dms-enterprise/CMakeLists.txt +++ b/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 diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/Dms_enterpriseClient.h b/dms-enterprise/include/alibabacloud/dms-enterprise/Dms_enterpriseClient.h index f2c93b2f3..0f49d40ba 100644 --- a/dms-enterprise/include/alibabacloud/dms-enterprise/Dms_enterpriseClient.h +++ b/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 ListOrdersOutcome; typedef std::future ListOrdersOutcomeCallable; typedef std::function&)> ListOrdersAsyncHandler; + typedef Outcome ListSensitiveColumnsOutcome; + typedef std::future ListSensitiveColumnsOutcomeCallable; + typedef std::function&)> ListSensitiveColumnsAsyncHandler; + typedef Outcome ListSensitiveColumnsDetailOutcome; + typedef std::future ListSensitiveColumnsDetailOutcomeCallable; + typedef std::function&)> ListSensitiveColumnsDetailAsyncHandler; typedef Outcome ListTablesOutcome; typedef std::future ListTablesOutcomeCallable; typedef std::function&)> 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& 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& 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& 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& context = nullptr) const; ListTablesOutcomeCallable listTablesCallable(const Model::ListTablesRequest& request) const; diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsDetailRequest.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsDetailRequest.h new file mode 100644 index 000000000..a601c09ee --- /dev/null +++ b/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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsDetailResult.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsDetailResult.h new file mode 100644 index 000000000..7a0aad778 --- /dev/null +++ b/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 +#include +#include +#include +#include + +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 getSensitiveColumnsDetailList()const; + std::string getErrorCode()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::vector sensitiveColumnsDetailList_; + std::string errorCode_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DMS_ENTERPRISE_MODEL_LISTSENSITIVECOLUMNSDETAILRESULT_H_ \ No newline at end of file diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsRequest.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsRequest.h new file mode 100644 index 000000000..12b340f4a --- /dev/null +++ b/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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsResult.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListSensitiveColumnsResult.h new file mode 100644 index 000000000..619a7312d --- /dev/null +++ b/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 +#include +#include +#include +#include + +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 getSensitiveColumnList()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + long totalCount_; + std::string errorCode_; + std::string errorMessage_; + std::vector sensitiveColumnList_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DMS_ENTERPRISE_MODEL_LISTSENSITIVECOLUMNSRESULT_H_ \ No newline at end of file diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListUsersResult.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListUsersResult.h index e93e272cf..1c12d390d 100644 --- a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListUsersResult.h +++ b/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListUsersResult.h @@ -34,13 +34,18 @@ namespace AlibabaCloud public: struct User { - long uid; - std::vector roleIdList; - std::string userId; - std::string state; std::vector roleNameList; std::string nickName; std::string mobile; + long maxExecuteCount; + long uid; + std::string lastLoginTime; + long curResultCount; + std::vector roleIdList; + long maxResultCount; + std::string userId; + std::string state; + long curExecuteCount; long parentUid; }; diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListWorkFlowTemplatesResult.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListWorkFlowTemplatesResult.h index c0eaf69c3..3a1e65ede 100644 --- a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListWorkFlowTemplatesResult.h +++ b/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 workflowNodes; long templateId; diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/UpdateUserRequest.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/UpdateUserRequest.h index 153882414..7426292e5 100644 --- a/dms-enterprise/include/alibabacloud/dms-enterprise/model/UpdateUserRequest.h +++ b/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_; diff --git a/dms-enterprise/src/Dms-enterpriseClient.cc b/dms-enterprise/src/Dms-enterpriseClient.cc index 7d5b7826a..137eac6f9 100644 --- a/dms-enterprise/src/Dms-enterpriseClient.cc +++ b/dms-enterprise/src/Dms-enterpriseClient.cc @@ -31,21 +31,21 @@ Dms_enterpriseClient::Dms_enterpriseClient(const Credentials &credentials, const RpcServiceClient(SERVICE_NAME, std::make_shared(credentials), configuration) { auto locationClient = std::make_shared(credentials, configuration); - endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, "dmsenterprise"); } Dms_enterpriseClient::Dms_enterpriseClient(const std::shared_ptr& credentialsProvider, const ClientConfiguration & configuration) : RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration) { auto locationClient = std::make_shared(credentialsProvider, configuration); - endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); + endpointProvider_ = std::make_shared(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(accessKeyId, accessKeySecret), configuration) { auto locationClient = std::make_shared(accessKeyId, accessKeySecret, configuration); - endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); + endpointProvider_ = std::make_shared(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& 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>( + [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& 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>( + [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(); diff --git a/dms-enterprise/src/model/ListSensitiveColumnsDetailRequest.cc b/dms-enterprise/src/model/ListSensitiveColumnsDetailRequest.cc new file mode 100644 index 000000000..6e96939dd --- /dev/null +++ b/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 + +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)); +} + diff --git a/dms-enterprise/src/model/ListSensitiveColumnsDetailResult.cc b/dms-enterprise/src/model/ListSensitiveColumnsDetailResult.cc new file mode 100644 index 000000000..eb3f7e1f2 --- /dev/null +++ b/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 +#include + +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::getSensitiveColumnsDetailList()const +{ + return sensitiveColumnsDetailList_; +} + +std::string ListSensitiveColumnsDetailResult::getErrorCode()const +{ + return errorCode_; +} + +std::string ListSensitiveColumnsDetailResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool ListSensitiveColumnsDetailResult::getSuccess()const +{ + return success_; +} + diff --git a/dms-enterprise/src/model/ListSensitiveColumnsRequest.cc b/dms-enterprise/src/model/ListSensitiveColumnsRequest.cc new file mode 100644 index 000000000..be849c103 --- /dev/null +++ b/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 + +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)); +} + diff --git a/dms-enterprise/src/model/ListSensitiveColumnsResult.cc b/dms-enterprise/src/model/ListSensitiveColumnsResult.cc new file mode 100644 index 000000000..2e31c99e4 --- /dev/null +++ b/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 +#include + +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::getSensitiveColumnList()const +{ + return sensitiveColumnList_; +} + +bool ListSensitiveColumnsResult::getSuccess()const +{ + return success_; +} + diff --git a/dms-enterprise/src/model/ListUsersResult.cc b/dms-enterprise/src/model/ListUsersResult.cc index 975c3bbe5..abf77ea4a 100644 --- a/dms-enterprise/src/model/ListUsersResult.cc +++ b/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()); diff --git a/dms-enterprise/src/model/ListWorkFlowTemplatesResult.cc b/dms-enterprise/src/model/ListWorkFlowTemplatesResult.cc index 25a6a7692..d79bf5ecf 100644 --- a/dms-enterprise/src/model/ListWorkFlowTemplatesResult.cc +++ b/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); diff --git a/dms-enterprise/src/model/UpdateUserRequest.cc b/dms-enterprise/src/model/UpdateUserRequest.cc index 5f936f87a..c7e934adb 100644 --- a/dms-enterprise/src/model/UpdateUserRequest.cc +++ b/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_;