1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add SmartQ APIs.

Browse Source
This commit is contained in:
sdk-team
2024-12-30 03:17:17 +00:00
parent dbe02e376e
commit 6deaa997fb
40 changed files with 2076 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.2035
1.36.2036

28
quickbi-public/CMakeLists.txt
View File

@@ -85,6 +85,8 @@ set(quickbi-public_public_header_model
include/alibabacloud/quickbi-public/model/DeleteUserGroupMembersResult.h
include/alibabacloud/quickbi-public/model/DeleteUserTagMetaRequest.h
include/alibabacloud/quickbi-public/model/DeleteUserTagMetaResult.h
include/alibabacloud/quickbi-public/model/GetDataSourceConnectionInfoRequest.h
include/alibabacloud/quickbi-public/model/GetDataSourceConnectionInfoResult.h
include/alibabacloud/quickbi-public/model/GetMailTaskStatusRequest.h
include/alibabacloud/quickbi-public/model/GetMailTaskStatusResult.h
include/alibabacloud/quickbi-public/model/GetUserGroupInfoRequest.h
@@ -101,6 +103,8 @@ set(quickbi-public_public_header_model
include/alibabacloud/quickbi-public/model/ListCubeDataLevelPermissionConfigResult.h
include/alibabacloud/quickbi-public/model/ListDataLevelPermissionWhiteListRequest.h
include/alibabacloud/quickbi-public/model/ListDataLevelPermissionWhiteListResult.h
include/alibabacloud/quickbi-public/model/ListDataSourceRequest.h
include/alibabacloud/quickbi-public/model/ListDataSourceResult.h
include/alibabacloud/quickbi-public/model/ListFavoriteReportsRequest.h
include/alibabacloud/quickbi-public/model/ListFavoriteReportsResult.h
include/alibabacloud/quickbi-public/model/ListOrganizationRoleUsersRequest.h
@@ -153,12 +157,16 @@ set(quickbi-public_public_header_model
include/alibabacloud/quickbi-public/model/QueryDatasetInfoResult.h
include/alibabacloud/quickbi-public/model/QueryDatasetListRequest.h
include/alibabacloud/quickbi-public/model/QueryDatasetListResult.h
include/alibabacloud/quickbi-public/model/QueryDatasetSmartqStatusRequest.h
include/alibabacloud/quickbi-public/model/QueryDatasetSmartqStatusResult.h
include/alibabacloud/quickbi-public/model/QueryDatasetSwitchInfoRequest.h
include/alibabacloud/quickbi-public/model/QueryDatasetSwitchInfoResult.h
include/alibabacloud/quickbi-public/model/QueryEmbeddedInfoRequest.h
include/alibabacloud/quickbi-public/model/QueryEmbeddedInfoResult.h
include/alibabacloud/quickbi-public/model/QueryEmbeddedStatusRequest.h
include/alibabacloud/quickbi-public/model/QueryEmbeddedStatusResult.h
include/alibabacloud/quickbi-public/model/QueryLlmCubeWithThemeListByUserIdRequest.h
include/alibabacloud/quickbi-public/model/QueryLlmCubeWithThemeListByUserIdResult.h
include/alibabacloud/quickbi-public/model/QueryOrganizationRoleConfigRequest.h
include/alibabacloud/quickbi-public/model/QueryOrganizationRoleConfigResult.h
include/alibabacloud/quickbi-public/model/QueryOrganizationWorkspaceListRequest.h
@@ -171,6 +179,8 @@ set(quickbi-public_public_header_model
include/alibabacloud/quickbi-public/model/QueryShareListResult.h
include/alibabacloud/quickbi-public/model/QuerySharesToUserListRequest.h
include/alibabacloud/quickbi-public/model/QuerySharesToUserListResult.h
include/alibabacloud/quickbi-public/model/QuerySmartqPermissionByCubeIdRequest.h
include/alibabacloud/quickbi-public/model/QuerySmartqPermissionByCubeIdResult.h
include/alibabacloud/quickbi-public/model/QueryTicketInfoRequest.h
include/alibabacloud/quickbi-public/model/QueryTicketInfoResult.h
include/alibabacloud/quickbi-public/model/QueryUserGroupListByParentIdRequest.h
@@ -211,6 +221,10 @@ set(quickbi-public_public_header_model
include/alibabacloud/quickbi-public/model/SetDataLevelPermissionRuleConfigResult.h
include/alibabacloud/quickbi-public/model/SetDataLevelPermissionWhiteListRequest.h
include/alibabacloud/quickbi-public/model/SetDataLevelPermissionWhiteListResult.h
include/alibabacloud/quickbi-public/model/SmartqAuthTransferRequest.h
include/alibabacloud/quickbi-public/model/SmartqAuthTransferResult.h
include/alibabacloud/quickbi-public/model/SmartqAuthorizeRequest.h
include/alibabacloud/quickbi-public/model/SmartqAuthorizeResult.h
include/alibabacloud/quickbi-public/model/SmartqQueryAbilityRequest.h
include/alibabacloud/quickbi-public/model/SmartqQueryAbilityResult.h
include/alibabacloud/quickbi-public/model/UpdateDataLevelPermissionStatusRequest.h
@@ -300,6 +314,8 @@ set(quickbi-public_src
src/model/DeleteUserGroupMembersResult.cc
src/model/DeleteUserTagMetaRequest.cc
src/model/DeleteUserTagMetaResult.cc
src/model/GetDataSourceConnectionInfoRequest.cc
src/model/GetDataSourceConnectionInfoResult.cc
src/model/GetMailTaskStatusRequest.cc
src/model/GetMailTaskStatusResult.cc
src/model/GetUserGroupInfoRequest.cc
@@ -316,6 +332,8 @@ set(quickbi-public_src
src/model/ListCubeDataLevelPermissionConfigResult.cc
src/model/ListDataLevelPermissionWhiteListRequest.cc
src/model/ListDataLevelPermissionWhiteListResult.cc
src/model/ListDataSourceRequest.cc
src/model/ListDataSourceResult.cc
src/model/ListFavoriteReportsRequest.cc
src/model/ListFavoriteReportsResult.cc
src/model/ListOrganizationRoleUsersRequest.cc
@@ -368,12 +386,16 @@ set(quickbi-public_src
src/model/QueryDatasetInfoResult.cc
src/model/QueryDatasetListRequest.cc
src/model/QueryDatasetListResult.cc
src/model/QueryDatasetSmartqStatusRequest.cc
src/model/QueryDatasetSmartqStatusResult.cc
src/model/QueryDatasetSwitchInfoRequest.cc
src/model/QueryDatasetSwitchInfoResult.cc
src/model/QueryEmbeddedInfoRequest.cc
src/model/QueryEmbeddedInfoResult.cc
src/model/QueryEmbeddedStatusRequest.cc
src/model/QueryEmbeddedStatusResult.cc
src/model/QueryLlmCubeWithThemeListByUserIdRequest.cc
src/model/QueryLlmCubeWithThemeListByUserIdResult.cc
src/model/QueryOrganizationRoleConfigRequest.cc
src/model/QueryOrganizationRoleConfigResult.cc
src/model/QueryOrganizationWorkspaceListRequest.cc
@@ -386,6 +408,8 @@ set(quickbi-public_src
src/model/QueryShareListResult.cc
src/model/QuerySharesToUserListRequest.cc
src/model/QuerySharesToUserListResult.cc
src/model/QuerySmartqPermissionByCubeIdRequest.cc
src/model/QuerySmartqPermissionByCubeIdResult.cc
src/model/QueryTicketInfoRequest.cc
src/model/QueryTicketInfoResult.cc
src/model/QueryUserGroupListByParentIdRequest.cc
@@ -426,6 +450,10 @@ set(quickbi-public_src
src/model/SetDataLevelPermissionRuleConfigResult.cc
src/model/SetDataLevelPermissionWhiteListRequest.cc
src/model/SetDataLevelPermissionWhiteListResult.cc
src/model/SmartqAuthTransferRequest.cc
src/model/SmartqAuthTransferResult.cc
src/model/SmartqAuthorizeRequest.cc
src/model/SmartqAuthorizeResult.cc
src/model/SmartqQueryAbilityRequest.cc
src/model/SmartqQueryAbilityResult.cc
src/model/UpdateDataLevelPermissionStatusRequest.cc

56
quickbi-public/include/alibabacloud/quickbi-public/Quickbi_publicClient.h
View File

@@ -86,6 +86,8 @@
#include "model/DeleteUserGroupMembersResult.h"
#include "model/DeleteUserTagMetaRequest.h"
#include "model/DeleteUserTagMetaResult.h"
#include "model/GetDataSourceConnectionInfoRequest.h"
#include "model/GetDataSourceConnectionInfoResult.h"
#include "model/GetMailTaskStatusRequest.h"
#include "model/GetMailTaskStatusResult.h"
#include "model/GetUserGroupInfoRequest.h"
@@ -102,6 +104,8 @@
#include "model/ListCubeDataLevelPermissionConfigResult.h"
#include "model/ListDataLevelPermissionWhiteListRequest.h"
#include "model/ListDataLevelPermissionWhiteListResult.h"
#include "model/ListDataSourceRequest.h"
#include "model/ListDataSourceResult.h"
#include "model/ListFavoriteReportsRequest.h"
#include "model/ListFavoriteReportsResult.h"
#include "model/ListOrganizationRoleUsersRequest.h"
@@ -154,12 +158,16 @@
#include "model/QueryDatasetInfoResult.h"
#include "model/QueryDatasetListRequest.h"
#include "model/QueryDatasetListResult.h"
#include "model/QueryDatasetSmartqStatusRequest.h"
#include "model/QueryDatasetSmartqStatusResult.h"
#include "model/QueryDatasetSwitchInfoRequest.h"
#include "model/QueryDatasetSwitchInfoResult.h"
#include "model/QueryEmbeddedInfoRequest.h"
#include "model/QueryEmbeddedInfoResult.h"
#include "model/QueryEmbeddedStatusRequest.h"
#include "model/QueryEmbeddedStatusResult.h"
#include "model/QueryLlmCubeWithThemeListByUserIdRequest.h"
#include "model/QueryLlmCubeWithThemeListByUserIdResult.h"
#include "model/QueryOrganizationRoleConfigRequest.h"
#include "model/QueryOrganizationRoleConfigResult.h"
#include "model/QueryOrganizationWorkspaceListRequest.h"
@@ -172,6 +180,8 @@
#include "model/QueryShareListResult.h"
#include "model/QuerySharesToUserListRequest.h"
#include "model/QuerySharesToUserListResult.h"
#include "model/QuerySmartqPermissionByCubeIdRequest.h"
#include "model/QuerySmartqPermissionByCubeIdResult.h"
#include "model/QueryTicketInfoRequest.h"
#include "model/QueryTicketInfoResult.h"
#include "model/QueryUserGroupListByParentIdRequest.h"
@@ -212,6 +222,10 @@
#include "model/SetDataLevelPermissionRuleConfigResult.h"
#include "model/SetDataLevelPermissionWhiteListRequest.h"
#include "model/SetDataLevelPermissionWhiteListResult.h"
#include "model/SmartqAuthTransferRequest.h"
#include "model/SmartqAuthTransferResult.h"
#include "model/SmartqAuthorizeRequest.h"
#include "model/SmartqAuthorizeResult.h"
#include "model/SmartqQueryAbilityRequest.h"
#include "model/SmartqQueryAbilityResult.h"
#include "model/UpdateDataLevelPermissionStatusRequest.h"
@@ -339,6 +353,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteUserTagMetaResult> DeleteUserTagMetaOutcome;
typedef std::future<DeleteUserTagMetaOutcome> DeleteUserTagMetaOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::DeleteUserTagMetaRequest&, const DeleteUserTagMetaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteUserTagMetaAsyncHandler;
typedef Outcome<Error, Model::GetDataSourceConnectionInfoResult> GetDataSourceConnectionInfoOutcome;
typedef std::future<GetDataSourceConnectionInfoOutcome> GetDataSourceConnectionInfoOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::GetDataSourceConnectionInfoRequest&, const GetDataSourceConnectionInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDataSourceConnectionInfoAsyncHandler;
typedef Outcome<Error, Model::GetMailTaskStatusResult> GetMailTaskStatusOutcome;
typedef std::future<GetMailTaskStatusOutcome> GetMailTaskStatusOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::GetMailTaskStatusRequest&, const GetMailTaskStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMailTaskStatusAsyncHandler;
@@ -363,6 +380,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ListDataLevelPermissionWhiteListResult> ListDataLevelPermissionWhiteListOutcome;
typedef std::future<ListDataLevelPermissionWhiteListOutcome> ListDataLevelPermissionWhiteListOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::ListDataLevelPermissionWhiteListRequest&, const ListDataLevelPermissionWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDataLevelPermissionWhiteListAsyncHandler;
typedef Outcome<Error, Model::ListDataSourceResult> ListDataSourceOutcome;
typedef std::future<ListDataSourceOutcome> ListDataSourceOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::ListDataSourceRequest&, const ListDataSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDataSourceAsyncHandler;
typedef Outcome<Error, Model::ListFavoriteReportsResult> ListFavoriteReportsOutcome;
typedef std::future<ListFavoriteReportsOutcome> ListFavoriteReportsOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::ListFavoriteReportsRequest&, const ListFavoriteReportsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFavoriteReportsAsyncHandler;
@@ -441,6 +461,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::QueryDatasetListResult> QueryDatasetListOutcome;
typedef std::future<QueryDatasetListOutcome> QueryDatasetListOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::QueryDatasetListRequest&, const QueryDatasetListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryDatasetListAsyncHandler;
typedef Outcome<Error, Model::QueryDatasetSmartqStatusResult> QueryDatasetSmartqStatusOutcome;
typedef std::future<QueryDatasetSmartqStatusOutcome> QueryDatasetSmartqStatusOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::QueryDatasetSmartqStatusRequest&, const QueryDatasetSmartqStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryDatasetSmartqStatusAsyncHandler;
typedef Outcome<Error, Model::QueryDatasetSwitchInfoResult> QueryDatasetSwitchInfoOutcome;
typedef std::future<QueryDatasetSwitchInfoOutcome> QueryDatasetSwitchInfoOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::QueryDatasetSwitchInfoRequest&, const QueryDatasetSwitchInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryDatasetSwitchInfoAsyncHandler;
@@ -450,6 +473,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::QueryEmbeddedStatusResult> QueryEmbeddedStatusOutcome;
typedef std::future<QueryEmbeddedStatusOutcome> QueryEmbeddedStatusOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::QueryEmbeddedStatusRequest&, const QueryEmbeddedStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryEmbeddedStatusAsyncHandler;
typedef Outcome<Error, Model::QueryLlmCubeWithThemeListByUserIdResult> QueryLlmCubeWithThemeListByUserIdOutcome;
typedef std::future<QueryLlmCubeWithThemeListByUserIdOutcome> QueryLlmCubeWithThemeListByUserIdOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::QueryLlmCubeWithThemeListByUserIdRequest&, const QueryLlmCubeWithThemeListByUserIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryLlmCubeWithThemeListByUserIdAsyncHandler;
typedef Outcome<Error, Model::QueryOrganizationRoleConfigResult> QueryOrganizationRoleConfigOutcome;
typedef std::future<QueryOrganizationRoleConfigOutcome> QueryOrganizationRoleConfigOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::QueryOrganizationRoleConfigRequest&, const QueryOrganizationRoleConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryOrganizationRoleConfigAsyncHandler;
@@ -468,6 +494,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::QuerySharesToUserListResult> QuerySharesToUserListOutcome;
typedef std::future<QuerySharesToUserListOutcome> QuerySharesToUserListOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::QuerySharesToUserListRequest&, const QuerySharesToUserListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QuerySharesToUserListAsyncHandler;
typedef Outcome<Error, Model::QuerySmartqPermissionByCubeIdResult> QuerySmartqPermissionByCubeIdOutcome;
typedef std::future<QuerySmartqPermissionByCubeIdOutcome> QuerySmartqPermissionByCubeIdOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::QuerySmartqPermissionByCubeIdRequest&, const QuerySmartqPermissionByCubeIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QuerySmartqPermissionByCubeIdAsyncHandler;
typedef Outcome<Error, Model::QueryTicketInfoResult> QueryTicketInfoOutcome;
typedef std::future<QueryTicketInfoOutcome> QueryTicketInfoOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::QueryTicketInfoRequest&, const QueryTicketInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryTicketInfoAsyncHandler;
@@ -528,6 +557,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::SetDataLevelPermissionWhiteListResult> SetDataLevelPermissionWhiteListOutcome;
typedef std::future<SetDataLevelPermissionWhiteListOutcome> SetDataLevelPermissionWhiteListOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::SetDataLevelPermissionWhiteListRequest&, const SetDataLevelPermissionWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetDataLevelPermissionWhiteListAsyncHandler;
typedef Outcome<Error, Model::SmartqAuthTransferResult> SmartqAuthTransferOutcome;
typedef std::future<SmartqAuthTransferOutcome> SmartqAuthTransferOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::SmartqAuthTransferRequest&, const SmartqAuthTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SmartqAuthTransferAsyncHandler;
typedef Outcome<Error, Model::SmartqAuthorizeResult> SmartqAuthorizeOutcome;
typedef std::future<SmartqAuthorizeOutcome> SmartqAuthorizeOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::SmartqAuthorizeRequest&, const SmartqAuthorizeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SmartqAuthorizeAsyncHandler;
typedef Outcome<Error, Model::SmartqQueryAbilityResult> SmartqQueryAbilityOutcome;
typedef std::future<SmartqQueryAbilityOutcome> SmartqQueryAbilityOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::SmartqQueryAbilityRequest&, const SmartqQueryAbilityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SmartqQueryAbilityAsyncHandler;
@@ -662,6 +697,9 @@ namespace AlibabaCloud
DeleteUserTagMetaOutcome deleteUserTagMeta(const Model::DeleteUserTagMetaRequest &request)const;
void deleteUserTagMetaAsync(const Model::DeleteUserTagMetaRequest& request, const DeleteUserTagMetaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteUserTagMetaOutcomeCallable deleteUserTagMetaCallable(const Model::DeleteUserTagMetaRequest& request) const;
GetDataSourceConnectionInfoOutcome getDataSourceConnectionInfo(const Model::GetDataSourceConnectionInfoRequest &request)const;
void getDataSourceConnectionInfoAsync(const Model::GetDataSourceConnectionInfoRequest& request, const GetDataSourceConnectionInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetDataSourceConnectionInfoOutcomeCallable getDataSourceConnectionInfoCallable(const Model::GetDataSourceConnectionInfoRequest& request) const;
GetMailTaskStatusOutcome getMailTaskStatus(const Model::GetMailTaskStatusRequest &request)const;
void getMailTaskStatusAsync(const Model::GetMailTaskStatusRequest& request, const GetMailTaskStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetMailTaskStatusOutcomeCallable getMailTaskStatusCallable(const Model::GetMailTaskStatusRequest& request) const;
@@ -686,6 +724,9 @@ namespace AlibabaCloud
ListDataLevelPermissionWhiteListOutcome listDataLevelPermissionWhiteList(const Model::ListDataLevelPermissionWhiteListRequest &request)const;
void listDataLevelPermissionWhiteListAsync(const Model::ListDataLevelPermissionWhiteListRequest& request, const ListDataLevelPermissionWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListDataLevelPermissionWhiteListOutcomeCallable listDataLevelPermissionWhiteListCallable(const Model::ListDataLevelPermissionWhiteListRequest& request) const;
ListDataSourceOutcome listDataSource(const Model::ListDataSourceRequest &request)const;
void listDataSourceAsync(const Model::ListDataSourceRequest& request, const ListDataSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListDataSourceOutcomeCallable listDataSourceCallable(const Model::ListDataSourceRequest& request) const;
ListFavoriteReportsOutcome listFavoriteReports(const Model::ListFavoriteReportsRequest &request)const;
void listFavoriteReportsAsync(const Model::ListFavoriteReportsRequest& request, const ListFavoriteReportsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListFavoriteReportsOutcomeCallable listFavoriteReportsCallable(const Model::ListFavoriteReportsRequest& request) const;
@@ -764,6 +805,9 @@ namespace AlibabaCloud
QueryDatasetListOutcome queryDatasetList(const Model::QueryDatasetListRequest &request)const;
void queryDatasetListAsync(const Model::QueryDatasetListRequest& request, const QueryDatasetListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryDatasetListOutcomeCallable queryDatasetListCallable(const Model::QueryDatasetListRequest& request) const;
QueryDatasetSmartqStatusOutcome queryDatasetSmartqStatus(const Model::QueryDatasetSmartqStatusRequest &request)const;
void queryDatasetSmartqStatusAsync(const Model::QueryDatasetSmartqStatusRequest& request, const QueryDatasetSmartqStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryDatasetSmartqStatusOutcomeCallable queryDatasetSmartqStatusCallable(const Model::QueryDatasetSmartqStatusRequest& request) const;
QueryDatasetSwitchInfoOutcome queryDatasetSwitchInfo(const Model::QueryDatasetSwitchInfoRequest &request)const;
void queryDatasetSwitchInfoAsync(const Model::QueryDatasetSwitchInfoRequest& request, const QueryDatasetSwitchInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryDatasetSwitchInfoOutcomeCallable queryDatasetSwitchInfoCallable(const Model::QueryDatasetSwitchInfoRequest& request) const;
@@ -773,6 +817,9 @@ namespace AlibabaCloud
QueryEmbeddedStatusOutcome queryEmbeddedStatus(const Model::QueryEmbeddedStatusRequest &request)const;
void queryEmbeddedStatusAsync(const Model::QueryEmbeddedStatusRequest& request, const QueryEmbeddedStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryEmbeddedStatusOutcomeCallable queryEmbeddedStatusCallable(const Model::QueryEmbeddedStatusRequest& request) const;
QueryLlmCubeWithThemeListByUserIdOutcome queryLlmCubeWithThemeListByUserId(const Model::QueryLlmCubeWithThemeListByUserIdRequest &request)const;
void queryLlmCubeWithThemeListByUserIdAsync(const Model::QueryLlmCubeWithThemeListByUserIdRequest& request, const QueryLlmCubeWithThemeListByUserIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryLlmCubeWithThemeListByUserIdOutcomeCallable queryLlmCubeWithThemeListByUserIdCallable(const Model::QueryLlmCubeWithThemeListByUserIdRequest& request) const;
QueryOrganizationRoleConfigOutcome queryOrganizationRoleConfig(const Model::QueryOrganizationRoleConfigRequest &request)const;
void queryOrganizationRoleConfigAsync(const Model::QueryOrganizationRoleConfigRequest& request, const QueryOrganizationRoleConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryOrganizationRoleConfigOutcomeCallable queryOrganizationRoleConfigCallable(const Model::QueryOrganizationRoleConfigRequest& request) const;
@@ -791,6 +838,9 @@ namespace AlibabaCloud
QuerySharesToUserListOutcome querySharesToUserList(const Model::QuerySharesToUserListRequest &request)const;
void querySharesToUserListAsync(const Model::QuerySharesToUserListRequest& request, const QuerySharesToUserListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QuerySharesToUserListOutcomeCallable querySharesToUserListCallable(const Model::QuerySharesToUserListRequest& request) const;
QuerySmartqPermissionByCubeIdOutcome querySmartqPermissionByCubeId(const Model::QuerySmartqPermissionByCubeIdRequest &request)const;
void querySmartqPermissionByCubeIdAsync(const Model::QuerySmartqPermissionByCubeIdRequest& request, const QuerySmartqPermissionByCubeIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QuerySmartqPermissionByCubeIdOutcomeCallable querySmartqPermissionByCubeIdCallable(const Model::QuerySmartqPermissionByCubeIdRequest& request) const;
QueryTicketInfoOutcome queryTicketInfo(const Model::QueryTicketInfoRequest &request)const;
void queryTicketInfoAsync(const Model::QueryTicketInfoRequest& request, const QueryTicketInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryTicketInfoOutcomeCallable queryTicketInfoCallable(const Model::QueryTicketInfoRequest& request) const;
@@ -851,6 +901,12 @@ namespace AlibabaCloud
SetDataLevelPermissionWhiteListOutcome setDataLevelPermissionWhiteList(const Model::SetDataLevelPermissionWhiteListRequest &request)const;
void setDataLevelPermissionWhiteListAsync(const Model::SetDataLevelPermissionWhiteListRequest& request, const SetDataLevelPermissionWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetDataLevelPermissionWhiteListOutcomeCallable setDataLevelPermissionWhiteListCallable(const Model::SetDataLevelPermissionWhiteListRequest& request) const;
SmartqAuthTransferOutcome smartqAuthTransfer(const Model::SmartqAuthTransferRequest &request)const;
void smartqAuthTransferAsync(const Model::SmartqAuthTransferRequest& request, const SmartqAuthTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SmartqAuthTransferOutcomeCallable smartqAuthTransferCallable(const Model::SmartqAuthTransferRequest& request) const;
SmartqAuthorizeOutcome smartqAuthorize(const Model::SmartqAuthorizeRequest &request)const;
void smartqAuthorizeAsync(const Model::SmartqAuthorizeRequest& request, const SmartqAuthorizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SmartqAuthorizeOutcomeCallable smartqAuthorizeCallable(const Model::SmartqAuthorizeRequest& request) const;
SmartqQueryAbilityOutcome smartqQueryAbility(const Model::SmartqQueryAbilityRequest &request)const;
void smartqQueryAbilityAsync(const Model::SmartqQueryAbilityRequest& request, const SmartqQueryAbilityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SmartqQueryAbilityOutcomeCallable smartqQueryAbilityCallable(const Model::SmartqQueryAbilityRequest& request) const;

6
quickbi-public/include/alibabacloud/quickbi-public/model/CancelAuthorizationMenuRequest.h
View File

@@ -34,22 +34,22 @@ public:
void setDataPortalId(const std::string &dataPortalId);
std::string getAccessPoint() const;
void setAccessPoint(const std::string &accessPoint);
std::string getMenuIds() const;
void setMenuIds(const std::string &menuIds);
std::string getSignType() const;
void setSignType(const std::string &signType);
std::string getUserGroupIds() const;
void setUserGroupIds(const std::string &userGroupIds);
std::string getUserIds() const;
void setUserIds(const std::string &userIds);
std::string getMenuIds() const;
void setMenuIds(const std::string &menuIds);
private:
std::string dataPortalId_;
std::string accessPoint_;
std::string menuIds_;
std::string signType_;
std::string userGroupIds_;
std::string userIds_;
std::string menuIds_;
};
} // namespace Model
} // namespace Quickbi_public

48
quickbi-public/include/alibabacloud/quickbi-public/model/GetDataSourceConnectionInfoRequest.h Normal file
View File

@@ -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_GETDATASOURCECONNECTIONINFOREQUEST_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_GETDATASOURCECONNECTIONINFOREQUEST_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 GetDataSourceConnectionInfoRequest : public RpcServiceRequest {
public:
GetDataSourceConnectionInfoRequest();
~GetDataSourceConnectionInfoRequest();
std::string getDsId() const;
void setDsId(const std::string &dsId);
std::string getAccessPoint() const;
void setAccessPoint(const std::string &accessPoint);
std::string getSignType() const;
void setSignType(const std::string &signType);
private:
std::string dsId_;
std::string accessPoint_;
std::string signType_;
};
} // namespace Model
} // namespace Quickbi_public
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_GETDATASOURCECONNECTIONINFOREQUEST_H_

72
quickbi-public/include/alibabacloud/quickbi-public/model/GetDataSourceConnectionInfoResult.h Normal file
View File

@@ -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_GETDATASOURCECONNECTIONINFORESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_GETDATASOURCECONNECTIONINFORESULT_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 GetDataSourceConnectionInfoResult : public ServiceResult
{
public:
struct Result
{
std::string modifyUser;
std::string address;
std::string instance;
std::string instanceId;
std::string creatorId;
std::string port;
std::string schema;
std::string workspaceId;
std::string dsId;
std::string parentDsType;
std::string dsVersion;
std::string showName;
std::string authLevel;
std::string dsType;
std::string project;
bool noSasl;
};
GetDataSourceConnectionInfoResult();
explicit GetDataSourceConnectionInfoResult(const std::string &payload);
~GetDataSourceConnectionInfoResult();
bool getSuccess()const;
Result getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
Result result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_GETDATASOURCECONNECTIONINFORESULT_H_

51
quickbi-public/include/alibabacloud/quickbi-public/model/ListDataSourceRequest.h Normal file
View File

@@ -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_LISTDATASOURCEREQUEST_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTDATASOURCEREQUEST_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 ListDataSourceRequest : public RpcServiceRequest {
public:
ListDataSourceRequest();
~ListDataSourceRequest();
std::string getDsType() const;
void setDsType(const std::string &dsType);
std::string getAccessPoint() const;
void setAccessPoint(const std::string &accessPoint);
std::string getSignType() const;
void setSignType(const std::string &signType);
std::string getWorkspaceId() const;
void setWorkspaceId(const std::string &workspaceId);
private:
std::string dsType_;
std::string accessPoint_;
std::string signType_;
std::string workspaceId_;
};
} // namespace Model
} // namespace Quickbi_public
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTDATASOURCEREQUEST_H_

64
quickbi-public/include/alibabacloud/quickbi-public/model/ListDataSourceResult.h Normal file
View File

@@ -0,0 +1,64 @@
/*
* 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_LISTDATASOURCERESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTDATASOURCERESULT_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 ListDataSourceResult : public ServiceResult
{
public:
struct Data
{
std::string gmtCreate;
std::string datasourceId;
std::string creatorId;
std::string gmtModified;
std::string parentDsType;
std::string showName;
std::string creatorName;
std::string dsType;
};
ListDataSourceResult();
explicit ListDataSourceResult(const std::string &payload);
~ListDataSourceResult();
bool getSuccess()const;
std::vector<Data> getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
std::vector<Data> result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTDATASOURCERESULT_H_

1
quickbi-public/include/alibabacloud/quickbi-public/model/QueryAuditLogResult.h
View File

@@ -41,6 +41,7 @@ namespace AlibabaCloud
std::string workspaceId;
std::string targetName;
std::string operatorType;
std::string targetId;
};

48
quickbi-public/include/alibabacloud/quickbi-public/model/QueryDatasetSmartqStatusRequest.h Normal file
View File

@@ -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_QUERYDATASETSMARTQSTATUSREQUEST_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATASETSMARTQSTATUSREQUEST_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 QueryDatasetSmartqStatusRequest : public RpcServiceRequest {
public:
QueryDatasetSmartqStatusRequest();
~QueryDatasetSmartqStatusRequest();
std::string getAccessPoint() const;
void setAccessPoint(const std::string &accessPoint);
std::string getSignType() const;
void setSignType(const std::string &signType);
std::string getCubeId() const;
void setCubeId(const std::string &cubeId);
private:
std::string accessPoint_;
std::string signType_;
std::string cubeId_;
};
} // namespace Model
} // namespace Quickbi_public
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATASETSMARTQSTATUSREQUEST_H_

53
quickbi-public/include/alibabacloud/quickbi-public/model/QueryDatasetSmartqStatusResult.h Normal file
View File

@@ -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_QUERYDATASETSMARTQSTATUSRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATASETSMARTQSTATUSRESULT_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 QueryDatasetSmartqStatusResult : public ServiceResult
{
public:
QueryDatasetSmartqStatusResult();
explicit QueryDatasetSmartqStatusResult(const std::string &payload);
~QueryDatasetSmartqStatusResult();
bool getSuccess()const;
bool getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
bool result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATASETSMARTQSTATUSRESULT_H_

48
quickbi-public/include/alibabacloud/quickbi-public/model/QueryLlmCubeWithThemeListByUserIdRequest.h Normal file
View File

@@ -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_QUERYLLMCUBEWITHTHEMELISTBYUSERIDREQUEST_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYLLMCUBEWITHTHEMELISTBYUSERIDREQUEST_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 QueryLlmCubeWithThemeListByUserIdRequest : public RpcServiceRequest {
public:
QueryLlmCubeWithThemeListByUserIdRequest();
~QueryLlmCubeWithThemeListByUserIdRequest();
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 accessPoint_;
std::string signType_;
std::string userId_;
};
} // namespace Model
} // namespace Quickbi_public
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYLLMCUBEWITHTHEMELISTBYUSERIDREQUEST_H_

58
quickbi-public/include/alibabacloud/quickbi-public/model/QueryLlmCubeWithThemeListByUserIdResult.h Normal file
View File

@@ -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_QUERYLLMCUBEWITHTHEMELISTBYUSERIDRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYLLMCUBEWITHTHEMELISTBYUSERIDRESULT_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 QueryLlmCubeWithThemeListByUserIdResult : public ServiceResult
{
public:
struct Result
{
std::string themeIds;
std::string cubeIds;
};
QueryLlmCubeWithThemeListByUserIdResult();
explicit QueryLlmCubeWithThemeListByUserIdResult(const std::string &payload);
~QueryLlmCubeWithThemeListByUserIdResult();
bool getSuccess()const;
Result getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
Result result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYLLMCUBEWITHTHEMELISTBYUSERIDRESULT_H_

51
quickbi-public/include/alibabacloud/quickbi-public/model/QuerySmartqPermissionByCubeIdRequest.h Normal file
View File

@@ -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_QUERYSMARTQPERMISSIONBYCUBEIDREQUEST_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYSMARTQPERMISSIONBYCUBEIDREQUEST_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 QuerySmartqPermissionByCubeIdRequest : public RpcServiceRequest {
public:
QuerySmartqPermissionByCubeIdRequest();
~QuerySmartqPermissionByCubeIdRequest();
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);
std::string getCubeId() const;
void setCubeId(const std::string &cubeId);
private:
std::string accessPoint_;
std::string signType_;
std::string userId_;
std::string cubeId_;
};
} // namespace Model
} // namespace Quickbi_public
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYSMARTQPERMISSIONBYCUBEIDREQUEST_H_

59
quickbi-public/include/alibabacloud/quickbi-public/model/QuerySmartqPermissionByCubeIdResult.h Normal file
View File

@@ -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.
*/
#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYSMARTQPERMISSIONBYCUBEIDRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYSMARTQPERMISSIONBYCUBEIDRESULT_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 QuerySmartqPermissionByCubeIdResult : public ServiceResult
{
public:
struct Result
{
std::string cubeId;
std::string cubeName;
bool hasPerssion;
};
QuerySmartqPermissionByCubeIdResult();
explicit QuerySmartqPermissionByCubeIdResult(const std::string &payload);
~QuerySmartqPermissionByCubeIdResult();
bool getSuccess()const;
Result getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
Result result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYSMARTQPERMISSIONBYCUBEIDRESULT_H_

2
quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksBloodRelationshipResult.h
View File

@@ -40,6 +40,7 @@ namespace AlibabaCloud
std::string pathId;
std::string uid;
bool isMeasure;
std::string expression;
std::string areaId;
std::string dataType;
std::string caption;
@@ -48,6 +49,7 @@ namespace AlibabaCloud
std::string componentTypeName;
std::vector<Item::QueryParam> queryParams;
std::string componentName;
std::string componentTypeCnName;
std::string componentId;
std::string datasetId;
};

51
quickbi-public/include/alibabacloud/quickbi-public/model/SmartqAuthTransferRequest.h Normal file
View File

@@ -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_SMARTQAUTHTRANSFERREQUEST_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_SMARTQAUTHTRANSFERREQUEST_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 SmartqAuthTransferRequest : public RpcServiceRequest {
public:
SmartqAuthTransferRequest();
~SmartqAuthTransferRequest();
std::string getAccessPoint() const;
void setAccessPoint(const std::string &accessPoint);
std::string getTargetUserIds() const;
void setTargetUserIds(const std::string &targetUserIds);
std::string getSignType() const;
void setSignType(const std::string &signType);
std::string getOriginUserId() const;
void setOriginUserId(const std::string &originUserId);
private:
std::string accessPoint_;
std::string targetUserIds_;
std::string signType_;
std::string originUserId_;
};
} // namespace Model
} // namespace Quickbi_public
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_SMARTQAUTHTRANSFERREQUEST_H_

53
quickbi-public/include/alibabacloud/quickbi-public/model/SmartqAuthTransferResult.h Normal file
View File

@@ -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_SMARTQAUTHTRANSFERRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_SMARTQAUTHTRANSFERRESULT_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 SmartqAuthTransferResult : public ServiceResult
{
public:
SmartqAuthTransferResult();
explicit SmartqAuthTransferResult(const std::string &payload);
~SmartqAuthTransferResult();
bool getSuccess()const;
bool getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
bool result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_SMARTQAUTHTRANSFERRESULT_H_

60
quickbi-public/include/alibabacloud/quickbi-public/model/SmartqAuthorizeRequest.h Normal file
View File

@@ -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_SMARTQAUTHORIZEREQUEST_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_SMARTQAUTHORIZEREQUEST_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 SmartqAuthorizeRequest : public RpcServiceRequest {
public:
SmartqAuthorizeRequest();
~SmartqAuthorizeRequest();
std::string getLlmCubeThemes() const;
void setLlmCubeThemes(const std::string &llmCubeThemes);
std::string getAccessPoint() const;
void setAccessPoint(const std::string &accessPoint);
std::string getLlmCubes() const;
void setLlmCubes(const std::string &llmCubes);
std::string getSignType() const;
void setSignType(const std::string &signType);
int getOperationType() const;
void setOperationType(int operationType);
std::string getExpireDay() const;
void setExpireDay(const std::string &expireDay);
std::string getUserIds() const;
void setUserIds(const std::string &userIds);
private:
std::string llmCubeThemes_;
std::string accessPoint_;
std::string llmCubes_;
std::string signType_;
int operationType_;
std::string expireDay_;
std::string userIds_;
};
} // namespace Model
} // namespace Quickbi_public
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_SMARTQAUTHORIZEREQUEST_H_

60
quickbi-public/include/alibabacloud/quickbi-public/model/SmartqAuthorizeResult.h Normal file
View File

@@ -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_SMARTQAUTHORIZERESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_SMARTQAUTHORIZERESULT_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 SmartqAuthorizeResult : public ServiceResult
{
public:
struct Data
{
std::string userId;
std::string llmCube;
std::string detailMessage;
std::string llmCubeTheme;
};
SmartqAuthorizeResult();
explicit SmartqAuthorizeResult(const std::string &payload);
~SmartqAuthorizeResult();
bool getSuccess()const;
std::vector<Data> getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
std::vector<Data> result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_SMARTQAUTHORIZERESULT_H_

9
quickbi-public/include/alibabacloud/quickbi-public/model/UpdateWorkspaceUserRoleRequest.h
View File

@@ -34,18 +34,21 @@ public:
void setRoleId(long roleId);
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);
std::string getRoleIds() const;
void setRoleIds(const std::string &roleIds);
std::string getSignType() const;
void setSignType(const std::string &signType);
std::string getWorkspaceId() const;
void setWorkspaceId(const std::string &workspaceId);
private:
long roleId_;
std::string accessPoint_;
std::string signType_;
std::string userId_;
std::string roleIds_;
std::string signType_;
std::string workspaceId_;
};
} // namespace Model

252
quickbi-public/src/Quickbi-publicClient.cc
View File

@@ -1203,6 +1203,42 @@ Quickbi_publicClient::DeleteUserTagMetaOutcomeCallable Quickbi_publicClient::del
return task->get_future();
}
Quickbi_publicClient::GetDataSourceConnectionInfoOutcome Quickbi_publicClient::getDataSourceConnectionInfo(const GetDataSourceConnectionInfoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetDataSourceConnectionInfoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetDataSourceConnectionInfoOutcome(GetDataSourceConnectionInfoResult(outcome.result()));
else
return GetDataSourceConnectionInfoOutcome(outcome.error());
}
void Quickbi_publicClient::getDataSourceConnectionInfoAsync(const GetDataSourceConnectionInfoRequest& request, const GetDataSourceConnectionInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getDataSourceConnectionInfo(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::GetDataSourceConnectionInfoOutcomeCallable Quickbi_publicClient::getDataSourceConnectionInfoCallable(const GetDataSourceConnectionInfoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetDataSourceConnectionInfoOutcome()>>(
[this, request]()
{
return this->getDataSourceConnectionInfo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::GetMailTaskStatusOutcome Quickbi_publicClient::getMailTaskStatus(const GetMailTaskStatusRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1491,6 +1527,42 @@ Quickbi_publicClient::ListDataLevelPermissionWhiteListOutcomeCallable Quickbi_pu
return task->get_future();
}
Quickbi_publicClient::ListDataSourceOutcome Quickbi_publicClient::listDataSource(const ListDataSourceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListDataSourceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListDataSourceOutcome(ListDataSourceResult(outcome.result()));
else
return ListDataSourceOutcome(outcome.error());
}
void Quickbi_publicClient::listDataSourceAsync(const ListDataSourceRequest& request, const ListDataSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listDataSource(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::ListDataSourceOutcomeCallable Quickbi_publicClient::listDataSourceCallable(const ListDataSourceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListDataSourceOutcome()>>(
[this, request]()
{
return this->listDataSource(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::ListFavoriteReportsOutcome Quickbi_publicClient::listFavoriteReports(const ListFavoriteReportsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2427,6 +2499,42 @@ Quickbi_publicClient::QueryDatasetListOutcomeCallable Quickbi_publicClient::quer
return task->get_future();
}
Quickbi_publicClient::QueryDatasetSmartqStatusOutcome Quickbi_publicClient::queryDatasetSmartqStatus(const QueryDatasetSmartqStatusRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QueryDatasetSmartqStatusOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QueryDatasetSmartqStatusOutcome(QueryDatasetSmartqStatusResult(outcome.result()));
else
return QueryDatasetSmartqStatusOutcome(outcome.error());
}
void Quickbi_publicClient::queryDatasetSmartqStatusAsync(const QueryDatasetSmartqStatusRequest& request, const QueryDatasetSmartqStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, queryDatasetSmartqStatus(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::QueryDatasetSmartqStatusOutcomeCallable Quickbi_publicClient::queryDatasetSmartqStatusCallable(const QueryDatasetSmartqStatusRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QueryDatasetSmartqStatusOutcome()>>(
[this, request]()
{
return this->queryDatasetSmartqStatus(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::QueryDatasetSwitchInfoOutcome Quickbi_publicClient::queryDatasetSwitchInfo(const QueryDatasetSwitchInfoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2535,6 +2643,42 @@ Quickbi_publicClient::QueryEmbeddedStatusOutcomeCallable Quickbi_publicClient::q
return task->get_future();
}
Quickbi_publicClient::QueryLlmCubeWithThemeListByUserIdOutcome Quickbi_publicClient::queryLlmCubeWithThemeListByUserId(const QueryLlmCubeWithThemeListByUserIdRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QueryLlmCubeWithThemeListByUserIdOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QueryLlmCubeWithThemeListByUserIdOutcome(QueryLlmCubeWithThemeListByUserIdResult(outcome.result()));
else
return QueryLlmCubeWithThemeListByUserIdOutcome(outcome.error());
}
void Quickbi_publicClient::queryLlmCubeWithThemeListByUserIdAsync(const QueryLlmCubeWithThemeListByUserIdRequest& request, const QueryLlmCubeWithThemeListByUserIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, queryLlmCubeWithThemeListByUserId(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::QueryLlmCubeWithThemeListByUserIdOutcomeCallable Quickbi_publicClient::queryLlmCubeWithThemeListByUserIdCallable(const QueryLlmCubeWithThemeListByUserIdRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QueryLlmCubeWithThemeListByUserIdOutcome()>>(
[this, request]()
{
return this->queryLlmCubeWithThemeListByUserId(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::QueryOrganizationRoleConfigOutcome Quickbi_publicClient::queryOrganizationRoleConfig(const QueryOrganizationRoleConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2751,6 +2895,42 @@ Quickbi_publicClient::QuerySharesToUserListOutcomeCallable Quickbi_publicClient:
return task->get_future();
}
Quickbi_publicClient::QuerySmartqPermissionByCubeIdOutcome Quickbi_publicClient::querySmartqPermissionByCubeId(const QuerySmartqPermissionByCubeIdRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QuerySmartqPermissionByCubeIdOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QuerySmartqPermissionByCubeIdOutcome(QuerySmartqPermissionByCubeIdResult(outcome.result()));
else
return QuerySmartqPermissionByCubeIdOutcome(outcome.error());
}
void Quickbi_publicClient::querySmartqPermissionByCubeIdAsync(const QuerySmartqPermissionByCubeIdRequest& request, const QuerySmartqPermissionByCubeIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, querySmartqPermissionByCubeId(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::QuerySmartqPermissionByCubeIdOutcomeCallable Quickbi_publicClient::querySmartqPermissionByCubeIdCallable(const QuerySmartqPermissionByCubeIdRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QuerySmartqPermissionByCubeIdOutcome()>>(
[this, request]()
{
return this->querySmartqPermissionByCubeId(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::QueryTicketInfoOutcome Quickbi_publicClient::queryTicketInfo(const QueryTicketInfoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3471,6 +3651,78 @@ Quickbi_publicClient::SetDataLevelPermissionWhiteListOutcomeCallable Quickbi_pub
return task->get_future();
}
Quickbi_publicClient::SmartqAuthTransferOutcome Quickbi_publicClient::smartqAuthTransfer(const SmartqAuthTransferRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SmartqAuthTransferOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SmartqAuthTransferOutcome(SmartqAuthTransferResult(outcome.result()));
else
return SmartqAuthTransferOutcome(outcome.error());
}
void Quickbi_publicClient::smartqAuthTransferAsync(const SmartqAuthTransferRequest& request, const SmartqAuthTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, smartqAuthTransfer(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::SmartqAuthTransferOutcomeCallable Quickbi_publicClient::smartqAuthTransferCallable(const SmartqAuthTransferRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SmartqAuthTransferOutcome()>>(
[this, request]()
{
return this->smartqAuthTransfer(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::SmartqAuthorizeOutcome Quickbi_publicClient::smartqAuthorize(const SmartqAuthorizeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SmartqAuthorizeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SmartqAuthorizeOutcome(SmartqAuthorizeResult(outcome.result()));
else
return SmartqAuthorizeOutcome(outcome.error());
}
void Quickbi_publicClient::smartqAuthorizeAsync(const SmartqAuthorizeRequest& request, const SmartqAuthorizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, smartqAuthorize(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::SmartqAuthorizeOutcomeCallable Quickbi_publicClient::smartqAuthorizeCallable(const SmartqAuthorizeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SmartqAuthorizeOutcome()>>(
[this, request]()
{
return this->smartqAuthorize(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::SmartqQueryAbilityOutcome Quickbi_publicClient::smartqQueryAbility(const SmartqQueryAbilityRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

18
quickbi-public/src/model/CancelAuthorizationMenuRequest.cc
View File

@@ -43,6 +43,15 @@ void CancelAuthorizationMenuRequest::setAccessPoint(const std::string &accessPoi
setParameter(std::string("AccessPoint"), accessPoint);
}
std::string CancelAuthorizationMenuRequest::getMenuIds() const {
return menuIds_;
}
void CancelAuthorizationMenuRequest::setMenuIds(const std::string &menuIds) {
menuIds_ = menuIds;
setParameter(std::string("MenuIds"), menuIds);
}
std::string CancelAuthorizationMenuRequest::getSignType() const {
return signType_;
}
@@ -70,12 +79,3 @@ void CancelAuthorizationMenuRequest::setUserIds(const std::string &userIds) {
setParameter(std::string("UserIds"), userIds);
}
std::string CancelAuthorizationMenuRequest::getMenuIds() const {
return menuIds_;
}
void CancelAuthorizationMenuRequest::setMenuIds(const std::string &menuIds) {
menuIds_ = menuIds;
setParameter(std::string("MenuIds"), menuIds);
}

54
quickbi-public/src/model/GetDataSourceConnectionInfoRequest.cc Normal file
View File

@@ -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/GetDataSourceConnectionInfoRequest.h>
using AlibabaCloud::Quickbi_public::Model::GetDataSourceConnectionInfoRequest;
GetDataSourceConnectionInfoRequest::GetDataSourceConnectionInfoRequest()
: RpcServiceRequest("quickbi-public", "2022-01-01", "GetDataSourceConnectionInfo") {
setMethod(HttpRequest::Method::Post);
}
GetDataSourceConnectionInfoRequest::~GetDataSourceConnectionInfoRequest() {}
std::string GetDataSourceConnectionInfoRequest::getDsId() const {
return dsId_;
}
void GetDataSourceConnectionInfoRequest::setDsId(const std::string &dsId) {
dsId_ = dsId;
setParameter(std::string("DsId"), dsId);
}
std::string GetDataSourceConnectionInfoRequest::getAccessPoint() const {
return accessPoint_;
}
void GetDataSourceConnectionInfoRequest::setAccessPoint(const std::string &accessPoint) {
accessPoint_ = accessPoint;
setParameter(std::string("AccessPoint"), accessPoint);
}
std::string GetDataSourceConnectionInfoRequest::getSignType() const {
return signType_;
}
void GetDataSourceConnectionInfoRequest::setSignType(const std::string &signType) {
signType_ = signType;
setParameter(std::string("SignType"), signType);
}

89
quickbi-public/src/model/GetDataSourceConnectionInfoResult.cc Normal file
View File

@@ -0,0 +1,89 @@
/*
* 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/GetDataSourceConnectionInfoResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
GetDataSourceConnectionInfoResult::GetDataSourceConnectionInfoResult() :
ServiceResult()
{}
GetDataSourceConnectionInfoResult::GetDataSourceConnectionInfoResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetDataSourceConnectionInfoResult::~GetDataSourceConnectionInfoResult()
{}
void GetDataSourceConnectionInfoResult::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["Address"].isNull())
result_.address = resultNode["Address"].asString();
if(!resultNode["AuthLevel"].isNull())
result_.authLevel = resultNode["AuthLevel"].asString();
if(!resultNode["CreatorId"].isNull())
result_.creatorId = resultNode["CreatorId"].asString();
if(!resultNode["DsId"].isNull())
result_.dsId = resultNode["DsId"].asString();
if(!resultNode["DsType"].isNull())
result_.dsType = resultNode["DsType"].asString();
if(!resultNode["DsVersion"].isNull())
result_.dsVersion = resultNode["DsVersion"].asString();
if(!resultNode["Instance"].isNull())
result_.instance = resultNode["Instance"].asString();
if(!resultNode["InstanceId"].isNull())
result_.instanceId = resultNode["InstanceId"].asString();
if(!resultNode["ModifyUser"].isNull())
result_.modifyUser = resultNode["ModifyUser"].asString();
if(!resultNode["NoSasl"].isNull())
result_.noSasl = resultNode["NoSasl"].asString() == "true";
if(!resultNode["ParentDsType"].isNull())
result_.parentDsType = resultNode["ParentDsType"].asString();
if(!resultNode["Port"].isNull())
result_.port = resultNode["Port"].asString();
if(!resultNode["Project"].isNull())
result_.project = resultNode["Project"].asString();
if(!resultNode["Schema"].isNull())
result_.schema = resultNode["Schema"].asString();
if(!resultNode["ShowName"].isNull())
result_.showName = resultNode["ShowName"].asString();
if(!resultNode["WorkspaceId"].isNull())
result_.workspaceId = resultNode["WorkspaceId"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool GetDataSourceConnectionInfoResult::getSuccess()const
{
return success_;
}
GetDataSourceConnectionInfoResult::Result GetDataSourceConnectionInfoResult::getResult()const
{
return result_;
}

63
quickbi-public/src/model/ListDataSourceRequest.cc Normal file
View File

@@ -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 <alibabacloud/quickbi-public/model/ListDataSourceRequest.h>
using AlibabaCloud::Quickbi_public::Model::ListDataSourceRequest;
ListDataSourceRequest::ListDataSourceRequest()
: RpcServiceRequest("quickbi-public", "2022-01-01", "ListDataSource") {
setMethod(HttpRequest::Method::Post);
}
ListDataSourceRequest::~ListDataSourceRequest() {}
std::string ListDataSourceRequest::getDsType() const {
return dsType_;
}
void ListDataSourceRequest::setDsType(const std::string &dsType) {
dsType_ = dsType;
setParameter(std::string("DsType"), dsType);
}
std::string ListDataSourceRequest::getAccessPoint() const {
return accessPoint_;
}
void ListDataSourceRequest::setAccessPoint(const std::string &accessPoint) {
accessPoint_ = accessPoint;
setParameter(std::string("AccessPoint"), accessPoint);
}
std::string ListDataSourceRequest::getSignType() const {
return signType_;
}
void ListDataSourceRequest::setSignType(const std::string &signType) {
signType_ = signType;
setParameter(std::string("SignType"), signType);
}
std::string ListDataSourceRequest::getWorkspaceId() const {
return workspaceId_;
}
void ListDataSourceRequest::setWorkspaceId(const std::string &workspaceId) {
workspaceId_ = workspaceId;
setParameter(std::string("WorkspaceId"), workspaceId);
}

78
quickbi-public/src/model/ListDataSourceResult.cc Normal file
View File

@@ -0,0 +1,78 @@
/*
* 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/ListDataSourceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
ListDataSourceResult::ListDataSourceResult() :
ServiceResult()
{}
ListDataSourceResult::ListDataSourceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListDataSourceResult::~ListDataSourceResult()
{}
void ListDataSourceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allResultNode = value["Result"]["Data"];
for (auto valueResultData : allResultNode)
{
Data resultObject;
if(!valueResultData["CreatorId"].isNull())
resultObject.creatorId = valueResultData["CreatorId"].asString();
if(!valueResultData["CreatorName"].isNull())
resultObject.creatorName = valueResultData["CreatorName"].asString();
if(!valueResultData["DatasourceId"].isNull())
resultObject.datasourceId = valueResultData["DatasourceId"].asString();
if(!valueResultData["GmtCreate"].isNull())
resultObject.gmtCreate = valueResultData["GmtCreate"].asString();
if(!valueResultData["GmtModified"].isNull())
resultObject.gmtModified = valueResultData["GmtModified"].asString();
if(!valueResultData["ShowName"].isNull())
resultObject.showName = valueResultData["ShowName"].asString();
if(!valueResultData["DsType"].isNull())
resultObject.dsType = valueResultData["DsType"].asString();
if(!valueResultData["ParentDsType"].isNull())
resultObject.parentDsType = valueResultData["ParentDsType"].asString();
result_.push_back(resultObject);
}
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool ListDataSourceResult::getSuccess()const
{
return success_;
}
std::vector<ListDataSourceResult::Data> ListDataSourceResult::getResult()const
{
return result_;
}

2
quickbi-public/src/model/QueryAuditLogResult.cc
View File

@@ -57,6 +57,8 @@ void QueryAuditLogResult::parse(const std::string &payload)
resultObject.targetType = valueResultLogApiResultModel["TargetType"].asString();
if(!valueResultLogApiResultModel["WorkspaceId"].isNull())
resultObject.workspaceId = valueResultLogApiResultModel["WorkspaceId"].asString();
if(!valueResultLogApiResultModel["TargetId"].isNull())
resultObject.targetId = valueResultLogApiResultModel["TargetId"].asString();
result_.push_back(resultObject);
}
if(!value["Success"].isNull())

54
quickbi-public/src/model/QueryDatasetSmartqStatusRequest.cc Normal file
View File

@@ -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/QueryDatasetSmartqStatusRequest.h>
using AlibabaCloud::Quickbi_public::Model::QueryDatasetSmartqStatusRequest;
QueryDatasetSmartqStatusRequest::QueryDatasetSmartqStatusRequest()
: RpcServiceRequest("quickbi-public", "2022-01-01", "QueryDatasetSmartqStatus") {
setMethod(HttpRequest::Method::Post);
}
QueryDatasetSmartqStatusRequest::~QueryDatasetSmartqStatusRequest() {}
std::string QueryDatasetSmartqStatusRequest::getAccessPoint() const {
return accessPoint_;
}
void QueryDatasetSmartqStatusRequest::setAccessPoint(const std::string &accessPoint) {
accessPoint_ = accessPoint;
setParameter(std::string("AccessPoint"), accessPoint);
}
std::string QueryDatasetSmartqStatusRequest::getSignType() const {
return signType_;
}
void QueryDatasetSmartqStatusRequest::setSignType(const std::string &signType) {
signType_ = signType;
setParameter(std::string("SignType"), signType);
}
std::string QueryDatasetSmartqStatusRequest::getCubeId() const {
return cubeId_;
}
void QueryDatasetSmartqStatusRequest::setCubeId(const std::string &cubeId) {
cubeId_ = cubeId;
setParameter(std::string("CubeId"), cubeId);
}

58
quickbi-public/src/model/QueryDatasetSmartqStatusResult.cc Normal file
View File

@@ -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 <alibabacloud/quickbi-public/model/QueryDatasetSmartqStatusResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
QueryDatasetSmartqStatusResult::QueryDatasetSmartqStatusResult() :
ServiceResult()
{}
QueryDatasetSmartqStatusResult::QueryDatasetSmartqStatusResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
QueryDatasetSmartqStatusResult::~QueryDatasetSmartqStatusResult()
{}
void QueryDatasetSmartqStatusResult::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() == "true";
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool QueryDatasetSmartqStatusResult::getSuccess()const
{
return success_;
}
bool QueryDatasetSmartqStatusResult::getResult()const
{
return result_;
}

54
quickbi-public/src/model/QueryLlmCubeWithThemeListByUserIdRequest.cc Normal file
View File

@@ -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/QueryLlmCubeWithThemeListByUserIdRequest.h>
using AlibabaCloud::Quickbi_public::Model::QueryLlmCubeWithThemeListByUserIdRequest;
QueryLlmCubeWithThemeListByUserIdRequest::QueryLlmCubeWithThemeListByUserIdRequest()
: RpcServiceRequest("quickbi-public", "2022-01-01", "QueryLlmCubeWithThemeListByUserId") {
setMethod(HttpRequest::Method::Post);
}
QueryLlmCubeWithThemeListByUserIdRequest::~QueryLlmCubeWithThemeListByUserIdRequest() {}
std::string QueryLlmCubeWithThemeListByUserIdRequest::getAccessPoint() const {
return accessPoint_;
}
void QueryLlmCubeWithThemeListByUserIdRequest::setAccessPoint(const std::string &accessPoint) {
accessPoint_ = accessPoint;
setParameter(std::string("AccessPoint"), accessPoint);
}
std::string QueryLlmCubeWithThemeListByUserIdRequest::getSignType() const {
return signType_;
}
void QueryLlmCubeWithThemeListByUserIdRequest::setSignType(const std::string &signType) {
signType_ = signType;
setParameter(std::string("SignType"), signType);
}
std::string QueryLlmCubeWithThemeListByUserIdRequest::getUserId() const {
return userId_;
}
void QueryLlmCubeWithThemeListByUserIdRequest::setUserId(const std::string &userId) {
userId_ = userId;
setParameter(std::string("UserId"), userId);
}

61
quickbi-public/src/model/QueryLlmCubeWithThemeListByUserIdResult.cc Normal file
View File

@@ -0,0 +1,61 @@
/*
* 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/QueryLlmCubeWithThemeListByUserIdResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
QueryLlmCubeWithThemeListByUserIdResult::QueryLlmCubeWithThemeListByUserIdResult() :
ServiceResult()
{}
QueryLlmCubeWithThemeListByUserIdResult::QueryLlmCubeWithThemeListByUserIdResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
QueryLlmCubeWithThemeListByUserIdResult::~QueryLlmCubeWithThemeListByUserIdResult()
{}
void QueryLlmCubeWithThemeListByUserIdResult::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["CubeIds"].isNull())
result_.cubeIds = resultNode["CubeIds"].asString();
if(!resultNode["ThemeIds"].isNull())
result_.themeIds = resultNode["ThemeIds"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool QueryLlmCubeWithThemeListByUserIdResult::getSuccess()const
{
return success_;
}
QueryLlmCubeWithThemeListByUserIdResult::Result QueryLlmCubeWithThemeListByUserIdResult::getResult()const
{
return result_;
}

63
quickbi-public/src/model/QuerySmartqPermissionByCubeIdRequest.cc Normal file
View File

@@ -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 <alibabacloud/quickbi-public/model/QuerySmartqPermissionByCubeIdRequest.h>
using AlibabaCloud::Quickbi_public::Model::QuerySmartqPermissionByCubeIdRequest;
QuerySmartqPermissionByCubeIdRequest::QuerySmartqPermissionByCubeIdRequest()
: RpcServiceRequest("quickbi-public", "2022-01-01", "QuerySmartqPermissionByCubeId") {
setMethod(HttpRequest::Method::Post);
}
QuerySmartqPermissionByCubeIdRequest::~QuerySmartqPermissionByCubeIdRequest() {}
std::string QuerySmartqPermissionByCubeIdRequest::getAccessPoint() const {
return accessPoint_;
}
void QuerySmartqPermissionByCubeIdRequest::setAccessPoint(const std::string &accessPoint) {
accessPoint_ = accessPoint;
setParameter(std::string("AccessPoint"), accessPoint);
}
std::string QuerySmartqPermissionByCubeIdRequest::getSignType() const {
return signType_;
}
void QuerySmartqPermissionByCubeIdRequest::setSignType(const std::string &signType) {
signType_ = signType;
setParameter(std::string("SignType"), signType);
}
std::string QuerySmartqPermissionByCubeIdRequest::getUserId() const {
return userId_;
}
void QuerySmartqPermissionByCubeIdRequest::setUserId(const std::string &userId) {
userId_ = userId;
setParameter(std::string("UserId"), userId);
}
std::string QuerySmartqPermissionByCubeIdRequest::getCubeId() const {
return cubeId_;
}
void QuerySmartqPermissionByCubeIdRequest::setCubeId(const std::string &cubeId) {
cubeId_ = cubeId;
setParameter(std::string("CubeId"), cubeId);
}

63
quickbi-public/src/model/QuerySmartqPermissionByCubeIdResult.cc Normal file
View File

@@ -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 <alibabacloud/quickbi-public/model/QuerySmartqPermissionByCubeIdResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
QuerySmartqPermissionByCubeIdResult::QuerySmartqPermissionByCubeIdResult() :
ServiceResult()
{}
QuerySmartqPermissionByCubeIdResult::QuerySmartqPermissionByCubeIdResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
QuerySmartqPermissionByCubeIdResult::~QuerySmartqPermissionByCubeIdResult()
{}
void QuerySmartqPermissionByCubeIdResult::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["HasPerssion"].isNull())
result_.hasPerssion = resultNode["HasPerssion"].asString() == "true";
if(!resultNode["CubeId"].isNull())
result_.cubeId = resultNode["CubeId"].asString();
if(!resultNode["CubeName"].isNull())
result_.cubeName = resultNode["CubeName"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool QuerySmartqPermissionByCubeIdResult::getSuccess()const
{
return success_;
}
QuerySmartqPermissionByCubeIdResult::Result QuerySmartqPermissionByCubeIdResult::getResult()const
{
return result_;
}

4
quickbi-public/src/model/QueryWorksBloodRelationshipResult.cc
View File

@@ -51,6 +51,8 @@ void QueryWorksBloodRelationshipResult::parse(const std::string &payload)
resultObject.componentType = std::stoi(valueResultItem["ComponentType"].asString());
if(!valueResultItem["ComponentTypeName"].isNull())
resultObject.componentTypeName = valueResultItem["ComponentTypeName"].asString();
if(!valueResultItem["ComponentTypeCnName"].isNull())
resultObject.componentTypeCnName = valueResultItem["ComponentTypeCnName"].asString();
if(!valueResultItem["DatasetId"].isNull())
resultObject.datasetId = valueResultItem["DatasetId"].asString();
auto allQueryParamsNode = valueResultItem["QueryParams"]["QueryParam"];
@@ -71,6 +73,8 @@ void QueryWorksBloodRelationshipResult::parse(const std::string &payload)
queryParamsObject.pathId = valueResultItemQueryParamsQueryParam["PathId"].asString();
if(!valueResultItemQueryParamsQueryParam["Uid"].isNull())
queryParamsObject.uid = valueResultItemQueryParamsQueryParam["Uid"].asString();
if(!valueResultItemQueryParamsQueryParam["Expression"].isNull())
queryParamsObject.expression = valueResultItemQueryParamsQueryParam["Expression"].asString();
resultObject.queryParams.push_back(queryParamsObject);
}
result_.push_back(resultObject);

63
quickbi-public/src/model/SmartqAuthTransferRequest.cc Normal file
View File

@@ -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 <alibabacloud/quickbi-public/model/SmartqAuthTransferRequest.h>
using AlibabaCloud::Quickbi_public::Model::SmartqAuthTransferRequest;
SmartqAuthTransferRequest::SmartqAuthTransferRequest()
: RpcServiceRequest("quickbi-public", "2022-01-01", "SmartqAuthTransfer") {
setMethod(HttpRequest::Method::Post);
}
SmartqAuthTransferRequest::~SmartqAuthTransferRequest() {}
std::string SmartqAuthTransferRequest::getAccessPoint() const {
return accessPoint_;
}
void SmartqAuthTransferRequest::setAccessPoint(const std::string &accessPoint) {
accessPoint_ = accessPoint;
setParameter(std::string("AccessPoint"), accessPoint);
}
std::string SmartqAuthTransferRequest::getTargetUserIds() const {
return targetUserIds_;
}
void SmartqAuthTransferRequest::setTargetUserIds(const std::string &targetUserIds) {
targetUserIds_ = targetUserIds;
setParameter(std::string("TargetUserIds"), targetUserIds);
}
std::string SmartqAuthTransferRequest::getSignType() const {
return signType_;
}
void SmartqAuthTransferRequest::setSignType(const std::string &signType) {
signType_ = signType;
setParameter(std::string("SignType"), signType);
}
std::string SmartqAuthTransferRequest::getOriginUserId() const {
return originUserId_;
}
void SmartqAuthTransferRequest::setOriginUserId(const std::string &originUserId) {
originUserId_ = originUserId;
setParameter(std::string("OriginUserId"), originUserId);
}

58
quickbi-public/src/model/SmartqAuthTransferResult.cc Normal file
View File

@@ -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 <alibabacloud/quickbi-public/model/SmartqAuthTransferResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
SmartqAuthTransferResult::SmartqAuthTransferResult() :
ServiceResult()
{}
SmartqAuthTransferResult::SmartqAuthTransferResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SmartqAuthTransferResult::~SmartqAuthTransferResult()
{}
void SmartqAuthTransferResult::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() == "true";
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool SmartqAuthTransferResult::getSuccess()const
{
return success_;
}
bool SmartqAuthTransferResult::getResult()const
{
return result_;
}

90
quickbi-public/src/model/SmartqAuthorizeRequest.cc Normal file
View File

@@ -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 <alibabacloud/quickbi-public/model/SmartqAuthorizeRequest.h>
using AlibabaCloud::Quickbi_public::Model::SmartqAuthorizeRequest;
SmartqAuthorizeRequest::SmartqAuthorizeRequest()
: RpcServiceRequest("quickbi-public", "2022-01-01", "SmartqAuthorize") {
setMethod(HttpRequest::Method::Post);
}
SmartqAuthorizeRequest::~SmartqAuthorizeRequest() {}
std::string SmartqAuthorizeRequest::getLlmCubeThemes() const {
return llmCubeThemes_;
}
void SmartqAuthorizeRequest::setLlmCubeThemes(const std::string &llmCubeThemes) {
llmCubeThemes_ = llmCubeThemes;
setParameter(std::string("LlmCubeThemes"), llmCubeThemes);
}
std::string SmartqAuthorizeRequest::getAccessPoint() const {
return accessPoint_;
}
void SmartqAuthorizeRequest::setAccessPoint(const std::string &accessPoint) {
accessPoint_ = accessPoint;
setParameter(std::string("AccessPoint"), accessPoint);
}
std::string SmartqAuthorizeRequest::getLlmCubes() const {
return llmCubes_;
}
void SmartqAuthorizeRequest::setLlmCubes(const std::string &llmCubes) {
llmCubes_ = llmCubes;
setParameter(std::string("LlmCubes"), llmCubes);
}
std::string SmartqAuthorizeRequest::getSignType() const {
return signType_;
}
void SmartqAuthorizeRequest::setSignType(const std::string &signType) {
signType_ = signType;
setParameter(std::string("SignType"), signType);
}
int SmartqAuthorizeRequest::getOperationType() const {
return operationType_;
}
void SmartqAuthorizeRequest::setOperationType(int operationType) {
operationType_ = operationType;
setParameter(std::string("OperationType"), std::to_string(operationType));
}
std::string SmartqAuthorizeRequest::getExpireDay() const {
return expireDay_;
}
void SmartqAuthorizeRequest::setExpireDay(const std::string &expireDay) {
expireDay_ = expireDay;
setParameter(std::string("ExpireDay"), expireDay);
}
std::string SmartqAuthorizeRequest::getUserIds() const {
return userIds_;
}
void SmartqAuthorizeRequest::setUserIds(const std::string &userIds) {
userIds_ = userIds;
setParameter(std::string("UserIds"), userIds);
}

70
quickbi-public/src/model/SmartqAuthorizeResult.cc Normal file
View File

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

27
quickbi-public/src/model/UpdateWorkspaceUserRoleRequest.cc
View File

@@ -43,15 +43,6 @@ void UpdateWorkspaceUserRoleRequest::setAccessPoint(const std::string &accessPoi
setParameter(std::string("AccessPoint"), accessPoint);
}
std::string UpdateWorkspaceUserRoleRequest::getSignType() const {
return signType_;
}
void UpdateWorkspaceUserRoleRequest::setSignType(const std::string &signType) {
signType_ = signType;
setParameter(std::string("SignType"), signType);
}
std::string UpdateWorkspaceUserRoleRequest::getUserId() const {
return userId_;
}
@@ -61,6 +52,24 @@ void UpdateWorkspaceUserRoleRequest::setUserId(const std::string &userId) {
setParameter(std::string("UserId"), userId);
}
std::string UpdateWorkspaceUserRoleRequest::getRoleIds() const {
return roleIds_;
}
void UpdateWorkspaceUserRoleRequest::setRoleIds(const std::string &roleIds) {
roleIds_ = roleIds;
setParameter(std::string("RoleIds"), roleIds);
}
std::string UpdateWorkspaceUserRoleRequest::getSignType() const {
return signType_;
}
void UpdateWorkspaceUserRoleRequest::setSignType(const std::string &signType) {
signType_ = signType;
setParameter(std::string("SignType"), signType);
}
std::string UpdateWorkspaceUserRoleRequest::getWorkspaceId() const {
return workspaceId_;
}