Add QueryAuditLog, QueryApprovalInfo, DataSourceBlood, DataSetBlood and QueryDataServiceList APIs.

VERSION

@@ -1 +1 @@
-1.36.1941
+1.36.1942

quickbi-public/CMakeLists.txt

@@ -61,6 +61,10 @@ set(quickbi-public_public_header_model
 	include/alibabacloud/quickbi-public/model/CreateTicket4CopilotResult.h
 	include/alibabacloud/quickbi-public/model/CreateUserGroupRequest.h
 	include/alibabacloud/quickbi-public/model/CreateUserGroupResult.h
+	include/alibabacloud/quickbi-public/model/DataSetBloodRequest.h
+	include/alibabacloud/quickbi-public/model/DataSetBloodResult.h
+	include/alibabacloud/quickbi-public/model/DataSourceBloodRequest.h
+	include/alibabacloud/quickbi-public/model/DataSourceBloodResult.h
 	include/alibabacloud/quickbi-public/model/DelayTicketExpireTimeRequest.h
 	include/alibabacloud/quickbi-public/model/DelayTicketExpireTimeResult.h
 	include/alibabacloud/quickbi-public/model/DeleteDataLevelPermissionRuleUsersRequest.h
@@ -115,6 +119,10 @@ set(quickbi-public_public_header_model
 	include/alibabacloud/quickbi-public/model/ListWorkspaceRolesResult.h
 	include/alibabacloud/quickbi-public/model/ModifyApiDatasourceParametersRequest.h
 	include/alibabacloud/quickbi-public/model/ModifyApiDatasourceParametersResult.h
+	include/alibabacloud/quickbi-public/model/QueryApprovalInfoRequest.h
+	include/alibabacloud/quickbi-public/model/QueryApprovalInfoResult.h
+	include/alibabacloud/quickbi-public/model/QueryAuditLogRequest.h
+	include/alibabacloud/quickbi-public/model/QueryAuditLogResult.h
 	include/alibabacloud/quickbi-public/model/QueryComponentPerformanceRequest.h
 	include/alibabacloud/quickbi-public/model/QueryComponentPerformanceResult.h
 	include/alibabacloud/quickbi-public/model/QueryCubeOptimizationRequest.h
@@ -123,6 +131,8 @@ set(quickbi-public_public_header_model
 	include/alibabacloud/quickbi-public/model/QueryCubePerformanceResult.h
 	include/alibabacloud/quickbi-public/model/QueryDataServiceRequest.h
 	include/alibabacloud/quickbi-public/model/QueryDataServiceResult.h
+	include/alibabacloud/quickbi-public/model/QueryDataServiceListRequest.h
+	include/alibabacloud/quickbi-public/model/QueryDataServiceListResult.h
 	include/alibabacloud/quickbi-public/model/QueryDatasetDetailInfoRequest.h
 	include/alibabacloud/quickbi-public/model/QueryDatasetDetailInfoResult.h
 	include/alibabacloud/quickbi-public/model/QueryDatasetInfoRequest.h
@@ -250,6 +260,10 @@ set(quickbi-public_src
 	src/model/CreateTicket4CopilotResult.cc
 	src/model/CreateUserGroupRequest.cc
 	src/model/CreateUserGroupResult.cc
+	src/model/DataSetBloodRequest.cc
+	src/model/DataSetBloodResult.cc
+	src/model/DataSourceBloodRequest.cc
+	src/model/DataSourceBloodResult.cc
 	src/model/DelayTicketExpireTimeRequest.cc
 	src/model/DelayTicketExpireTimeResult.cc
 	src/model/DeleteDataLevelPermissionRuleUsersRequest.cc
@@ -304,6 +318,10 @@ set(quickbi-public_src
 	src/model/ListWorkspaceRolesResult.cc
 	src/model/ModifyApiDatasourceParametersRequest.cc
 	src/model/ModifyApiDatasourceParametersResult.cc
+	src/model/QueryApprovalInfoRequest.cc
+	src/model/QueryApprovalInfoResult.cc
+	src/model/QueryAuditLogRequest.cc
+	src/model/QueryAuditLogResult.cc
 	src/model/QueryComponentPerformanceRequest.cc
 	src/model/QueryComponentPerformanceResult.cc
 	src/model/QueryCubeOptimizationRequest.cc
@@ -312,6 +330,8 @@ set(quickbi-public_src
 	src/model/QueryCubePerformanceResult.cc
 	src/model/QueryDataServiceRequest.cc
 	src/model/QueryDataServiceResult.cc
+	src/model/QueryDataServiceListRequest.cc
+	src/model/QueryDataServiceListResult.cc
 	src/model/QueryDatasetDetailInfoRequest.cc
 	src/model/QueryDatasetDetailInfoResult.cc
 	src/model/QueryDatasetInfoRequest.cc

quickbi-public/include/alibabacloud/quickbi-public/Quickbi_publicClient.h

@@ -62,6 +62,10 @@
 #include "model/CreateTicket4CopilotResult.h"
 #include "model/CreateUserGroupRequest.h"
 #include "model/CreateUserGroupResult.h"
+#include "model/DataSetBloodRequest.h"
+#include "model/DataSetBloodResult.h"
+#include "model/DataSourceBloodRequest.h"
+#include "model/DataSourceBloodResult.h"
 #include "model/DelayTicketExpireTimeRequest.h"
 #include "model/DelayTicketExpireTimeResult.h"
 #include "model/DeleteDataLevelPermissionRuleUsersRequest.h"
@@ -116,6 +120,10 @@
 #include "model/ListWorkspaceRolesResult.h"
 #include "model/ModifyApiDatasourceParametersRequest.h"
 #include "model/ModifyApiDatasourceParametersResult.h"
+#include "model/QueryApprovalInfoRequest.h"
+#include "model/QueryApprovalInfoResult.h"
+#include "model/QueryAuditLogRequest.h"
+#include "model/QueryAuditLogResult.h"
 #include "model/QueryComponentPerformanceRequest.h"
 #include "model/QueryComponentPerformanceResult.h"
 #include "model/QueryCubeOptimizationRequest.h"
@@ -124,6 +132,8 @@
 #include "model/QueryCubePerformanceResult.h"
 #include "model/QueryDataServiceRequest.h"
 #include "model/QueryDataServiceResult.h"
+#include "model/QueryDataServiceListRequest.h"
+#include "model/QueryDataServiceListResult.h"
 #include "model/QueryDatasetDetailInfoRequest.h"
 #include "model/QueryDatasetDetailInfoResult.h"
 #include "model/QueryDatasetInfoRequest.h"
@@ -277,6 +287,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateUserGroupResult> CreateUserGroupOutcome;
 			typedef std::future<CreateUserGroupOutcome> CreateUserGroupOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::CreateUserGroupRequest&, const CreateUserGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateUserGroupAsyncHandler;
+			typedef Outcome<Error, Model::DataSetBloodResult> DataSetBloodOutcome;
+			typedef std::future<DataSetBloodOutcome> DataSetBloodOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::DataSetBloodRequest&, const DataSetBloodOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DataSetBloodAsyncHandler;
+			typedef Outcome<Error, Model::DataSourceBloodResult> DataSourceBloodOutcome;
+			typedef std::future<DataSourceBloodOutcome> DataSourceBloodOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::DataSourceBloodRequest&, const DataSourceBloodOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DataSourceBloodAsyncHandler;
 			typedef Outcome<Error, Model::DelayTicketExpireTimeResult> DelayTicketExpireTimeOutcome;
 			typedef std::future<DelayTicketExpireTimeOutcome> DelayTicketExpireTimeOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::DelayTicketExpireTimeRequest&, const DelayTicketExpireTimeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DelayTicketExpireTimeAsyncHandler;
@@ -358,6 +374,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyApiDatasourceParametersResult> ModifyApiDatasourceParametersOutcome;
 			typedef std::future<ModifyApiDatasourceParametersOutcome> ModifyApiDatasourceParametersOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::ModifyApiDatasourceParametersRequest&, const ModifyApiDatasourceParametersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyApiDatasourceParametersAsyncHandler;
+			typedef Outcome<Error, Model::QueryApprovalInfoResult> QueryApprovalInfoOutcome;
+			typedef std::future<QueryApprovalInfoOutcome> QueryApprovalInfoOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryApprovalInfoRequest&, const QueryApprovalInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryApprovalInfoAsyncHandler;
+			typedef Outcome<Error, Model::QueryAuditLogResult> QueryAuditLogOutcome;
+			typedef std::future<QueryAuditLogOutcome> QueryAuditLogOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryAuditLogRequest&, const QueryAuditLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryAuditLogAsyncHandler;
 			typedef Outcome<Error, Model::QueryComponentPerformanceResult> QueryComponentPerformanceOutcome;
 			typedef std::future<QueryComponentPerformanceOutcome> QueryComponentPerformanceOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryComponentPerformanceRequest&, const QueryComponentPerformanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryComponentPerformanceAsyncHandler;
@@ -370,6 +392,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::QueryDataServiceResult> QueryDataServiceOutcome;
 			typedef std::future<QueryDataServiceOutcome> QueryDataServiceOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryDataServiceRequest&, const QueryDataServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryDataServiceAsyncHandler;
+			typedef Outcome<Error, Model::QueryDataServiceListResult> QueryDataServiceListOutcome;
+			typedef std::future<QueryDataServiceListOutcome> QueryDataServiceListOutcomeCallable;
+			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryDataServiceListRequest&, const QueryDataServiceListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryDataServiceListAsyncHandler;
 			typedef Outcome<Error, Model::QueryDatasetDetailInfoResult> QueryDatasetDetailInfoOutcome;
 			typedef std::future<QueryDatasetDetailInfoOutcome> QueryDatasetDetailInfoOutcomeCallable;
 			typedef std::function<void(const Quickbi_publicClient*, const Model::QueryDatasetDetailInfoRequest&, const QueryDatasetDetailInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryDatasetDetailInfoAsyncHandler;
@@ -561,6 +586,12 @@ namespace AlibabaCloud
 			CreateUserGroupOutcome createUserGroup(const Model::CreateUserGroupRequest &request)const;
 			void createUserGroupAsync(const Model::CreateUserGroupRequest& request, const CreateUserGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateUserGroupOutcomeCallable createUserGroupCallable(const Model::CreateUserGroupRequest& request) const;
+			DataSetBloodOutcome dataSetBlood(const Model::DataSetBloodRequest &request)const;
+			void dataSetBloodAsync(const Model::DataSetBloodRequest& request, const DataSetBloodAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DataSetBloodOutcomeCallable dataSetBloodCallable(const Model::DataSetBloodRequest& request) const;
+			DataSourceBloodOutcome dataSourceBlood(const Model::DataSourceBloodRequest &request)const;
+			void dataSourceBloodAsync(const Model::DataSourceBloodRequest& request, const DataSourceBloodAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DataSourceBloodOutcomeCallable dataSourceBloodCallable(const Model::DataSourceBloodRequest& request) const;
 			DelayTicketExpireTimeOutcome delayTicketExpireTime(const Model::DelayTicketExpireTimeRequest &request)const;
 			void delayTicketExpireTimeAsync(const Model::DelayTicketExpireTimeRequest& request, const DelayTicketExpireTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DelayTicketExpireTimeOutcomeCallable delayTicketExpireTimeCallable(const Model::DelayTicketExpireTimeRequest& request) const;
@@ -642,6 +673,12 @@ namespace AlibabaCloud
 			ModifyApiDatasourceParametersOutcome modifyApiDatasourceParameters(const Model::ModifyApiDatasourceParametersRequest &request)const;
 			void modifyApiDatasourceParametersAsync(const Model::ModifyApiDatasourceParametersRequest& request, const ModifyApiDatasourceParametersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyApiDatasourceParametersOutcomeCallable modifyApiDatasourceParametersCallable(const Model::ModifyApiDatasourceParametersRequest& request) const;
+			QueryApprovalInfoOutcome queryApprovalInfo(const Model::QueryApprovalInfoRequest &request)const;
+			void queryApprovalInfoAsync(const Model::QueryApprovalInfoRequest& request, const QueryApprovalInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryApprovalInfoOutcomeCallable queryApprovalInfoCallable(const Model::QueryApprovalInfoRequest& request) const;
+			QueryAuditLogOutcome queryAuditLog(const Model::QueryAuditLogRequest &request)const;
+			void queryAuditLogAsync(const Model::QueryAuditLogRequest& request, const QueryAuditLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryAuditLogOutcomeCallable queryAuditLogCallable(const Model::QueryAuditLogRequest& request) const;
 			QueryComponentPerformanceOutcome queryComponentPerformance(const Model::QueryComponentPerformanceRequest &request)const;
 			void queryComponentPerformanceAsync(const Model::QueryComponentPerformanceRequest& request, const QueryComponentPerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryComponentPerformanceOutcomeCallable queryComponentPerformanceCallable(const Model::QueryComponentPerformanceRequest& request) const;
@@ -654,6 +691,9 @@ namespace AlibabaCloud
 			QueryDataServiceOutcome queryDataService(const Model::QueryDataServiceRequest &request)const;
 			void queryDataServiceAsync(const Model::QueryDataServiceRequest& request, const QueryDataServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryDataServiceOutcomeCallable queryDataServiceCallable(const Model::QueryDataServiceRequest& request) const;
+			QueryDataServiceListOutcome queryDataServiceList(const Model::QueryDataServiceListRequest &request)const;
+			void queryDataServiceListAsync(const Model::QueryDataServiceListRequest& request, const QueryDataServiceListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryDataServiceListOutcomeCallable queryDataServiceListCallable(const Model::QueryDataServiceListRequest& request) const;
 			QueryDatasetDetailInfoOutcome queryDatasetDetailInfo(const Model::QueryDatasetDetailInfoRequest &request)const;
 			void queryDatasetDetailInfoAsync(const Model::QueryDatasetDetailInfoRequest& request, const QueryDatasetDetailInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			QueryDatasetDetailInfoOutcomeCallable queryDatasetDetailInfoCallable(const Model::QueryDatasetDetailInfoRequest& request) const;

quickbi-public/include/alibabacloud/quickbi-public/model/DataSetBloodRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASETBLOODREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASETBLOODREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT DataSetBloodRequest : public RpcServiceRequest {
+public:
+	DataSetBloodRequest();
+	~DataSetBloodRequest();
+	std::string getDataSetIds() const;
+	void setDataSetIds(const std::string &dataSetIds);
+	std::string getWorksType() const;
+	void setWorksType(const std::string &worksType);
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+
+private:
+	std::string dataSetIds_;
+	std::string worksType_;
+	std::string accessPoint_;
+	std::string signType_;
+	std::string userId_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASETBLOODREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/DataSetBloodResult.h

@@ -0,0 +1,58 @@
+/*
+ * 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_QUICKBI_PUBLIC_MODEL_DATASETBLOODRESULT_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASETBLOODRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Quickbi_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT DataSetBloodResult : public ServiceResult
+			{
+			public:
+				struct WorksModels
+				{
+					std::string worksType;
+					std::string worksId;
+				};
+
+
+				DataSetBloodResult();
+				explicit DataSetBloodResult(const std::string &payload);
+				~DataSetBloodResult();
+				bool getSuccess()const;
+				std::vector<WorksModels> getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+				std::vector<WorksModels> result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASETBLOODRESULT_H_

quickbi-public/include/alibabacloud/quickbi-public/model/DataSourceBloodRequest.h

@@ -0,0 +1,48 @@
+/*
+ * 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_QUICKBI_PUBLIC_MODEL_DATASOURCEBLOODREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASOURCEBLOODREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT DataSourceBloodRequest : public RpcServiceRequest {
+public:
+	DataSourceBloodRequest();
+	~DataSourceBloodRequest();
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getDataSourceId() const;
+	void setDataSourceId(const std::string &dataSourceId);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+
+private:
+	std::string accessPoint_;
+	std::string dataSourceId_;
+	std::string signType_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASOURCEBLOODREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/DataSourceBloodResult.h

@@ -0,0 +1,53 @@
+/*
+ * 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_QUICKBI_PUBLIC_MODEL_DATASOURCEBLOODRESULT_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASOURCEBLOODRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Quickbi_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT DataSourceBloodResult : public ServiceResult
+			{
+			public:
+
+
+				DataSourceBloodResult();
+				explicit DataSourceBloodResult(const std::string &payload);
+				~DataSourceBloodResult();
+				bool getSuccess()const;
+				std::vector<std::string> getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+				std::vector<std::string> result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASOURCEBLOODRESULT_H_

quickbi-public/include/alibabacloud/quickbi-public/model/QueryApprovalInfoRequest.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_QUICKBI_PUBLIC_MODEL_QUERYAPPROVALINFOREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAPPROVALINFOREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryApprovalInfoRequest : public RpcServiceRequest {
+public:
+	QueryApprovalInfoRequest();
+	~QueryApprovalInfoRequest();
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	int getPage() const;
+	void setPage(int page);
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	int getStatus() const;
+	void setStatus(int status);
+
+private:
+	std::string accessPoint_;
+	int pageSize_;
+	std::string signType_;
+	int page_;
+	std::string userId_;
+	int status_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAPPROVALINFOREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/QueryApprovalInfoResult.h

@@ -0,0 +1,81 @@
+/*
+ * 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_QUICKBI_PUBLIC_MODEL_QUERYAPPROVALINFORESULT_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAPPROVALINFORESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Quickbi_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryApprovalInfoResult : public ServiceResult
+			{
+			public:
+				struct Result
+				{
+					struct ApprovalsResultModel
+					{
+						long expireDate;
+						int flagStatus;
+						std::string resourceName;
+						std::string applicantName;
+						long gmtModified;
+						std::string resourceType;
+						std::string handleReason;
+						std::string applyReason;
+						bool deleteFlag;
+						long gmtCreate;
+						std::string resourceId;
+						std::string applicantId;
+						std::string approverId;
+						std::string workspaceName;
+						std::string approverName;
+						std::string applicationId;
+					};
+					int pageSize;
+					int start;
+					int total;
+					std::vector<ApprovalsResultModel> data;
+					int totalPages;
+					int page;
+				};
+
+
+				QueryApprovalInfoResult();
+				explicit QueryApprovalInfoResult(const std::string &payload);
+				~QueryApprovalInfoResult();
+				bool getSuccess()const;
+				Result getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+				Result result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAPPROVALINFORESULT_H_

quickbi-public/include/alibabacloud/quickbi-public/model/QueryAuditLogRequest.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_QUICKBI_PUBLIC_MODEL_QUERYAUDITLOGREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAUDITLOGREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryAuditLogRequest : public RpcServiceRequest {
+public:
+	QueryAuditLogRequest();
+	~QueryAuditLogRequest();
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	std::string getStartDate() const;
+	void setStartDate(const std::string &startDate);
+	std::string getResourceType() const;
+	void setResourceType(const std::string &resourceType);
+	std::string getOperatorTypes() const;
+	void setOperatorTypes(const std::string &operatorTypes);
+	std::string getLogType() const;
+	void setLogType(const std::string &logType);
+	std::string getEndDate() const;
+	void setEndDate(const std::string &endDate);
+	std::string getOperatorId() const;
+	void setOperatorId(const std::string &operatorId);
+	std::string getWorkspaceId() const;
+	void setWorkspaceId(const std::string &workspaceId);
+
+private:
+	std::string accessPoint_;
+	std::string signType_;
+	std::string startDate_;
+	std::string resourceType_;
+	std::string operatorTypes_;
+	std::string logType_;
+	std::string endDate_;
+	std::string operatorId_;
+	std::string workspaceId_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAUDITLOGREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/QueryAuditLogResult.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAUDITLOGRESULT_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAUDITLOGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Quickbi_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryAuditLogResult : public ServiceResult
+			{
+			public:
+				struct LogApiResultModel
+				{
+					std::string operatorAccountName;
+					std::string operatorName;
+					std::string gmtCreate;
+					std::string workspaceId;
+					std::string targetType;
+					std::string targetName;
+					std::string operatorType;
+				};
+
+
+				QueryAuditLogResult();
+				explicit QueryAuditLogResult(const std::string &payload);
+				~QueryAuditLogResult();
+				bool getSuccess()const;
+				std::vector<LogApiResultModel> getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+				std::vector<LogApiResultModel> result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAUDITLOGRESULT_H_

quickbi-public/include/alibabacloud/quickbi-public/model/QueryDataServiceListRequest.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_QUICKBI_PUBLIC_MODEL_QUERYDATASERVICELISTREQUEST_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATASERVICELISTREQUEST_H_
+
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Quickbi_public {
+namespace Model {
+class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryDataServiceListRequest : public RpcServiceRequest {
+public:
+	QueryDataServiceListRequest();
+	~QueryDataServiceListRequest();
+	int getPageNo() const;
+	void setPageNo(int pageNo);
+	std::string getAccessPoint() const;
+	void setAccessPoint(const std::string &accessPoint);
+	std::string getName() const;
+	void setName(const std::string &name);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getSignType() const;
+	void setSignType(const std::string &signType);
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+
+private:
+	int pageNo_;
+	std::string accessPoint_;
+	std::string name_;
+	int pageSize_;
+	std::string signType_;
+	std::string userId_;
+};
+} // namespace Model
+} // namespace Quickbi_public
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATASERVICELISTREQUEST_H_

quickbi-public/include/alibabacloud/quickbi-public/model/QueryDataServiceListResult.h

@@ -0,0 +1,112 @@
+/*
+ * 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_QUICKBI_PUBLIC_MODEL_QUERYDATASERVICELISTRESULT_H_
+#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATASERVICELISTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Quickbi_public
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryDataServiceListResult : public ServiceResult
+			{
+			public:
+				struct Result
+				{
+					struct QueryDataServiceModel
+					{
+						struct Content
+						{
+							struct Filter
+							{
+								std::string type;
+								std::vector<std::string> filters;
+								std::string logicalOperator;
+							};
+							struct SelectFieldModel
+							{
+								struct Field
+								{
+									std::string fid;
+									std::string type;
+									std::string column;
+									std::string dataType;
+									std::string granularity;
+									std::string caption;
+									std::string name;
+								};
+								std::string orderby;
+								Field field;
+								std::string desc;
+								std::string alias;
+								std::string aggregator;
+							};
+							std::string cubeId;
+							std::vector<SelectFieldModel> returnFields;
+							Filter filter;
+							std::string cubeName;
+							bool detail;
+						};
+						std::string ownerName;
+						std::string cubeId;
+						std::string creatorId;
+						std::string modifierName;
+						std::string workspaceId;
+						std::string gmtModified;
+						std::string sid;
+						std::string name;
+						std::string desc;
+						std::string gmtCreate;
+						std::string ownerId;
+						Content content;
+						std::string cubeName;
+						std::string workspaceName;
+						std::string creatorName;
+						std::string modifierId;
+					};
+					int totalNum;
+					int pageNum;
+					int pageSize;
+					std::vector<QueryDataServiceModel> data;
+					int totalPages;
+				};
+
+
+				QueryDataServiceListResult();
+				explicit QueryDataServiceListResult(const std::string &payload);
+				~QueryDataServiceListResult();
+				bool getSuccess()const;
+				Result getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool success_;
+				Result result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATASERVICELISTRESULT_H_

quickbi-public/include/alibabacloud/quickbi-public/model/QueryUserListResult.h

@@ -36,6 +36,7 @@ namespace AlibabaCloud
 				{
 					struct DataItem
 					{
+						long lastLoginTime;
 						std::vector<std::string> roleIdList;
 						std::string email;
 						std::string accountId;
@@ -44,6 +45,7 @@ namespace AlibabaCloud
 						bool adminUser;
 						std::string nickName;
 						int userType;
+						long joinedDate;
 						bool authAdminUser;
 						std::string accountName;
 					};

quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksByOrganizationResult.h

@@ -45,6 +45,7 @@ namespace AlibabaCloud
 						};
 						int status;
 						std::string ownerName;
+						long publicInvalidTime;
 						std::string description;
 						std::string workType;
 						std::string modifyName;
@@ -56,6 +57,7 @@ namespace AlibabaCloud
 						std::string securityLevel;
 						std::string workName;
 						std::string workspaceName;
+						bool publicFlag;
 						std::string worksId;
 						Directory directory;
 					};

quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksByWorkspaceResult.h

@@ -45,6 +45,7 @@ namespace AlibabaCloud
 						};
 						int status;
 						std::string ownerName;
+						long publicInvalidTime;
 						std::string description;
 						std::string workType;
 						std::string modifyName;
@@ -56,6 +57,7 @@ namespace AlibabaCloud
 						std::string securityLevel;
 						std::string workName;
 						std::string workspaceName;
+						bool publicFlag;
 						std::string worksId;
 						Directory directory;
 					};

quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksResult.h

@@ -43,6 +43,7 @@ namespace AlibabaCloud
 					};
 					int status;
 					std::string ownerName;
+					long publicInvalidTime;
 					std::string description;
 					std::string workType;
 					std::string modifyName;
@@ -54,6 +55,7 @@ namespace AlibabaCloud
 					std::string workName;
 					std::string securityLevel;
 					std::string workspaceName;
+					bool publicFlag;
 					std::string worksId;
 					Directory directory;
 				};

quickbi-public/include/alibabacloud/quickbi-public/model/UpdateUserRequest.h

@@ -42,6 +42,8 @@ public:
 	void setSignType(const std::string &signType);
 	std::string getUserId() const;
 	void setUserId(const std::string &userId);
+	bool getIsDeleted() const;
+	void setIsDeleted(bool isDeleted);
 	std::string getRoleIds() const;
 	void setRoleIds(const std::string &roleIds);
 	std::string getPhone() const;
@@ -60,6 +62,7 @@ private:
 	int userType_;
 	std::string signType_;
 	std::string userId_;
+	bool isDeleted_;
 	std::string roleIds_;
 	std::string phone_;
 	std::string nickName_;

quickbi-public/src/Quickbi-publicClient.cc

@@ -771,6 +771,78 @@ Quickbi_publicClient::CreateUserGroupOutcomeCallable Quickbi_publicClient::creat
 	return task->get_future();
 }
 
+Quickbi_publicClient::DataSetBloodOutcome Quickbi_publicClient::dataSetBlood(const DataSetBloodRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DataSetBloodOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DataSetBloodOutcome(DataSetBloodResult(outcome.result()));
+	else
+		return DataSetBloodOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::dataSetBloodAsync(const DataSetBloodRequest& request, const DataSetBloodAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, dataSetBlood(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::DataSetBloodOutcomeCallable Quickbi_publicClient::dataSetBloodCallable(const DataSetBloodRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DataSetBloodOutcome()>>(
+			[this, request]()
+			{
+			return this->dataSetBlood(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Quickbi_publicClient::DataSourceBloodOutcome Quickbi_publicClient::dataSourceBlood(const DataSourceBloodRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DataSourceBloodOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DataSourceBloodOutcome(DataSourceBloodResult(outcome.result()));
+	else
+		return DataSourceBloodOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::dataSourceBloodAsync(const DataSourceBloodRequest& request, const DataSourceBloodAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, dataSourceBlood(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::DataSourceBloodOutcomeCallable Quickbi_publicClient::dataSourceBloodCallable(const DataSourceBloodRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DataSourceBloodOutcome()>>(
+			[this, request]()
+			{
+			return this->dataSourceBlood(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Quickbi_publicClient::DelayTicketExpireTimeOutcome Quickbi_publicClient::delayTicketExpireTime(const DelayTicketExpireTimeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1743,6 +1815,78 @@ Quickbi_publicClient::ModifyApiDatasourceParametersOutcomeCallable Quickbi_publi
 	return task->get_future();
 }
 
+Quickbi_publicClient::QueryApprovalInfoOutcome Quickbi_publicClient::queryApprovalInfo(const QueryApprovalInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryApprovalInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryApprovalInfoOutcome(QueryApprovalInfoResult(outcome.result()));
+	else
+		return QueryApprovalInfoOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::queryApprovalInfoAsync(const QueryApprovalInfoRequest& request, const QueryApprovalInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryApprovalInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::QueryApprovalInfoOutcomeCallable Quickbi_publicClient::queryApprovalInfoCallable(const QueryApprovalInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryApprovalInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->queryApprovalInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Quickbi_publicClient::QueryAuditLogOutcome Quickbi_publicClient::queryAuditLog(const QueryAuditLogRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryAuditLogOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryAuditLogOutcome(QueryAuditLogResult(outcome.result()));
+	else
+		return QueryAuditLogOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::queryAuditLogAsync(const QueryAuditLogRequest& request, const QueryAuditLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryAuditLog(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::QueryAuditLogOutcomeCallable Quickbi_publicClient::queryAuditLogCallable(const QueryAuditLogRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryAuditLogOutcome()>>(
+			[this, request]()
+			{
+			return this->queryAuditLog(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Quickbi_publicClient::QueryComponentPerformanceOutcome Quickbi_publicClient::queryComponentPerformance(const QueryComponentPerformanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1887,6 +2031,42 @@ Quickbi_publicClient::QueryDataServiceOutcomeCallable Quickbi_publicClient::quer
 	return task->get_future();
 }
 
+Quickbi_publicClient::QueryDataServiceListOutcome Quickbi_publicClient::queryDataServiceList(const QueryDataServiceListRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return QueryDataServiceListOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return QueryDataServiceListOutcome(QueryDataServiceListResult(outcome.result()));
+	else
+		return QueryDataServiceListOutcome(outcome.error());
+}
+
+void Quickbi_publicClient::queryDataServiceListAsync(const QueryDataServiceListRequest& request, const QueryDataServiceListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, queryDataServiceList(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Quickbi_publicClient::QueryDataServiceListOutcomeCallable Quickbi_publicClient::queryDataServiceListCallable(const QueryDataServiceListRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<QueryDataServiceListOutcome()>>(
+			[this, request]()
+			{
+			return this->queryDataServiceList(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Quickbi_publicClient::QueryDatasetDetailInfoOutcome Quickbi_publicClient::queryDatasetDetailInfo(const QueryDatasetDetailInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

quickbi-public/src/model/DataSetBloodRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * 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/quickbi-public/model/DataSetBloodRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::DataSetBloodRequest;
+
+DataSetBloodRequest::DataSetBloodRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "DataSetBlood") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DataSetBloodRequest::~DataSetBloodRequest() {}
+
+std::string DataSetBloodRequest::getDataSetIds() const {
+  return dataSetIds_;
+}
+
+void DataSetBloodRequest::setDataSetIds(const std::string &dataSetIds) {
+  dataSetIds_ = dataSetIds;
+  setParameter(std::string("DataSetIds"), dataSetIds);
+}
+
+std::string DataSetBloodRequest::getWorksType() const {
+  return worksType_;
+}
+
+void DataSetBloodRequest::setWorksType(const std::string &worksType) {
+  worksType_ = worksType;
+  setParameter(std::string("WorksType"), worksType);
+}
+
+std::string DataSetBloodRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void DataSetBloodRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string DataSetBloodRequest::getSignType() const {
+  return signType_;
+}
+
+void DataSetBloodRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+std::string DataSetBloodRequest::getUserId() const {
+  return userId_;
+}
+
+void DataSetBloodRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+

quickbi-public/src/model/DataSetBloodResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/quickbi-public/model/DataSetBloodResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+DataSetBloodResult::DataSetBloodResult() :
+	ServiceResult()
+{}
+
+DataSetBloodResult::DataSetBloodResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DataSetBloodResult::~DataSetBloodResult()
+{}
+
+void DataSetBloodResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allResultNode = value["Result"]["WorksModels"];
+	for (auto valueResultWorksModels : allResultNode)
+	{
+		WorksModels resultObject;
+		if(!valueResultWorksModels["WorksType"].isNull())
+			resultObject.worksType = valueResultWorksModels["WorksType"].asString();
+		if(!valueResultWorksModels["WorksId"].isNull())
+			resultObject.worksId = valueResultWorksModels["WorksId"].asString();
+		result_.push_back(resultObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool DataSetBloodResult::getSuccess()const
+{
+	return success_;
+}
+
+std::vector<DataSetBloodResult::WorksModels> DataSetBloodResult::getResult()const
+{
+	return result_;
+}
+

quickbi-public/src/model/DataSourceBloodRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/quickbi-public/model/DataSourceBloodRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::DataSourceBloodRequest;
+
+DataSourceBloodRequest::DataSourceBloodRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "DataSourceBlood") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DataSourceBloodRequest::~DataSourceBloodRequest() {}
+
+std::string DataSourceBloodRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void DataSourceBloodRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string DataSourceBloodRequest::getDataSourceId() const {
+  return dataSourceId_;
+}
+
+void DataSourceBloodRequest::setDataSourceId(const std::string &dataSourceId) {
+  dataSourceId_ = dataSourceId;
+  setParameter(std::string("DataSourceId"), dataSourceId);
+}
+
+std::string DataSourceBloodRequest::getSignType() const {
+  return signType_;
+}
+
+void DataSourceBloodRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+

quickbi-public/src/model/DataSourceBloodResult.cc

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/quickbi-public/model/DataSourceBloodResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+DataSourceBloodResult::DataSourceBloodResult() :
+	ServiceResult()
+{}
+
+DataSourceBloodResult::DataSourceBloodResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DataSourceBloodResult::~DataSourceBloodResult()
+{}
+
+void DataSourceBloodResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allResult = value["Result"]["datasetIds"];
+	for (const auto &item : allResult)
+		result_.push_back(item.asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool DataSourceBloodResult::getSuccess()const
+{
+	return success_;
+}
+
+std::vector<std::string> DataSourceBloodResult::getResult()const
+{
+	return result_;
+}
+

quickbi-public/src/model/QueryApprovalInfoRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * 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/quickbi-public/model/QueryApprovalInfoRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::QueryApprovalInfoRequest;
+
+QueryApprovalInfoRequest::QueryApprovalInfoRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "QueryApprovalInfo") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+QueryApprovalInfoRequest::~QueryApprovalInfoRequest() {}
+
+std::string QueryApprovalInfoRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void QueryApprovalInfoRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+int QueryApprovalInfoRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void QueryApprovalInfoRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string QueryApprovalInfoRequest::getSignType() const {
+  return signType_;
+}
+
+void QueryApprovalInfoRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+int QueryApprovalInfoRequest::getPage() const {
+  return page_;
+}
+
+void QueryApprovalInfoRequest::setPage(int page) {
+  page_ = page;
+  setParameter(std::string("Page"), std::to_string(page));
+}
+
+std::string QueryApprovalInfoRequest::getUserId() const {
+  return userId_;
+}
+
+void QueryApprovalInfoRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+int QueryApprovalInfoRequest::getStatus() const {
+  return status_;
+}
+
+void QueryApprovalInfoRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
+}
+

quickbi-public/src/model/QueryApprovalInfoResult.cc

@@ -0,0 +1,105 @@
+/*
+ * 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/quickbi-public/model/QueryApprovalInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+QueryApprovalInfoResult::QueryApprovalInfoResult() :
+	ServiceResult()
+{}
+
+QueryApprovalInfoResult::QueryApprovalInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+QueryApprovalInfoResult::~QueryApprovalInfoResult()
+{}
+
+void QueryApprovalInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultNode = value["Result"];
+	if(!resultNode["Total"].isNull())
+		result_.total = std::stoi(resultNode["Total"].asString());
+	if(!resultNode["TotalPages"].isNull())
+		result_.totalPages = std::stoi(resultNode["TotalPages"].asString());
+	if(!resultNode["Start"].isNull())
+		result_.start = std::stoi(resultNode["Start"].asString());
+	if(!resultNode["PageSize"].isNull())
+		result_.pageSize = std::stoi(resultNode["PageSize"].asString());
+	if(!resultNode["Page"].isNull())
+		result_.page = std::stoi(resultNode["Page"].asString());
+	auto allDataNode = resultNode["Data"]["ApprovalsResultModel"];
+	for (auto resultNodeDataApprovalsResultModel : allDataNode)
+	{
+		Result::ApprovalsResultModel approvalsResultModelObject;
+		if(!resultNodeDataApprovalsResultModel["WorkspaceName"].isNull())
+			approvalsResultModelObject.workspaceName = resultNodeDataApprovalsResultModel["WorkspaceName"].asString();
+		if(!resultNodeDataApprovalsResultModel["ApplicationId"].isNull())
+			approvalsResultModelObject.applicationId = resultNodeDataApprovalsResultModel["ApplicationId"].asString();
+		if(!resultNodeDataApprovalsResultModel["ApplicantId"].isNull())
+			approvalsResultModelObject.applicantId = resultNodeDataApprovalsResultModel["ApplicantId"].asString();
+		if(!resultNodeDataApprovalsResultModel["ApplicantName"].isNull())
+			approvalsResultModelObject.applicantName = resultNodeDataApprovalsResultModel["ApplicantName"].asString();
+		if(!resultNodeDataApprovalsResultModel["ApproverId"].isNull())
+			approvalsResultModelObject.approverId = resultNodeDataApprovalsResultModel["ApproverId"].asString();
+		if(!resultNodeDataApprovalsResultModel["ApproverName"].isNull())
+			approvalsResultModelObject.approverName = resultNodeDataApprovalsResultModel["ApproverName"].asString();
+		if(!resultNodeDataApprovalsResultModel["ResourceId"].isNull())
+			approvalsResultModelObject.resourceId = resultNodeDataApprovalsResultModel["ResourceId"].asString();
+		if(!resultNodeDataApprovalsResultModel["ResourceName"].isNull())
+			approvalsResultModelObject.resourceName = resultNodeDataApprovalsResultModel["ResourceName"].asString();
+		if(!resultNodeDataApprovalsResultModel["ResourceType"].isNull())
+			approvalsResultModelObject.resourceType = resultNodeDataApprovalsResultModel["ResourceType"].asString();
+		if(!resultNodeDataApprovalsResultModel["ApplyReason"].isNull())
+			approvalsResultModelObject.applyReason = resultNodeDataApprovalsResultModel["ApplyReason"].asString();
+		if(!resultNodeDataApprovalsResultModel["HandleReason"].isNull())
+			approvalsResultModelObject.handleReason = resultNodeDataApprovalsResultModel["HandleReason"].asString();
+		if(!resultNodeDataApprovalsResultModel["ExpireDate"].isNull())
+			approvalsResultModelObject.expireDate = std::stol(resultNodeDataApprovalsResultModel["ExpireDate"].asString());
+		if(!resultNodeDataApprovalsResultModel["GmtCreate"].isNull())
+			approvalsResultModelObject.gmtCreate = std::stol(resultNodeDataApprovalsResultModel["GmtCreate"].asString());
+		if(!resultNodeDataApprovalsResultModel["GmtModified"].isNull())
+			approvalsResultModelObject.gmtModified = std::stol(resultNodeDataApprovalsResultModel["GmtModified"].asString());
+		if(!resultNodeDataApprovalsResultModel["FlagStatus"].isNull())
+			approvalsResultModelObject.flagStatus = std::stoi(resultNodeDataApprovalsResultModel["FlagStatus"].asString());
+		if(!resultNodeDataApprovalsResultModel["DeleteFlag"].isNull())
+			approvalsResultModelObject.deleteFlag = resultNodeDataApprovalsResultModel["DeleteFlag"].asString() == "true";
+		result_.data.push_back(approvalsResultModelObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool QueryApprovalInfoResult::getSuccess()const
+{
+	return success_;
+}
+
+QueryApprovalInfoResult::Result QueryApprovalInfoResult::getResult()const
+{
+	return result_;
+}
+

quickbi-public/src/model/QueryAuditLogRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * 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/quickbi-public/model/QueryAuditLogRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::QueryAuditLogRequest;
+
+QueryAuditLogRequest::QueryAuditLogRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "QueryAuditLog") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+QueryAuditLogRequest::~QueryAuditLogRequest() {}
+
+std::string QueryAuditLogRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void QueryAuditLogRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string QueryAuditLogRequest::getSignType() const {
+  return signType_;
+}
+
+void QueryAuditLogRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+std::string QueryAuditLogRequest::getStartDate() const {
+  return startDate_;
+}
+
+void QueryAuditLogRequest::setStartDate(const std::string &startDate) {
+  startDate_ = startDate;
+  setParameter(std::string("StartDate"), startDate);
+}
+
+std::string QueryAuditLogRequest::getResourceType() const {
+  return resourceType_;
+}
+
+void QueryAuditLogRequest::setResourceType(const std::string &resourceType) {
+  resourceType_ = resourceType;
+  setParameter(std::string("ResourceType"), resourceType);
+}
+
+std::string QueryAuditLogRequest::getOperatorTypes() const {
+  return operatorTypes_;
+}
+
+void QueryAuditLogRequest::setOperatorTypes(const std::string &operatorTypes) {
+  operatorTypes_ = operatorTypes;
+  setParameter(std::string("OperatorTypes"), operatorTypes);
+}
+
+std::string QueryAuditLogRequest::getLogType() const {
+  return logType_;
+}
+
+void QueryAuditLogRequest::setLogType(const std::string &logType) {
+  logType_ = logType;
+  setParameter(std::string("LogType"), logType);
+}
+
+std::string QueryAuditLogRequest::getEndDate() const {
+  return endDate_;
+}
+
+void QueryAuditLogRequest::setEndDate(const std::string &endDate) {
+  endDate_ = endDate;
+  setParameter(std::string("EndDate"), endDate);
+}
+
+std::string QueryAuditLogRequest::getOperatorId() const {
+  return operatorId_;
+}
+
+void QueryAuditLogRequest::setOperatorId(const std::string &operatorId) {
+  operatorId_ = operatorId;
+  setParameter(std::string("OperatorId"), operatorId);
+}
+
+std::string QueryAuditLogRequest::getWorkspaceId() const {
+  return workspaceId_;
+}
+
+void QueryAuditLogRequest::setWorkspaceId(const std::string &workspaceId) {
+  workspaceId_ = workspaceId;
+  setParameter(std::string("WorkspaceId"), workspaceId);
+}
+

quickbi-public/src/model/QueryAuditLogResult.cc

@@ -0,0 +1,76 @@
+/*
+ * 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/quickbi-public/model/QueryAuditLogResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+QueryAuditLogResult::QueryAuditLogResult() :
+	ServiceResult()
+{}
+
+QueryAuditLogResult::QueryAuditLogResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+QueryAuditLogResult::~QueryAuditLogResult()
+{}
+
+void QueryAuditLogResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allResultNode = value["Result"]["LogApiResultModel"];
+	for (auto valueResultLogApiResultModel : allResultNode)
+	{
+		LogApiResultModel resultObject;
+		if(!valueResultLogApiResultModel["WorkspaceId"].isNull())
+			resultObject.workspaceId = valueResultLogApiResultModel["WorkspaceId"].asString();
+		if(!valueResultLogApiResultModel["OperatorName"].isNull())
+			resultObject.operatorName = valueResultLogApiResultModel["OperatorName"].asString();
+		if(!valueResultLogApiResultModel["OperatorAccountName"].isNull())
+			resultObject.operatorAccountName = valueResultLogApiResultModel["OperatorAccountName"].asString();
+		if(!valueResultLogApiResultModel["OperatorType"].isNull())
+			resultObject.operatorType = valueResultLogApiResultModel["OperatorType"].asString();
+		if(!valueResultLogApiResultModel["TargetType"].isNull())
+			resultObject.targetType = valueResultLogApiResultModel["TargetType"].asString();
+		if(!valueResultLogApiResultModel["TargetName"].isNull())
+			resultObject.targetName = valueResultLogApiResultModel["TargetName"].asString();
+		if(!valueResultLogApiResultModel["GmtCreate"].isNull())
+			resultObject.gmtCreate = valueResultLogApiResultModel["GmtCreate"].asString();
+		result_.push_back(resultObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool QueryAuditLogResult::getSuccess()const
+{
+	return success_;
+}
+
+std::vector<QueryAuditLogResult::LogApiResultModel> QueryAuditLogResult::getResult()const
+{
+	return result_;
+}
+

quickbi-public/src/model/QueryDataServiceListRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * 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/quickbi-public/model/QueryDataServiceListRequest.h>
+
+using AlibabaCloud::Quickbi_public::Model::QueryDataServiceListRequest;
+
+QueryDataServiceListRequest::QueryDataServiceListRequest()
+    : RpcServiceRequest("quickbi-public", "2022-01-01", "QueryDataServiceList") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+QueryDataServiceListRequest::~QueryDataServiceListRequest() {}
+
+int QueryDataServiceListRequest::getPageNo() const {
+  return pageNo_;
+}
+
+void QueryDataServiceListRequest::setPageNo(int pageNo) {
+  pageNo_ = pageNo;
+  setParameter(std::string("PageNo"), std::to_string(pageNo));
+}
+
+std::string QueryDataServiceListRequest::getAccessPoint() const {
+  return accessPoint_;
+}
+
+void QueryDataServiceListRequest::setAccessPoint(const std::string &accessPoint) {
+  accessPoint_ = accessPoint;
+  setParameter(std::string("AccessPoint"), accessPoint);
+}
+
+std::string QueryDataServiceListRequest::getName() const {
+  return name_;
+}
+
+void QueryDataServiceListRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+int QueryDataServiceListRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void QueryDataServiceListRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string QueryDataServiceListRequest::getSignType() const {
+  return signType_;
+}
+
+void QueryDataServiceListRequest::setSignType(const std::string &signType) {
+  signType_ = signType;
+  setParameter(std::string("SignType"), signType);
+}
+
+std::string QueryDataServiceListRequest::getUserId() const {
+  return userId_;
+}
+
+void QueryDataServiceListRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+

quickbi-public/src/model/QueryDataServiceListResult.cc

@@ -0,0 +1,145 @@
+/*
+ * 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/quickbi-public/model/QueryDataServiceListResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Quickbi_public;
+using namespace AlibabaCloud::Quickbi_public::Model;
+
+QueryDataServiceListResult::QueryDataServiceListResult() :
+	ServiceResult()
+{}
+
+QueryDataServiceListResult::QueryDataServiceListResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+QueryDataServiceListResult::~QueryDataServiceListResult()
+{}
+
+void QueryDataServiceListResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultNode = value["Result"];
+	if(!resultNode["TotalPages"].isNull())
+		result_.totalPages = std::stoi(resultNode["TotalPages"].asString());
+	if(!resultNode["TotalNum"].isNull())
+		result_.totalNum = std::stoi(resultNode["TotalNum"].asString());
+	if(!resultNode["PageNum"].isNull())
+		result_.pageNum = std::stoi(resultNode["PageNum"].asString());
+	if(!resultNode["PageSize"].isNull())
+		result_.pageSize = std::stoi(resultNode["PageSize"].asString());
+	auto allDataNode = resultNode["Data"]["QueryDataServiceModel"];
+	for (auto resultNodeDataQueryDataServiceModel : allDataNode)
+	{
+		Result::QueryDataServiceModel queryDataServiceModelObject;
+		if(!resultNodeDataQueryDataServiceModel["Sid"].isNull())
+			queryDataServiceModelObject.sid = resultNodeDataQueryDataServiceModel["Sid"].asString();
+		if(!resultNodeDataQueryDataServiceModel["Name"].isNull())
+			queryDataServiceModelObject.name = resultNodeDataQueryDataServiceModel["Name"].asString();
+		if(!resultNodeDataQueryDataServiceModel["Desc"].isNull())
+			queryDataServiceModelObject.desc = resultNodeDataQueryDataServiceModel["Desc"].asString();
+		if(!resultNodeDataQueryDataServiceModel["CubeId"].isNull())
+			queryDataServiceModelObject.cubeId = resultNodeDataQueryDataServiceModel["CubeId"].asString();
+		if(!resultNodeDataQueryDataServiceModel["CubeName"].isNull())
+			queryDataServiceModelObject.cubeName = resultNodeDataQueryDataServiceModel["CubeName"].asString();
+		if(!resultNodeDataQueryDataServiceModel["WorkspaceId"].isNull())
+			queryDataServiceModelObject.workspaceId = resultNodeDataQueryDataServiceModel["WorkspaceId"].asString();
+		if(!resultNodeDataQueryDataServiceModel["WorkspaceName"].isNull())
+			queryDataServiceModelObject.workspaceName = resultNodeDataQueryDataServiceModel["WorkspaceName"].asString();
+		if(!resultNodeDataQueryDataServiceModel["GmtCreate"].isNull())
+			queryDataServiceModelObject.gmtCreate = resultNodeDataQueryDataServiceModel["GmtCreate"].asString();
+		if(!resultNodeDataQueryDataServiceModel["GmtModified"].isNull())
+			queryDataServiceModelObject.gmtModified = resultNodeDataQueryDataServiceModel["GmtModified"].asString();
+		if(!resultNodeDataQueryDataServiceModel["CreatorId"].isNull())
+			queryDataServiceModelObject.creatorId = resultNodeDataQueryDataServiceModel["CreatorId"].asString();
+		if(!resultNodeDataQueryDataServiceModel["CreatorName"].isNull())
+			queryDataServiceModelObject.creatorName = resultNodeDataQueryDataServiceModel["CreatorName"].asString();
+		if(!resultNodeDataQueryDataServiceModel["ModifierId"].isNull())
+			queryDataServiceModelObject.modifierId = resultNodeDataQueryDataServiceModel["ModifierId"].asString();
+		if(!resultNodeDataQueryDataServiceModel["ModifierName"].isNull())
+			queryDataServiceModelObject.modifierName = resultNodeDataQueryDataServiceModel["ModifierName"].asString();
+		if(!resultNodeDataQueryDataServiceModel["OwnerId"].isNull())
+			queryDataServiceModelObject.ownerId = resultNodeDataQueryDataServiceModel["OwnerId"].asString();
+		if(!resultNodeDataQueryDataServiceModel["OwnerName"].isNull())
+			queryDataServiceModelObject.ownerName = resultNodeDataQueryDataServiceModel["OwnerName"].asString();
+		auto contentNode = value["Content"];
+		if(!contentNode["CubeId"].isNull())
+			queryDataServiceModelObject.content.cubeId = contentNode["CubeId"].asString();
+		if(!contentNode["CubeName"].isNull())
+			queryDataServiceModelObject.content.cubeName = contentNode["CubeName"].asString();
+		if(!contentNode["Detail"].isNull())
+			queryDataServiceModelObject.content.detail = contentNode["Detail"].asString() == "true";
+		auto allReturnFieldsNode = contentNode["ReturnFields"]["SelectFieldModel"];
+		for (auto contentNodeReturnFieldsSelectFieldModel : allReturnFieldsNode)
+		{
+			Result::QueryDataServiceModel::Content::SelectFieldModel selectFieldModelObject;
+			if(!contentNodeReturnFieldsSelectFieldModel["Alias"].isNull())
+				selectFieldModelObject.alias = contentNodeReturnFieldsSelectFieldModel["Alias"].asString();
+			if(!contentNodeReturnFieldsSelectFieldModel["Desc"].isNull())
+				selectFieldModelObject.desc = contentNodeReturnFieldsSelectFieldModel["Desc"].asString();
+			if(!contentNodeReturnFieldsSelectFieldModel["Aggregator"].isNull())
+				selectFieldModelObject.aggregator = contentNodeReturnFieldsSelectFieldModel["Aggregator"].asString();
+			if(!contentNodeReturnFieldsSelectFieldModel["Orderby"].isNull())
+				selectFieldModelObject.orderby = contentNodeReturnFieldsSelectFieldModel["Orderby"].asString();
+			auto fieldNode = value["Field"];
+			if(!fieldNode["Fid"].isNull())
+				selectFieldModelObject.field.fid = fieldNode["Fid"].asString();
+			if(!fieldNode["Name"].isNull())
+				selectFieldModelObject.field.name = fieldNode["Name"].asString();
+			if(!fieldNode["Type"].isNull())
+				selectFieldModelObject.field.type = fieldNode["Type"].asString();
+			if(!fieldNode["Caption"].isNull())
+				selectFieldModelObject.field.caption = fieldNode["Caption"].asString();
+			if(!fieldNode["Column"].isNull())
+				selectFieldModelObject.field.column = fieldNode["Column"].asString();
+			if(!fieldNode["DataType"].isNull())
+				selectFieldModelObject.field.dataType = fieldNode["DataType"].asString();
+			if(!fieldNode["Granularity"].isNull())
+				selectFieldModelObject.field.granularity = fieldNode["Granularity"].asString();
+			queryDataServiceModelObject.content.returnFields.push_back(selectFieldModelObject);
+		}
+		auto filterNode = contentNode["Filter"];
+		if(!filterNode["LogicalOperator"].isNull())
+			queryDataServiceModelObject.content.filter.logicalOperator = filterNode["LogicalOperator"].asString();
+		if(!filterNode["Type"].isNull())
+			queryDataServiceModelObject.content.filter.type = filterNode["Type"].asString();
+			auto allFilters = filterNode["Filters"]["AbstractFilter"];
+			for (auto value : allFilters)
+				queryDataServiceModelObject.content.filter.filters.push_back(value.asString());
+		result_.data.push_back(queryDataServiceModelObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+bool QueryDataServiceListResult::getSuccess()const
+{
+	return success_;
+}
+
+QueryDataServiceListResult::Result QueryDataServiceListResult::getResult()const
+{
+	return result_;
+}
+

quickbi-public/src/model/QueryUserListResult.cc

@@ -70,6 +70,10 @@ void QueryUserListResult::parse(const std::string &payload)
 			dataItemObject.phone = resultNodeDataDataItem["Phone"].asString();
 		if(!resultNodeDataDataItem["AccountName"].isNull())
 			dataItemObject.accountName = resultNodeDataDataItem["AccountName"].asString();
+		if(!resultNodeDataDataItem["JoinedDate"].isNull())
+			dataItemObject.joinedDate = std::stol(resultNodeDataDataItem["JoinedDate"].asString());
+		if(!resultNodeDataDataItem["LastLoginTime"].isNull())
+			dataItemObject.lastLoginTime = std::stol(resultNodeDataDataItem["LastLoginTime"].asString());
 		auto allRoleIdList = value["RoleIdList"]["roleIdList"];
 		for (auto value : allRoleIdList)
 			dataItemObject.roleIdList.push_back(value.asString());

quickbi-public/src/model/QueryWorksByOrganizationResult.cc

@@ -80,6 +80,10 @@ void QueryWorksByOrganizationResult::parse(const std::string &payload)
 			dataItemObject.workName = resultNodeDataDataItem["WorkName"].asString();
 		if(!resultNodeDataDataItem["GmtCreate"].isNull())
 			dataItemObject.gmtCreate = resultNodeDataDataItem["GmtCreate"].asString();
+		if(!resultNodeDataDataItem["PublicFlag"].isNull())
+			dataItemObject.publicFlag = resultNodeDataDataItem["PublicFlag"].asString() == "true";
+		if(!resultNodeDataDataItem["PublicInvalidTime"].isNull())
+			dataItemObject.publicInvalidTime = std::stol(resultNodeDataDataItem["PublicInvalidTime"].asString());
 		auto directoryNode = value["Directory"];
 		if(!directoryNode["PathId"].isNull())
 			dataItemObject.directory.pathId = directoryNode["PathId"].asString();

quickbi-public/src/model/QueryWorksByWorkspaceResult.cc

@@ -80,6 +80,10 @@ void QueryWorksByWorkspaceResult::parse(const std::string &payload)
 			dataItemObject.workName = resultNodeDataDataItem["WorkName"].asString();
 		if(!resultNodeDataDataItem["GmtCreate"].isNull())
 			dataItemObject.gmtCreate = resultNodeDataDataItem["GmtCreate"].asString();
+		if(!resultNodeDataDataItem["PublicFlag"].isNull())
+			dataItemObject.publicFlag = resultNodeDataDataItem["PublicFlag"].asString() == "true";
+		if(!resultNodeDataDataItem["PublicInvalidTime"].isNull())
+			dataItemObject.publicInvalidTime = std::stol(resultNodeDataDataItem["PublicInvalidTime"].asString());
 		auto directoryNode = value["Directory"];
 		if(!directoryNode["PathId"].isNull())
 			dataItemObject.directory.pathId = directoryNode["PathId"].asString();

quickbi-public/src/model/QueryWorksResult.cc

@@ -68,6 +68,10 @@ void QueryWorksResult::parse(const std::string &payload)
 		result_.gmtModify = resultNode["GmtModify"].asString();
 	if(!resultNode["Status"].isNull())
 		result_.status = std::stoi(resultNode["Status"].asString());
+	if(!resultNode["PublicFlag"].isNull())
+		result_.publicFlag = resultNode["PublicFlag"].asString() == "true";
+	if(!resultNode["PublicInvalidTime"].isNull())
+		result_.publicInvalidTime = std::stol(resultNode["PublicInvalidTime"].asString());
 	auto directoryNode = resultNode["Directory"];
 	if(!directoryNode["Id"].isNull())
 		result_.directory.id = directoryNode["Id"].asString();

quickbi-public/src/model/UpdateUserRequest.cc

@@ -79,6 +79,15 @@ void UpdateUserRequest::setUserId(const std::string &userId) {
   setParameter(std::string("UserId"), userId);
 }
 
+bool UpdateUserRequest::getIsDeleted() const {
+  return isDeleted_;
+}
+
+void UpdateUserRequest::setIsDeleted(bool isDeleted) {
+  isDeleted_ = isDeleted;
+  setParameter(std::string("IsDeleted"), isDeleted ? "true" : "false");
+}
+
 std::string UpdateUserRequest::getRoleIds() const {
   return roleIds_;
 }