From 7ceaff6c6e9b21583e334f17586638afc2187425 Mon Sep 17 00:00:00 2001 From: sdk-team Date: Mon, 17 Nov 2025 08:06:10 +0000 Subject: [PATCH] Add some APIs. --- VERSION | 2 +- quickbi-public/CMakeLists.txt | 16 ++ .../quickbi-public/Quickbi_publicClient.h | 32 ++++ .../model/CreateWorkspaceRequest.h | 69 +++++++++ .../model/CreateWorkspaceResult.h | 53 +++++++ .../ListAccelerationOfWorkspaceRequest.h | 60 ++++++++ .../model/ListAccelerationOfWorkspaceResult.h | 75 +++++++++ .../ModifyDashboardNl2sqlStatusRequest.h | 51 +++++++ .../model/ModifyDashboardNl2sqlStatusResult.h | 53 +++++++ .../QueryAccelerationLogByCubeIdRequest.h | 60 ++++++++ .../QueryAccelerationLogByCubeIdResult.h | 72 +++++++++ .../model/SmartqQueryAbilityRequest.h | 3 + .../model/SmartqQueryAbilityResult.h | 1 + quickbi-public/src/Quickbi-publicClient.cc | 144 ++++++++++++++++++ .../src/model/CreateWorkspaceRequest.cc | 117 ++++++++++++++ .../src/model/CreateWorkspaceResult.cc | 58 +++++++ .../ListAccelerationOfWorkspaceRequest.cc | 90 +++++++++++ .../ListAccelerationOfWorkspaceResult.cc | 93 +++++++++++ .../ModifyDashboardNl2sqlStatusRequest.cc | 63 ++++++++ .../ModifyDashboardNl2sqlStatusResult.cc | 59 +++++++ .../QueryAccelerationLogByCubeIdRequest.cc | 90 +++++++++++ .../QueryAccelerationLogByCubeIdResult.cc | 87 +++++++++++ .../src/model/SmartqQueryAbilityRequest.cc | 9 ++ .../src/model/SmartqQueryAbilityResult.cc | 3 + 24 files changed, 1359 insertions(+), 1 deletion(-) create mode 100644 quickbi-public/include/alibabacloud/quickbi-public/model/CreateWorkspaceRequest.h create mode 100644 quickbi-public/include/alibabacloud/quickbi-public/model/CreateWorkspaceResult.h create mode 100644 quickbi-public/include/alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceRequest.h create mode 100644 quickbi-public/include/alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceResult.h create mode 100644 quickbi-public/include/alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusRequest.h create mode 100644 quickbi-public/include/alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusResult.h create mode 100644 quickbi-public/include/alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdRequest.h create mode 100644 quickbi-public/include/alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdResult.h create mode 100644 quickbi-public/src/model/CreateWorkspaceRequest.cc create mode 100644 quickbi-public/src/model/CreateWorkspaceResult.cc create mode 100644 quickbi-public/src/model/ListAccelerationOfWorkspaceRequest.cc create mode 100644 quickbi-public/src/model/ListAccelerationOfWorkspaceResult.cc create mode 100644 quickbi-public/src/model/ModifyDashboardNl2sqlStatusRequest.cc create mode 100644 quickbi-public/src/model/ModifyDashboardNl2sqlStatusResult.cc create mode 100644 quickbi-public/src/model/QueryAccelerationLogByCubeIdRequest.cc create mode 100644 quickbi-public/src/model/QueryAccelerationLogByCubeIdResult.cc diff --git a/VERSION b/VERSION index 65c7f5719..99280be39 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.2116 \ No newline at end of file +1.36.2117 \ No newline at end of file diff --git a/quickbi-public/CMakeLists.txt b/quickbi-public/CMakeLists.txt index a4ae4f29f..e0a450fe3 100644 --- a/quickbi-public/CMakeLists.txt +++ b/quickbi-public/CMakeLists.txt @@ -71,6 +71,8 @@ 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/CreateWorkspaceRequest.h + include/alibabacloud/quickbi-public/model/CreateWorkspaceResult.h include/alibabacloud/quickbi-public/model/DataInterpretationRequest.h include/alibabacloud/quickbi-public/model/DataInterpretationResult.h include/alibabacloud/quickbi-public/model/DataSetBloodRequest.h @@ -105,6 +107,8 @@ set(quickbi-public_public_header_model include/alibabacloud/quickbi-public/model/GetUserGroupInfoResult.h include/alibabacloud/quickbi-public/model/GetWorksEmbedListRequest.h include/alibabacloud/quickbi-public/model/GetWorksEmbedListResult.h + include/alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceRequest.h + include/alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceResult.h include/alibabacloud/quickbi-public/model/ListApiDatasourceRequest.h include/alibabacloud/quickbi-public/model/ListApiDatasourceResult.h include/alibabacloud/quickbi-public/model/ListByUserGroupIdRequest.h @@ -145,6 +149,10 @@ set(quickbi-public_public_header_model include/alibabacloud/quickbi-public/model/ModifyApiDatasourceParametersResult.h include/alibabacloud/quickbi-public/model/ModifyCopilotEmbedConfigRequest.h include/alibabacloud/quickbi-public/model/ModifyCopilotEmbedConfigResult.h + include/alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusRequest.h + include/alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusResult.h + include/alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdRequest.h + include/alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdResult.h include/alibabacloud/quickbi-public/model/QueryApprovalInfoRequest.h include/alibabacloud/quickbi-public/model/QueryApprovalInfoResult.h include/alibabacloud/quickbi-public/model/QueryAuditLogRequest.h @@ -324,6 +332,8 @@ set(quickbi-public_src src/model/CreateTicket4CopilotResult.cc src/model/CreateUserGroupRequest.cc src/model/CreateUserGroupResult.cc + src/model/CreateWorkspaceRequest.cc + src/model/CreateWorkspaceResult.cc src/model/DataInterpretationRequest.cc src/model/DataInterpretationResult.cc src/model/DataSetBloodRequest.cc @@ -358,6 +368,8 @@ set(quickbi-public_src src/model/GetUserGroupInfoResult.cc src/model/GetWorksEmbedListRequest.cc src/model/GetWorksEmbedListResult.cc + src/model/ListAccelerationOfWorkspaceRequest.cc + src/model/ListAccelerationOfWorkspaceResult.cc src/model/ListApiDatasourceRequest.cc src/model/ListApiDatasourceResult.cc src/model/ListByUserGroupIdRequest.cc @@ -398,6 +410,10 @@ set(quickbi-public_src src/model/ModifyApiDatasourceParametersResult.cc src/model/ModifyCopilotEmbedConfigRequest.cc src/model/ModifyCopilotEmbedConfigResult.cc + src/model/ModifyDashboardNl2sqlStatusRequest.cc + src/model/ModifyDashboardNl2sqlStatusResult.cc + src/model/QueryAccelerationLogByCubeIdRequest.cc + src/model/QueryAccelerationLogByCubeIdResult.cc src/model/QueryApprovalInfoRequest.cc src/model/QueryApprovalInfoResult.cc src/model/QueryAuditLogRequest.cc diff --git a/quickbi-public/include/alibabacloud/quickbi-public/Quickbi_publicClient.h b/quickbi-public/include/alibabacloud/quickbi-public/Quickbi_publicClient.h index 8fa4b7314..fa04466f6 100644 --- a/quickbi-public/include/alibabacloud/quickbi-public/Quickbi_publicClient.h +++ b/quickbi-public/include/alibabacloud/quickbi-public/Quickbi_publicClient.h @@ -72,6 +72,8 @@ #include "model/CreateTicket4CopilotResult.h" #include "model/CreateUserGroupRequest.h" #include "model/CreateUserGroupResult.h" +#include "model/CreateWorkspaceRequest.h" +#include "model/CreateWorkspaceResult.h" #include "model/DataInterpretationRequest.h" #include "model/DataInterpretationResult.h" #include "model/DataSetBloodRequest.h" @@ -106,6 +108,8 @@ #include "model/GetUserGroupInfoResult.h" #include "model/GetWorksEmbedListRequest.h" #include "model/GetWorksEmbedListResult.h" +#include "model/ListAccelerationOfWorkspaceRequest.h" +#include "model/ListAccelerationOfWorkspaceResult.h" #include "model/ListApiDatasourceRequest.h" #include "model/ListApiDatasourceResult.h" #include "model/ListByUserGroupIdRequest.h" @@ -146,6 +150,10 @@ #include "model/ModifyApiDatasourceParametersResult.h" #include "model/ModifyCopilotEmbedConfigRequest.h" #include "model/ModifyCopilotEmbedConfigResult.h" +#include "model/ModifyDashboardNl2sqlStatusRequest.h" +#include "model/ModifyDashboardNl2sqlStatusResult.h" +#include "model/QueryAccelerationLogByCubeIdRequest.h" +#include "model/QueryAccelerationLogByCubeIdResult.h" #include "model/QueryApprovalInfoRequest.h" #include "model/QueryApprovalInfoResult.h" #include "model/QueryAuditLogRequest.h" @@ -356,6 +364,9 @@ namespace AlibabaCloud typedef Outcome CreateUserGroupOutcome; typedef std::future CreateUserGroupOutcomeCallable; typedef std::function&)> CreateUserGroupAsyncHandler; + typedef Outcome CreateWorkspaceOutcome; + typedef std::future CreateWorkspaceOutcomeCallable; + typedef std::function&)> CreateWorkspaceAsyncHandler; typedef Outcome DataInterpretationOutcome; typedef std::future DataInterpretationOutcomeCallable; typedef std::function&)> DataInterpretationAsyncHandler; @@ -407,6 +418,9 @@ namespace AlibabaCloud typedef Outcome GetWorksEmbedListOutcome; typedef std::future GetWorksEmbedListOutcomeCallable; typedef std::function&)> GetWorksEmbedListAsyncHandler; + typedef Outcome ListAccelerationOfWorkspaceOutcome; + typedef std::future ListAccelerationOfWorkspaceOutcomeCallable; + typedef std::function&)> ListAccelerationOfWorkspaceAsyncHandler; typedef Outcome ListApiDatasourceOutcome; typedef std::future ListApiDatasourceOutcomeCallable; typedef std::function&)> ListApiDatasourceAsyncHandler; @@ -467,6 +481,12 @@ namespace AlibabaCloud typedef Outcome ModifyCopilotEmbedConfigOutcome; typedef std::future ModifyCopilotEmbedConfigOutcomeCallable; typedef std::function&)> ModifyCopilotEmbedConfigAsyncHandler; + typedef Outcome ModifyDashboardNl2sqlStatusOutcome; + typedef std::future ModifyDashboardNl2sqlStatusOutcomeCallable; + typedef std::function&)> ModifyDashboardNl2sqlStatusAsyncHandler; + typedef Outcome QueryAccelerationLogByCubeIdOutcome; + typedef std::future QueryAccelerationLogByCubeIdOutcomeCallable; + typedef std::function&)> QueryAccelerationLogByCubeIdAsyncHandler; typedef Outcome QueryApprovalInfoOutcome; typedef std::future QueryApprovalInfoOutcomeCallable; typedef std::function&)> QueryApprovalInfoAsyncHandler; @@ -736,6 +756,9 @@ namespace AlibabaCloud CreateUserGroupOutcome createUserGroup(const Model::CreateUserGroupRequest &request)const; void createUserGroupAsync(const Model::CreateUserGroupRequest& request, const CreateUserGroupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateUserGroupOutcomeCallable createUserGroupCallable(const Model::CreateUserGroupRequest& request) const; + CreateWorkspaceOutcome createWorkspace(const Model::CreateWorkspaceRequest &request)const; + void createWorkspaceAsync(const Model::CreateWorkspaceRequest& request, const CreateWorkspaceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateWorkspaceOutcomeCallable createWorkspaceCallable(const Model::CreateWorkspaceRequest& request) const; DataInterpretationOutcome dataInterpretation(const Model::DataInterpretationRequest &request)const; void dataInterpretationAsync(const Model::DataInterpretationRequest& request, const DataInterpretationAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DataInterpretationOutcomeCallable dataInterpretationCallable(const Model::DataInterpretationRequest& request) const; @@ -787,6 +810,9 @@ namespace AlibabaCloud GetWorksEmbedListOutcome getWorksEmbedList(const Model::GetWorksEmbedListRequest &request)const; void getWorksEmbedListAsync(const Model::GetWorksEmbedListRequest& request, const GetWorksEmbedListAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetWorksEmbedListOutcomeCallable getWorksEmbedListCallable(const Model::GetWorksEmbedListRequest& request) const; + ListAccelerationOfWorkspaceOutcome listAccelerationOfWorkspace(const Model::ListAccelerationOfWorkspaceRequest &request)const; + void listAccelerationOfWorkspaceAsync(const Model::ListAccelerationOfWorkspaceRequest& request, const ListAccelerationOfWorkspaceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListAccelerationOfWorkspaceOutcomeCallable listAccelerationOfWorkspaceCallable(const Model::ListAccelerationOfWorkspaceRequest& request) const; ListApiDatasourceOutcome listApiDatasource(const Model::ListApiDatasourceRequest &request)const; void listApiDatasourceAsync(const Model::ListApiDatasourceRequest& request, const ListApiDatasourceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListApiDatasourceOutcomeCallable listApiDatasourceCallable(const Model::ListApiDatasourceRequest& request) const; @@ -847,6 +873,12 @@ namespace AlibabaCloud ModifyCopilotEmbedConfigOutcome modifyCopilotEmbedConfig(const Model::ModifyCopilotEmbedConfigRequest &request)const; void modifyCopilotEmbedConfigAsync(const Model::ModifyCopilotEmbedConfigRequest& request, const ModifyCopilotEmbedConfigAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ModifyCopilotEmbedConfigOutcomeCallable modifyCopilotEmbedConfigCallable(const Model::ModifyCopilotEmbedConfigRequest& request) const; + ModifyDashboardNl2sqlStatusOutcome modifyDashboardNl2sqlStatus(const Model::ModifyDashboardNl2sqlStatusRequest &request)const; + void modifyDashboardNl2sqlStatusAsync(const Model::ModifyDashboardNl2sqlStatusRequest& request, const ModifyDashboardNl2sqlStatusAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ModifyDashboardNl2sqlStatusOutcomeCallable modifyDashboardNl2sqlStatusCallable(const Model::ModifyDashboardNl2sqlStatusRequest& request) const; + QueryAccelerationLogByCubeIdOutcome queryAccelerationLogByCubeId(const Model::QueryAccelerationLogByCubeIdRequest &request)const; + void queryAccelerationLogByCubeIdAsync(const Model::QueryAccelerationLogByCubeIdRequest& request, const QueryAccelerationLogByCubeIdAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + QueryAccelerationLogByCubeIdOutcomeCallable queryAccelerationLogByCubeIdCallable(const Model::QueryAccelerationLogByCubeIdRequest& request) const; QueryApprovalInfoOutcome queryApprovalInfo(const Model::QueryApprovalInfoRequest &request)const; void queryApprovalInfoAsync(const Model::QueryApprovalInfoRequest& request, const QueryApprovalInfoAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; QueryApprovalInfoOutcomeCallable queryApprovalInfoCallable(const Model::QueryApprovalInfoRequest& request) const; diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/CreateWorkspaceRequest.h b/quickbi-public/include/alibabacloud/quickbi-public/model/CreateWorkspaceRequest.h new file mode 100644 index 000000000..fbc113575 --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/CreateWorkspaceRequest.h @@ -0,0 +1,69 @@ +/* + * 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_CREATEWORKSPACEREQUEST_H_ +#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEWORKSPACEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Quickbi_public { +namespace Model { +class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT CreateWorkspaceRequest : public RpcServiceRequest { +public: + CreateWorkspaceRequest(); + ~CreateWorkspaceRequest(); + bool getAllowViewAll() const; + void setAllowViewAll(bool allowViewAll); + std::string getAccessPoint() const; + void setAccessPoint(const std::string &accessPoint); + std::string getWorkspaceName() const; + void setWorkspaceName(const std::string &workspaceName); + std::string getWorkspaceDescription() const; + void setWorkspaceDescription(const std::string &workspaceDescription); + bool getOnlyAdminCreateDatasource() const; + void setOnlyAdminCreateDatasource(bool onlyAdminCreateDatasource); + std::string getSignType() const; + void setSignType(const std::string &signType); + bool getAllowShare() const; + void setAllowShare(bool allowShare); + bool getDefaultShareToAll() const; + void setDefaultShareToAll(bool defaultShareToAll); + bool getAllowPublish() const; + void setAllowPublish(bool allowPublish); + bool getUseComment() const; + void setUseComment(bool useComment); + +private: + bool allowViewAll_; + std::string accessPoint_; + std::string workspaceName_; + std::string workspaceDescription_; + bool onlyAdminCreateDatasource_; + std::string signType_; + bool allowShare_; + bool defaultShareToAll_; + bool allowPublish_; + bool useComment_; +}; +} // namespace Model +} // namespace Quickbi_public +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEWORKSPACEREQUEST_H_ diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/CreateWorkspaceResult.h b/quickbi-public/include/alibabacloud/quickbi-public/model/CreateWorkspaceResult.h new file mode 100644 index 000000000..f14817f4b --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/CreateWorkspaceResult.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_CREATEWORKSPACERESULT_H_ +#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEWORKSPACERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Quickbi_public + { + namespace Model + { + class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT CreateWorkspaceResult : public ServiceResult + { + public: + + + CreateWorkspaceResult(); + explicit CreateWorkspaceResult(const std::string &payload); + ~CreateWorkspaceResult(); + bool getSuccess()const; + std::string getResult()const; + + protected: + void parse(const std::string &payload); + private: + bool success_; + std::string result_; + + }; + } + } +} +#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEWORKSPACERESULT_H_ \ No newline at end of file diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceRequest.h b/quickbi-public/include/alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceRequest.h new file mode 100644 index 000000000..d1137b728 --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceRequest.h @@ -0,0 +1,60 @@ +/* + * 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_LISTACCELERATIONOFWORKSPACEREQUEST_H_ +#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTACCELERATIONOFWORKSPACEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Quickbi_public { +namespace Model { +class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT ListAccelerationOfWorkspaceRequest : public RpcServiceRequest { +public: + ListAccelerationOfWorkspaceRequest(); + ~ListAccelerationOfWorkspaceRequest(); + std::string getAccessPoint() const; + void setAccessPoint(const std::string &accessPoint); + std::string getCubeName() const; + void setCubeName(const std::string &cubeName); + int getPageSize() const; + void setPageSize(int pageSize); + std::string getCreatorId() const; + void setCreatorId(const std::string &creatorId); + std::string getSignType() const; + void setSignType(const std::string &signType); + int getPageNo() const; + void setPageNo(int pageNo); + std::string getWorkspaceId() const; + void setWorkspaceId(const std::string &workspaceId); + +private: + std::string accessPoint_; + std::string cubeName_; + int pageSize_; + std::string creatorId_; + std::string signType_; + int pageNo_; + std::string workspaceId_; +}; +} // namespace Model +} // namespace Quickbi_public +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTACCELERATIONOFWORKSPACEREQUEST_H_ diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceResult.h b/quickbi-public/include/alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceResult.h new file mode 100644 index 000000000..a672980b4 --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/ListAccelerationOfWorkspaceResult.h @@ -0,0 +1,75 @@ +/* + * 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_LISTACCELERATIONOFWORKSPACERESULT_H_ +#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTACCELERATIONOFWORKSPACERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Quickbi_public + { + namespace Model + { + class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT ListAccelerationOfWorkspaceResult : public ServiceResult + { + public: + struct Result + { + struct DataItem + { + int jobStatus; + std::string cubeId; + std::string cubeName; + std::string size; + std::string jobHistoryId; + std::string lastModifyTime; + std::string creatorName; + std::string jobId; + std::string enableQuickindexTime; + }; + int pre; + int totalNum; + int pageNum; + int pageSize; + int next; + std::vector data; + int totalPages; + }; + + + ListAccelerationOfWorkspaceResult(); + explicit ListAccelerationOfWorkspaceResult(const std::string &payload); + ~ListAccelerationOfWorkspaceResult(); + bool getSuccess()const; + Result getResult()const; + + protected: + void parse(const std::string &payload); + private: + bool success_; + Result result_; + + }; + } + } +} +#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTACCELERATIONOFWORKSPACERESULT_H_ \ No newline at end of file diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusRequest.h b/quickbi-public/include/alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusRequest.h new file mode 100644 index 000000000..07b94cb66 --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusRequest.h @@ -0,0 +1,51 @@ +/* + * 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_MODIFYDASHBOARDNL2SQLSTATUSREQUEST_H_ +#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_MODIFYDASHBOARDNL2SQLSTATUSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Quickbi_public { +namespace Model { +class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT ModifyDashboardNl2sqlStatusRequest : public RpcServiceRequest { +public: + ModifyDashboardNl2sqlStatusRequest(); + ~ModifyDashboardNl2sqlStatusRequest(); + std::string getAccessPoint() const; + void setAccessPoint(const std::string &accessPoint); + std::string getSignType() const; + void setSignType(const std::string &signType); + std::string getDashboardIds() const; + void setDashboardIds(const std::string &dashboardIds); + int getStatus() const; + void setStatus(int status); + +private: + std::string accessPoint_; + std::string signType_; + std::string dashboardIds_; + int status_; +}; +} // namespace Model +} // namespace Quickbi_public +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_MODIFYDASHBOARDNL2SQLSTATUSREQUEST_H_ diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusResult.h b/quickbi-public/include/alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusResult.h new file mode 100644 index 000000000..e06cbef0f --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/ModifyDashboardNl2sqlStatusResult.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_MODIFYDASHBOARDNL2SQLSTATUSRESULT_H_ +#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_MODIFYDASHBOARDNL2SQLSTATUSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Quickbi_public + { + namespace Model + { + class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT ModifyDashboardNl2sqlStatusResult : public ServiceResult + { + public: + + + ModifyDashboardNl2sqlStatusResult(); + explicit ModifyDashboardNl2sqlStatusResult(const std::string &payload); + ~ModifyDashboardNl2sqlStatusResult(); + bool getSuccess()const; + std::vector getResult()const; + + protected: + void parse(const std::string &payload); + private: + bool success_; + std::vector result_; + + }; + } + } +} +#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_MODIFYDASHBOARDNL2SQLSTATUSRESULT_H_ \ No newline at end of file diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdRequest.h b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdRequest.h new file mode 100644 index 000000000..8158d0201 --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdRequest.h @@ -0,0 +1,60 @@ +/* + * 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_QUERYACCELERATIONLOGBYCUBEIDREQUEST_H_ +#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYACCELERATIONLOGBYCUBEIDREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Quickbi_public { +namespace Model { +class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryAccelerationLogByCubeIdRequest : public RpcServiceRequest { +public: + QueryAccelerationLogByCubeIdRequest(); + ~QueryAccelerationLogByCubeIdRequest(); + std::string getAccessPoint() const; + void setAccessPoint(const std::string &accessPoint); + std::string getStartDate() const; + void setStartDate(const std::string &startDate); + int getPageSize() const; + void setPageSize(int pageSize); + std::string getCubeId() const; + void setCubeId(const std::string &cubeId); + std::string getSignType() const; + void setSignType(const std::string &signType); + std::string getEndDate() const; + void setEndDate(const std::string &endDate); + int getPageNo() const; + void setPageNo(int pageNo); + +private: + std::string accessPoint_; + std::string startDate_; + int pageSize_; + std::string cubeId_; + std::string signType_; + std::string endDate_; + int pageNo_; +}; +} // namespace Model +} // namespace Quickbi_public +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYACCELERATIONLOGBYCUBEIDREQUEST_H_ diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdResult.h b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdResult.h new file mode 100644 index 000000000..8b0285a5b --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryAccelerationLogByCubeIdResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYACCELERATIONLOGBYCUBEIDRESULT_H_ +#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYACCELERATIONLOGBYCUBEIDRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Quickbi_public + { + namespace Model + { + class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryAccelerationLogByCubeIdResult : public ServiceResult + { + public: + struct Result + { + struct DataItem + { + std::string jobStatus; + std::string jonStartDate; + std::string log; + std::string jobHistoryId; + std::string duration; + std::string jobId; + }; + int pre; + int totalNum; + int pageNum; + int pageSize; + int next; + std::vector data; + int totalPages; + }; + + + QueryAccelerationLogByCubeIdResult(); + explicit QueryAccelerationLogByCubeIdResult(const std::string &payload); + ~QueryAccelerationLogByCubeIdResult(); + bool getSuccess()const; + Result getResult()const; + + protected: + void parse(const std::string &payload); + private: + bool success_; + Result result_; + + }; + } + } +} +#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYACCELERATIONLOGBYCUBEIDRESULT_H_ \ No newline at end of file diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/SmartqQueryAbilityRequest.h b/quickbi-public/include/alibabacloud/quickbi-public/model/SmartqQueryAbilityRequest.h index d7817ef6d..4ba55a9e9 100644 --- a/quickbi-public/include/alibabacloud/quickbi-public/model/SmartqQueryAbilityRequest.h +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/SmartqQueryAbilityRequest.h @@ -38,6 +38,8 @@ public: void setUserQuestion(const std::string &userQuestion); std::string getCubeId() const; void setCubeId(const std::string &cubeId); + std::string getMultipleCubeIds() const; + void setMultipleCubeIds(const std::string &multipleCubeIds); std::string getSignType() const; void setSignType(const std::string &signType); @@ -46,6 +48,7 @@ private: std::string userId_; std::string userQuestion_; std::string cubeId_; + std::string multipleCubeIds_; std::string signType_; }; } // namespace Model diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/SmartqQueryAbilityResult.h b/quickbi-public/include/alibabacloud/quickbi-public/model/SmartqQueryAbilityResult.h index 6412de7b1..c435411c1 100644 --- a/quickbi-public/include/alibabacloud/quickbi-public/model/SmartqQueryAbilityResult.h +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/SmartqQueryAbilityResult.h @@ -44,6 +44,7 @@ namespace AlibabaCloud { std::vector row; }; + std::vector dataList; std::string conclusionText; std::string logicSql; std::vector values; diff --git a/quickbi-public/src/Quickbi-publicClient.cc b/quickbi-public/src/Quickbi-publicClient.cc index bed5344a3..b87b068be 100644 --- a/quickbi-public/src/Quickbi-publicClient.cc +++ b/quickbi-public/src/Quickbi-publicClient.cc @@ -951,6 +951,42 @@ Quickbi_publicClient::CreateUserGroupOutcomeCallable Quickbi_publicClient::creat return task->get_future(); } +Quickbi_publicClient::CreateWorkspaceOutcome Quickbi_publicClient::createWorkspace(const CreateWorkspaceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateWorkspaceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateWorkspaceOutcome(CreateWorkspaceResult(outcome.result())); + else + return CreateWorkspaceOutcome(outcome.error()); +} + +void Quickbi_publicClient::createWorkspaceAsync(const CreateWorkspaceRequest& request, const CreateWorkspaceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createWorkspace(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Quickbi_publicClient::CreateWorkspaceOutcomeCallable Quickbi_publicClient::createWorkspaceCallable(const CreateWorkspaceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createWorkspace(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Quickbi_publicClient::DataInterpretationOutcome Quickbi_publicClient::dataInterpretation(const DataInterpretationRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1563,6 +1599,42 @@ Quickbi_publicClient::GetWorksEmbedListOutcomeCallable Quickbi_publicClient::get return task->get_future(); } +Quickbi_publicClient::ListAccelerationOfWorkspaceOutcome Quickbi_publicClient::listAccelerationOfWorkspace(const ListAccelerationOfWorkspaceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListAccelerationOfWorkspaceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListAccelerationOfWorkspaceOutcome(ListAccelerationOfWorkspaceResult(outcome.result())); + else + return ListAccelerationOfWorkspaceOutcome(outcome.error()); +} + +void Quickbi_publicClient::listAccelerationOfWorkspaceAsync(const ListAccelerationOfWorkspaceRequest& request, const ListAccelerationOfWorkspaceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listAccelerationOfWorkspace(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Quickbi_publicClient::ListAccelerationOfWorkspaceOutcomeCallable Quickbi_publicClient::listAccelerationOfWorkspaceCallable(const ListAccelerationOfWorkspaceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listAccelerationOfWorkspace(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Quickbi_publicClient::ListApiDatasourceOutcome Quickbi_publicClient::listApiDatasource(const ListApiDatasourceRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -2283,6 +2355,78 @@ Quickbi_publicClient::ModifyCopilotEmbedConfigOutcomeCallable Quickbi_publicClie return task->get_future(); } +Quickbi_publicClient::ModifyDashboardNl2sqlStatusOutcome Quickbi_publicClient::modifyDashboardNl2sqlStatus(const ModifyDashboardNl2sqlStatusRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ModifyDashboardNl2sqlStatusOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ModifyDashboardNl2sqlStatusOutcome(ModifyDashboardNl2sqlStatusResult(outcome.result())); + else + return ModifyDashboardNl2sqlStatusOutcome(outcome.error()); +} + +void Quickbi_publicClient::modifyDashboardNl2sqlStatusAsync(const ModifyDashboardNl2sqlStatusRequest& request, const ModifyDashboardNl2sqlStatusAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, modifyDashboardNl2sqlStatus(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Quickbi_publicClient::ModifyDashboardNl2sqlStatusOutcomeCallable Quickbi_publicClient::modifyDashboardNl2sqlStatusCallable(const ModifyDashboardNl2sqlStatusRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->modifyDashboardNl2sqlStatus(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Quickbi_publicClient::QueryAccelerationLogByCubeIdOutcome Quickbi_publicClient::queryAccelerationLogByCubeId(const QueryAccelerationLogByCubeIdRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return QueryAccelerationLogByCubeIdOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return QueryAccelerationLogByCubeIdOutcome(QueryAccelerationLogByCubeIdResult(outcome.result())); + else + return QueryAccelerationLogByCubeIdOutcome(outcome.error()); +} + +void Quickbi_publicClient::queryAccelerationLogByCubeIdAsync(const QueryAccelerationLogByCubeIdRequest& request, const QueryAccelerationLogByCubeIdAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, queryAccelerationLogByCubeId(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Quickbi_publicClient::QueryAccelerationLogByCubeIdOutcomeCallable Quickbi_publicClient::queryAccelerationLogByCubeIdCallable(const QueryAccelerationLogByCubeIdRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->queryAccelerationLogByCubeId(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Quickbi_publicClient::QueryApprovalInfoOutcome Quickbi_publicClient::queryApprovalInfo(const QueryApprovalInfoRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/quickbi-public/src/model/CreateWorkspaceRequest.cc b/quickbi-public/src/model/CreateWorkspaceRequest.cc new file mode 100644 index 000000000..9d16b62b2 --- /dev/null +++ b/quickbi-public/src/model/CreateWorkspaceRequest.cc @@ -0,0 +1,117 @@ +/* + * 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::Quickbi_public::Model::CreateWorkspaceRequest; + +CreateWorkspaceRequest::CreateWorkspaceRequest() + : RpcServiceRequest("quickbi-public", "2022-01-01", "CreateWorkspace") { + setMethod(HttpRequest::Method::Post); +} + +CreateWorkspaceRequest::~CreateWorkspaceRequest() {} + +bool CreateWorkspaceRequest::getAllowViewAll() const { + return allowViewAll_; +} + +void CreateWorkspaceRequest::setAllowViewAll(bool allowViewAll) { + allowViewAll_ = allowViewAll; + setParameter(std::string("AllowViewAll"), allowViewAll ? "true" : "false"); +} + +std::string CreateWorkspaceRequest::getAccessPoint() const { + return accessPoint_; +} + +void CreateWorkspaceRequest::setAccessPoint(const std::string &accessPoint) { + accessPoint_ = accessPoint; + setParameter(std::string("AccessPoint"), accessPoint); +} + +std::string CreateWorkspaceRequest::getWorkspaceName() const { + return workspaceName_; +} + +void CreateWorkspaceRequest::setWorkspaceName(const std::string &workspaceName) { + workspaceName_ = workspaceName; + setParameter(std::string("WorkspaceName"), workspaceName); +} + +std::string CreateWorkspaceRequest::getWorkspaceDescription() const { + return workspaceDescription_; +} + +void CreateWorkspaceRequest::setWorkspaceDescription(const std::string &workspaceDescription) { + workspaceDescription_ = workspaceDescription; + setParameter(std::string("WorkspaceDescription"), workspaceDescription); +} + +bool CreateWorkspaceRequest::getOnlyAdminCreateDatasource() const { + return onlyAdminCreateDatasource_; +} + +void CreateWorkspaceRequest::setOnlyAdminCreateDatasource(bool onlyAdminCreateDatasource) { + onlyAdminCreateDatasource_ = onlyAdminCreateDatasource; + setParameter(std::string("OnlyAdminCreateDatasource"), onlyAdminCreateDatasource ? "true" : "false"); +} + +std::string CreateWorkspaceRequest::getSignType() const { + return signType_; +} + +void CreateWorkspaceRequest::setSignType(const std::string &signType) { + signType_ = signType; + setParameter(std::string("SignType"), signType); +} + +bool CreateWorkspaceRequest::getAllowShare() const { + return allowShare_; +} + +void CreateWorkspaceRequest::setAllowShare(bool allowShare) { + allowShare_ = allowShare; + setParameter(std::string("AllowShare"), allowShare ? "true" : "false"); +} + +bool CreateWorkspaceRequest::getDefaultShareToAll() const { + return defaultShareToAll_; +} + +void CreateWorkspaceRequest::setDefaultShareToAll(bool defaultShareToAll) { + defaultShareToAll_ = defaultShareToAll; + setParameter(std::string("DefaultShareToAll"), defaultShareToAll ? "true" : "false"); +} + +bool CreateWorkspaceRequest::getAllowPublish() const { + return allowPublish_; +} + +void CreateWorkspaceRequest::setAllowPublish(bool allowPublish) { + allowPublish_ = allowPublish; + setParameter(std::string("AllowPublish"), allowPublish ? "true" : "false"); +} + +bool CreateWorkspaceRequest::getUseComment() const { + return useComment_; +} + +void CreateWorkspaceRequest::setUseComment(bool useComment) { + useComment_ = useComment; + setParameter(std::string("UseComment"), useComment ? "true" : "false"); +} + diff --git a/quickbi-public/src/model/CreateWorkspaceResult.cc b/quickbi-public/src/model/CreateWorkspaceResult.cc new file mode 100644 index 000000000..263a747dd --- /dev/null +++ b/quickbi-public/src/model/CreateWorkspaceResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Quickbi_public; +using namespace AlibabaCloud::Quickbi_public::Model; + +CreateWorkspaceResult::CreateWorkspaceResult() : + ServiceResult() +{} + +CreateWorkspaceResult::CreateWorkspaceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateWorkspaceResult::~CreateWorkspaceResult() +{} + +void CreateWorkspaceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Result"].isNull()) + result_ = value["Result"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +bool CreateWorkspaceResult::getSuccess()const +{ + return success_; +} + +std::string CreateWorkspaceResult::getResult()const +{ + return result_; +} + diff --git a/quickbi-public/src/model/ListAccelerationOfWorkspaceRequest.cc b/quickbi-public/src/model/ListAccelerationOfWorkspaceRequest.cc new file mode 100644 index 000000000..992988e3a --- /dev/null +++ b/quickbi-public/src/model/ListAccelerationOfWorkspaceRequest.cc @@ -0,0 +1,90 @@ +/* + * 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::Quickbi_public::Model::ListAccelerationOfWorkspaceRequest; + +ListAccelerationOfWorkspaceRequest::ListAccelerationOfWorkspaceRequest() + : RpcServiceRequest("quickbi-public", "2022-01-01", "ListAccelerationOfWorkspace") { + setMethod(HttpRequest::Method::Post); +} + +ListAccelerationOfWorkspaceRequest::~ListAccelerationOfWorkspaceRequest() {} + +std::string ListAccelerationOfWorkspaceRequest::getAccessPoint() const { + return accessPoint_; +} + +void ListAccelerationOfWorkspaceRequest::setAccessPoint(const std::string &accessPoint) { + accessPoint_ = accessPoint; + setParameter(std::string("AccessPoint"), accessPoint); +} + +std::string ListAccelerationOfWorkspaceRequest::getCubeName() const { + return cubeName_; +} + +void ListAccelerationOfWorkspaceRequest::setCubeName(const std::string &cubeName) { + cubeName_ = cubeName; + setParameter(std::string("CubeName"), cubeName); +} + +int ListAccelerationOfWorkspaceRequest::getPageSize() const { + return pageSize_; +} + +void ListAccelerationOfWorkspaceRequest::setPageSize(int pageSize) { + pageSize_ = pageSize; + setParameter(std::string("PageSize"), std::to_string(pageSize)); +} + +std::string ListAccelerationOfWorkspaceRequest::getCreatorId() const { + return creatorId_; +} + +void ListAccelerationOfWorkspaceRequest::setCreatorId(const std::string &creatorId) { + creatorId_ = creatorId; + setParameter(std::string("CreatorId"), creatorId); +} + +std::string ListAccelerationOfWorkspaceRequest::getSignType() const { + return signType_; +} + +void ListAccelerationOfWorkspaceRequest::setSignType(const std::string &signType) { + signType_ = signType; + setParameter(std::string("SignType"), signType); +} + +int ListAccelerationOfWorkspaceRequest::getPageNo() const { + return pageNo_; +} + +void ListAccelerationOfWorkspaceRequest::setPageNo(int pageNo) { + pageNo_ = pageNo; + setParameter(std::string("PageNo"), std::to_string(pageNo)); +} + +std::string ListAccelerationOfWorkspaceRequest::getWorkspaceId() const { + return workspaceId_; +} + +void ListAccelerationOfWorkspaceRequest::setWorkspaceId(const std::string &workspaceId) { + workspaceId_ = workspaceId; + setParameter(std::string("WorkspaceId"), workspaceId); +} + diff --git a/quickbi-public/src/model/ListAccelerationOfWorkspaceResult.cc b/quickbi-public/src/model/ListAccelerationOfWorkspaceResult.cc new file mode 100644 index 000000000..b96e1480b --- /dev/null +++ b/quickbi-public/src/model/ListAccelerationOfWorkspaceResult.cc @@ -0,0 +1,93 @@ +/* + * 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::Quickbi_public; +using namespace AlibabaCloud::Quickbi_public::Model; + +ListAccelerationOfWorkspaceResult::ListAccelerationOfWorkspaceResult() : + ServiceResult() +{} + +ListAccelerationOfWorkspaceResult::ListAccelerationOfWorkspaceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListAccelerationOfWorkspaceResult::~ListAccelerationOfWorkspaceResult() +{} + +void ListAccelerationOfWorkspaceResult::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()); + if(!resultNode["Pre"].isNull()) + result_.pre = std::stoi(resultNode["Pre"].asString()); + if(!resultNode["Next"].isNull()) + result_.next = std::stoi(resultNode["Next"].asString()); + auto allDataNode = resultNode["Data"]["DataItem"]; + for (auto resultNodeDataDataItem : allDataNode) + { + Result::DataItem dataItemObject; + if(!resultNodeDataDataItem["CubeId"].isNull()) + dataItemObject.cubeId = resultNodeDataDataItem["CubeId"].asString(); + if(!resultNodeDataDataItem["CubeName"].isNull()) + dataItemObject.cubeName = resultNodeDataDataItem["CubeName"].asString(); + if(!resultNodeDataDataItem["CreatorName"].isNull()) + dataItemObject.creatorName = resultNodeDataDataItem["CreatorName"].asString(); + if(!resultNodeDataDataItem["Size"].isNull()) + dataItemObject.size = resultNodeDataDataItem["Size"].asString(); + if(!resultNodeDataDataItem["LastModifyTime"].isNull()) + dataItemObject.lastModifyTime = resultNodeDataDataItem["LastModifyTime"].asString(); + if(!resultNodeDataDataItem["EnableQuickindexTime"].isNull()) + dataItemObject.enableQuickindexTime = resultNodeDataDataItem["EnableQuickindexTime"].asString(); + if(!resultNodeDataDataItem["JobId"].isNull()) + dataItemObject.jobId = resultNodeDataDataItem["JobId"].asString(); + if(!resultNodeDataDataItem["JobStatus"].isNull()) + dataItemObject.jobStatus = std::stoi(resultNodeDataDataItem["JobStatus"].asString()); + if(!resultNodeDataDataItem["JobHistoryId"].isNull()) + dataItemObject.jobHistoryId = resultNodeDataDataItem["JobHistoryId"].asString(); + result_.data.push_back(dataItemObject); + } + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +bool ListAccelerationOfWorkspaceResult::getSuccess()const +{ + return success_; +} + +ListAccelerationOfWorkspaceResult::Result ListAccelerationOfWorkspaceResult::getResult()const +{ + return result_; +} + diff --git a/quickbi-public/src/model/ModifyDashboardNl2sqlStatusRequest.cc b/quickbi-public/src/model/ModifyDashboardNl2sqlStatusRequest.cc new file mode 100644 index 000000000..add4f9515 --- /dev/null +++ b/quickbi-public/src/model/ModifyDashboardNl2sqlStatusRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::Quickbi_public::Model::ModifyDashboardNl2sqlStatusRequest; + +ModifyDashboardNl2sqlStatusRequest::ModifyDashboardNl2sqlStatusRequest() + : RpcServiceRequest("quickbi-public", "2022-01-01", "ModifyDashboardNl2sqlStatus") { + setMethod(HttpRequest::Method::Post); +} + +ModifyDashboardNl2sqlStatusRequest::~ModifyDashboardNl2sqlStatusRequest() {} + +std::string ModifyDashboardNl2sqlStatusRequest::getAccessPoint() const { + return accessPoint_; +} + +void ModifyDashboardNl2sqlStatusRequest::setAccessPoint(const std::string &accessPoint) { + accessPoint_ = accessPoint; + setParameter(std::string("AccessPoint"), accessPoint); +} + +std::string ModifyDashboardNl2sqlStatusRequest::getSignType() const { + return signType_; +} + +void ModifyDashboardNl2sqlStatusRequest::setSignType(const std::string &signType) { + signType_ = signType; + setParameter(std::string("SignType"), signType); +} + +std::string ModifyDashboardNl2sqlStatusRequest::getDashboardIds() const { + return dashboardIds_; +} + +void ModifyDashboardNl2sqlStatusRequest::setDashboardIds(const std::string &dashboardIds) { + dashboardIds_ = dashboardIds; + setParameter(std::string("DashboardIds"), dashboardIds); +} + +int ModifyDashboardNl2sqlStatusRequest::getStatus() const { + return status_; +} + +void ModifyDashboardNl2sqlStatusRequest::setStatus(int status) { + status_ = status; + setParameter(std::string("Status"), std::to_string(status)); +} + diff --git a/quickbi-public/src/model/ModifyDashboardNl2sqlStatusResult.cc b/quickbi-public/src/model/ModifyDashboardNl2sqlStatusResult.cc new file mode 100644 index 000000000..2ed5eefa0 --- /dev/null +++ b/quickbi-public/src/model/ModifyDashboardNl2sqlStatusResult.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 +#include + +using namespace AlibabaCloud::Quickbi_public; +using namespace AlibabaCloud::Quickbi_public::Model; + +ModifyDashboardNl2sqlStatusResult::ModifyDashboardNl2sqlStatusResult() : + ServiceResult() +{} + +ModifyDashboardNl2sqlStatusResult::ModifyDashboardNl2sqlStatusResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ModifyDashboardNl2sqlStatusResult::~ModifyDashboardNl2sqlStatusResult() +{} + +void ModifyDashboardNl2sqlStatusResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allResult = value["Result"]["Data"]; + for (const auto &item : allResult) + result_.push_back(item.asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +bool ModifyDashboardNl2sqlStatusResult::getSuccess()const +{ + return success_; +} + +std::vector ModifyDashboardNl2sqlStatusResult::getResult()const +{ + return result_; +} + diff --git a/quickbi-public/src/model/QueryAccelerationLogByCubeIdRequest.cc b/quickbi-public/src/model/QueryAccelerationLogByCubeIdRequest.cc new file mode 100644 index 000000000..d26bab054 --- /dev/null +++ b/quickbi-public/src/model/QueryAccelerationLogByCubeIdRequest.cc @@ -0,0 +1,90 @@ +/* + * 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::Quickbi_public::Model::QueryAccelerationLogByCubeIdRequest; + +QueryAccelerationLogByCubeIdRequest::QueryAccelerationLogByCubeIdRequest() + : RpcServiceRequest("quickbi-public", "2022-01-01", "QueryAccelerationLogByCubeId") { + setMethod(HttpRequest::Method::Post); +} + +QueryAccelerationLogByCubeIdRequest::~QueryAccelerationLogByCubeIdRequest() {} + +std::string QueryAccelerationLogByCubeIdRequest::getAccessPoint() const { + return accessPoint_; +} + +void QueryAccelerationLogByCubeIdRequest::setAccessPoint(const std::string &accessPoint) { + accessPoint_ = accessPoint; + setParameter(std::string("AccessPoint"), accessPoint); +} + +std::string QueryAccelerationLogByCubeIdRequest::getStartDate() const { + return startDate_; +} + +void QueryAccelerationLogByCubeIdRequest::setStartDate(const std::string &startDate) { + startDate_ = startDate; + setParameter(std::string("StartDate"), startDate); +} + +int QueryAccelerationLogByCubeIdRequest::getPageSize() const { + return pageSize_; +} + +void QueryAccelerationLogByCubeIdRequest::setPageSize(int pageSize) { + pageSize_ = pageSize; + setParameter(std::string("PageSize"), std::to_string(pageSize)); +} + +std::string QueryAccelerationLogByCubeIdRequest::getCubeId() const { + return cubeId_; +} + +void QueryAccelerationLogByCubeIdRequest::setCubeId(const std::string &cubeId) { + cubeId_ = cubeId; + setParameter(std::string("CubeId"), cubeId); +} + +std::string QueryAccelerationLogByCubeIdRequest::getSignType() const { + return signType_; +} + +void QueryAccelerationLogByCubeIdRequest::setSignType(const std::string &signType) { + signType_ = signType; + setParameter(std::string("SignType"), signType); +} + +std::string QueryAccelerationLogByCubeIdRequest::getEndDate() const { + return endDate_; +} + +void QueryAccelerationLogByCubeIdRequest::setEndDate(const std::string &endDate) { + endDate_ = endDate; + setParameter(std::string("EndDate"), endDate); +} + +int QueryAccelerationLogByCubeIdRequest::getPageNo() const { + return pageNo_; +} + +void QueryAccelerationLogByCubeIdRequest::setPageNo(int pageNo) { + pageNo_ = pageNo; + setParameter(std::string("PageNo"), std::to_string(pageNo)); +} + diff --git a/quickbi-public/src/model/QueryAccelerationLogByCubeIdResult.cc b/quickbi-public/src/model/QueryAccelerationLogByCubeIdResult.cc new file mode 100644 index 000000000..3bc3e4610 --- /dev/null +++ b/quickbi-public/src/model/QueryAccelerationLogByCubeIdResult.cc @@ -0,0 +1,87 @@ +/* + * 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::Quickbi_public; +using namespace AlibabaCloud::Quickbi_public::Model; + +QueryAccelerationLogByCubeIdResult::QueryAccelerationLogByCubeIdResult() : + ServiceResult() +{} + +QueryAccelerationLogByCubeIdResult::QueryAccelerationLogByCubeIdResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +QueryAccelerationLogByCubeIdResult::~QueryAccelerationLogByCubeIdResult() +{} + +void QueryAccelerationLogByCubeIdResult::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()); + if(!resultNode["Pre"].isNull()) + result_.pre = std::stoi(resultNode["Pre"].asString()); + if(!resultNode["Next"].isNull()) + result_.next = std::stoi(resultNode["Next"].asString()); + auto allDataNode = resultNode["Data"]["DataItem"]; + for (auto resultNodeDataDataItem : allDataNode) + { + Result::DataItem dataItemObject; + if(!resultNodeDataDataItem["JobId"].isNull()) + dataItemObject.jobId = resultNodeDataDataItem["JobId"].asString(); + if(!resultNodeDataDataItem["JobHistoryId"].isNull()) + dataItemObject.jobHistoryId = resultNodeDataDataItem["JobHistoryId"].asString(); + if(!resultNodeDataDataItem["JonStartDate"].isNull()) + dataItemObject.jonStartDate = resultNodeDataDataItem["JonStartDate"].asString(); + if(!resultNodeDataDataItem["JobStatus"].isNull()) + dataItemObject.jobStatus = resultNodeDataDataItem["JobStatus"].asString(); + if(!resultNodeDataDataItem["Duration"].isNull()) + dataItemObject.duration = resultNodeDataDataItem["Duration"].asString(); + if(!resultNodeDataDataItem["Log"].isNull()) + dataItemObject.log = resultNodeDataDataItem["Log"].asString(); + result_.data.push_back(dataItemObject); + } + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +bool QueryAccelerationLogByCubeIdResult::getSuccess()const +{ + return success_; +} + +QueryAccelerationLogByCubeIdResult::Result QueryAccelerationLogByCubeIdResult::getResult()const +{ + return result_; +} + diff --git a/quickbi-public/src/model/SmartqQueryAbilityRequest.cc b/quickbi-public/src/model/SmartqQueryAbilityRequest.cc index 780c95471..b13e90573 100644 --- a/quickbi-public/src/model/SmartqQueryAbilityRequest.cc +++ b/quickbi-public/src/model/SmartqQueryAbilityRequest.cc @@ -61,6 +61,15 @@ void SmartqQueryAbilityRequest::setCubeId(const std::string &cubeId) { setParameter(std::string("CubeId"), cubeId); } +std::string SmartqQueryAbilityRequest::getMultipleCubeIds() const { + return multipleCubeIds_; +} + +void SmartqQueryAbilityRequest::setMultipleCubeIds(const std::string &multipleCubeIds) { + multipleCubeIds_ = multipleCubeIds; + setParameter(std::string("MultipleCubeIds"), multipleCubeIds); +} + std::string SmartqQueryAbilityRequest::getSignType() const { return signType_; } diff --git a/quickbi-public/src/model/SmartqQueryAbilityResult.cc b/quickbi-public/src/model/SmartqQueryAbilityResult.cc index 0e2a8ddb2..cdd6a4d3b 100644 --- a/quickbi-public/src/model/SmartqQueryAbilityResult.cc +++ b/quickbi-public/src/model/SmartqQueryAbilityResult.cc @@ -67,6 +67,9 @@ void SmartqQueryAbilityResult::parse(const std::string &payload) valuesItemObject.row.push_back(value.asString()); result_.values.push_back(valuesItemObject); } + auto allDataList = resultNode["DataList"]["DataList"]; + for (auto value : allDataList) + result_.dataList.push_back(value.asString()); if(!value["Success"].isNull()) success_ = value["Success"].asString() == "true";