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

Initialize APIs.

Browse Source
This commit is contained in:
sdk-team
2022-03-04 09:56:50 +00:00
parent a1e11dbb5b
commit e23adc1324
158 changed files with 548 additions and 2172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2022-03-04 Version: 1.36.1070
- Initialize APIs.
2022-03-03 Version: 1.36.1069
- Release RecognizeVideoCastCrewList.

2
VERSION
View File

@@ -1 +1 @@
1.36.1069
1.36.1070

20
quickbi-public/CMakeLists.txt
View File

@@ -41,8 +41,6 @@ set(quickbi-public_public_header_model
include/alibabacloud/quickbi-public/model/AddWorkspaceUsersResult.h
include/alibabacloud/quickbi-public/model/AuthorizeMenuRequest.h
include/alibabacloud/quickbi-public/model/AuthorizeMenuResult.h
include/alibabacloud/quickbi-public/model/BuildSignatureUrlRequest.h
include/alibabacloud/quickbi-public/model/BuildSignatureUrlResult.h
include/alibabacloud/quickbi-public/model/CancelAuthorizationMenuRequest.h
include/alibabacloud/quickbi-public/model/CancelAuthorizationMenuResult.h
include/alibabacloud/quickbi-public/model/CancelCollectionRequest.h
@@ -53,22 +51,16 @@ set(quickbi-public_public_header_model
include/alibabacloud/quickbi-public/model/ChangeVisibilityModelResult.h
include/alibabacloud/quickbi-public/model/CheckReadableRequest.h
include/alibabacloud/quickbi-public/model/CheckReadableResult.h
include/alibabacloud/quickbi-public/model/CreateEmbedTokenRequest.h
include/alibabacloud/quickbi-public/model/CreateEmbedTokenResult.h
include/alibabacloud/quickbi-public/model/CreateTicketRequest.h
include/alibabacloud/quickbi-public/model/CreateTicketResult.h
include/alibabacloud/quickbi-public/model/CreateUserGroupRequest.h
include/alibabacloud/quickbi-public/model/CreateUserGroupResult.h
include/alibabacloud/quickbi-public/model/DelayEmbedTokenRequest.h
include/alibabacloud/quickbi-public/model/DelayEmbedTokenResult.h
include/alibabacloud/quickbi-public/model/DelayTicketExpireTimeRequest.h
include/alibabacloud/quickbi-public/model/DelayTicketExpireTimeResult.h
include/alibabacloud/quickbi-public/model/DeleteDataLevelPermissionRuleUsersRequest.h
include/alibabacloud/quickbi-public/model/DeleteDataLevelPermissionRuleUsersResult.h
include/alibabacloud/quickbi-public/model/DeleteDataLevelRuleConfigRequest.h
include/alibabacloud/quickbi-public/model/DeleteDataLevelRuleConfigResult.h
include/alibabacloud/quickbi-public/model/DeleteEmbedTokenRequest.h
include/alibabacloud/quickbi-public/model/DeleteEmbedTokenResult.h
include/alibabacloud/quickbi-public/model/DeleteTicketRequest.h
include/alibabacloud/quickbi-public/model/DeleteTicketResult.h
include/alibabacloud/quickbi-public/model/DeleteUserRequest.h
@@ -115,8 +107,6 @@ set(quickbi-public_public_header_model
include/alibabacloud/quickbi-public/model/QueryDatasetListResult.h
include/alibabacloud/quickbi-public/model/QueryDatasetSwitchInfoRequest.h
include/alibabacloud/quickbi-public/model/QueryDatasetSwitchInfoResult.h
include/alibabacloud/quickbi-public/model/QueryEmbedTokenInfoRequest.h
include/alibabacloud/quickbi-public/model/QueryEmbedTokenInfoResult.h
include/alibabacloud/quickbi-public/model/QueryEmbeddedInfoRequest.h
include/alibabacloud/quickbi-public/model/QueryEmbeddedInfoResult.h
include/alibabacloud/quickbi-public/model/QueryEmbeddedStausRequest.h
@@ -210,8 +200,6 @@ set(quickbi-public_src
src/model/AddWorkspaceUsersResult.cc
src/model/AuthorizeMenuRequest.cc
src/model/AuthorizeMenuResult.cc
src/model/BuildSignatureUrlRequest.cc
src/model/BuildSignatureUrlResult.cc
src/model/CancelAuthorizationMenuRequest.cc
src/model/CancelAuthorizationMenuResult.cc
src/model/CancelCollectionRequest.cc
@@ -222,22 +210,16 @@ set(quickbi-public_src
src/model/ChangeVisibilityModelResult.cc
src/model/CheckReadableRequest.cc
src/model/CheckReadableResult.cc
src/model/CreateEmbedTokenRequest.cc
src/model/CreateEmbedTokenResult.cc
src/model/CreateTicketRequest.cc
src/model/CreateTicketResult.cc
src/model/CreateUserGroupRequest.cc
src/model/CreateUserGroupResult.cc
src/model/DelayEmbedTokenRequest.cc
src/model/DelayEmbedTokenResult.cc
src/model/DelayTicketExpireTimeRequest.cc
src/model/DelayTicketExpireTimeResult.cc
src/model/DeleteDataLevelPermissionRuleUsersRequest.cc
src/model/DeleteDataLevelPermissionRuleUsersResult.cc
src/model/DeleteDataLevelRuleConfigRequest.cc
src/model/DeleteDataLevelRuleConfigResult.cc
src/model/DeleteEmbedTokenRequest.cc
src/model/DeleteEmbedTokenResult.cc
src/model/DeleteTicketRequest.cc
src/model/DeleteTicketResult.cc
src/model/DeleteUserRequest.cc
@@ -284,8 +266,6 @@ set(quickbi-public_src
src/model/QueryDatasetListResult.cc
src/model/QueryDatasetSwitchInfoRequest.cc
src/model/QueryDatasetSwitchInfoResult.cc
src/model/QueryEmbedTokenInfoRequest.cc
src/model/QueryEmbedTokenInfoResult.cc
src/model/QueryEmbeddedInfoRequest.cc
src/model/QueryEmbeddedInfoResult.cc
src/model/QueryEmbeddedStausRequest.cc

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

@@ -42,8 +42,6 @@
#include "model/AddWorkspaceUsersResult.h"
#include "model/AuthorizeMenuRequest.h"
#include "model/AuthorizeMenuResult.h"
#include "model/BuildSignatureUrlRequest.h"
#include "model/BuildSignatureUrlResult.h"
#include "model/CancelAuthorizationMenuRequest.h"
#include "model/CancelAuthorizationMenuResult.h"
#include "model/CancelCollectionRequest.h"
@@ -54,22 +52,16 @@
#include "model/ChangeVisibilityModelResult.h"
#include "model/CheckReadableRequest.h"
#include "model/CheckReadableResult.h"
#include "model/CreateEmbedTokenRequest.h"
#include "model/CreateEmbedTokenResult.h"
#include "model/CreateTicketRequest.h"
#include "model/CreateTicketResult.h"
#include "model/CreateUserGroupRequest.h"
#include "model/CreateUserGroupResult.h"
#include "model/DelayEmbedTokenRequest.h"
#include "model/DelayEmbedTokenResult.h"
#include "model/DelayTicketExpireTimeRequest.h"
#include "model/DelayTicketExpireTimeResult.h"
#include "model/DeleteDataLevelPermissionRuleUsersRequest.h"
#include "model/DeleteDataLevelPermissionRuleUsersResult.h"
#include "model/DeleteDataLevelRuleConfigRequest.h"
#include "model/DeleteDataLevelRuleConfigResult.h"
#include "model/DeleteEmbedTokenRequest.h"
#include "model/DeleteEmbedTokenResult.h"
#include "model/DeleteTicketRequest.h"
#include "model/DeleteTicketResult.h"
#include "model/DeleteUserRequest.h"
@@ -116,8 +108,6 @@
#include "model/QueryDatasetListResult.h"
#include "model/QueryDatasetSwitchInfoRequest.h"
#include "model/QueryDatasetSwitchInfoResult.h"
#include "model/QueryEmbedTokenInfoRequest.h"
#include "model/QueryEmbedTokenInfoResult.h"
#include "model/QueryEmbeddedInfoRequest.h"
#include "model/QueryEmbeddedInfoResult.h"
#include "model/QueryEmbeddedStausRequest.h"
@@ -227,9 +217,6 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::AuthorizeMenuResult> AuthorizeMenuOutcome;
typedef std::future<AuthorizeMenuOutcome> AuthorizeMenuOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::AuthorizeMenuRequest&, const AuthorizeMenuOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AuthorizeMenuAsyncHandler;
typedef Outcome<Error, Model::BuildSignatureUrlResult> BuildSignatureUrlOutcome;
typedef std::future<BuildSignatureUrlOutcome> BuildSignatureUrlOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::BuildSignatureUrlRequest&, const BuildSignatureUrlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BuildSignatureUrlAsyncHandler;
typedef Outcome<Error, Model::CancelAuthorizationMenuResult> CancelAuthorizationMenuOutcome;
typedef std::future<CancelAuthorizationMenuOutcome> CancelAuthorizationMenuOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::CancelAuthorizationMenuRequest&, const CancelAuthorizationMenuOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelAuthorizationMenuAsyncHandler;
@@ -245,18 +232,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CheckReadableResult> CheckReadableOutcome;
typedef std::future<CheckReadableOutcome> CheckReadableOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::CheckReadableRequest&, const CheckReadableOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckReadableAsyncHandler;
typedef Outcome<Error, Model::CreateEmbedTokenResult> CreateEmbedTokenOutcome;
typedef std::future<CreateEmbedTokenOutcome> CreateEmbedTokenOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::CreateEmbedTokenRequest&, const CreateEmbedTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateEmbedTokenAsyncHandler;
typedef Outcome<Error, Model::CreateTicketResult> CreateTicketOutcome;
typedef std::future<CreateTicketOutcome> CreateTicketOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::CreateTicketRequest&, const CreateTicketOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTicketAsyncHandler;
typedef Outcome<Error, Model::CreateUserGroupResult> CreateUserGroupOutcome;
typedef std::future<CreateUserGroupOutcome> CreateUserGroupOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::CreateUserGroupRequest&, const CreateUserGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateUserGroupAsyncHandler;
typedef Outcome<Error, Model::DelayEmbedTokenResult> DelayEmbedTokenOutcome;
typedef std::future<DelayEmbedTokenOutcome> DelayEmbedTokenOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::DelayEmbedTokenRequest&, const DelayEmbedTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DelayEmbedTokenAsyncHandler;
typedef Outcome<Error, Model::DelayTicketExpireTimeResult> DelayTicketExpireTimeOutcome;
typedef std::future<DelayTicketExpireTimeOutcome> DelayTicketExpireTimeOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::DelayTicketExpireTimeRequest&, const DelayTicketExpireTimeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DelayTicketExpireTimeAsyncHandler;
@@ -266,9 +247,6 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteDataLevelRuleConfigResult> DeleteDataLevelRuleConfigOutcome;
typedef std::future<DeleteDataLevelRuleConfigOutcome> DeleteDataLevelRuleConfigOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::DeleteDataLevelRuleConfigRequest&, const DeleteDataLevelRuleConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDataLevelRuleConfigAsyncHandler;
typedef Outcome<Error, Model::DeleteEmbedTokenResult> DeleteEmbedTokenOutcome;
typedef std::future<DeleteEmbedTokenOutcome> DeleteEmbedTokenOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::DeleteEmbedTokenRequest&, const DeleteEmbedTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteEmbedTokenAsyncHandler;
typedef Outcome<Error, Model::DeleteTicketResult> DeleteTicketOutcome;
typedef std::future<DeleteTicketOutcome> DeleteTicketOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::DeleteTicketRequest&, const DeleteTicketOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTicketAsyncHandler;
@@ -338,9 +316,6 @@ namespace AlibabaCloud
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;
typedef Outcome<Error, Model::QueryEmbedTokenInfoResult> QueryEmbedTokenInfoOutcome;
typedef std::future<QueryEmbedTokenInfoOutcome> QueryEmbedTokenInfoOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::QueryEmbedTokenInfoRequest&, const QueryEmbedTokenInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryEmbedTokenInfoAsyncHandler;
typedef Outcome<Error, Model::QueryEmbeddedInfoResult> QueryEmbeddedInfoOutcome;
typedef std::future<QueryEmbeddedInfoOutcome> QueryEmbeddedInfoOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::QueryEmbeddedInfoRequest&, const QueryEmbeddedInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryEmbeddedInfoAsyncHandler;
@@ -481,9 +456,6 @@ namespace AlibabaCloud
AuthorizeMenuOutcome authorizeMenu(const Model::AuthorizeMenuRequest &request)const;
void authorizeMenuAsync(const Model::AuthorizeMenuRequest& request, const AuthorizeMenuAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AuthorizeMenuOutcomeCallable authorizeMenuCallable(const Model::AuthorizeMenuRequest& request) const;
BuildSignatureUrlOutcome buildSignatureUrl(const Model::BuildSignatureUrlRequest &request)const;
void buildSignatureUrlAsync(const Model::BuildSignatureUrlRequest& request, const BuildSignatureUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BuildSignatureUrlOutcomeCallable buildSignatureUrlCallable(const Model::BuildSignatureUrlRequest& request) const;
CancelAuthorizationMenuOutcome cancelAuthorizationMenu(const Model::CancelAuthorizationMenuRequest &request)const;
void cancelAuthorizationMenuAsync(const Model::CancelAuthorizationMenuRequest& request, const CancelAuthorizationMenuAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CancelAuthorizationMenuOutcomeCallable cancelAuthorizationMenuCallable(const Model::CancelAuthorizationMenuRequest& request) const;
@@ -499,18 +471,12 @@ namespace AlibabaCloud
CheckReadableOutcome checkReadable(const Model::CheckReadableRequest &request)const;
void checkReadableAsync(const Model::CheckReadableRequest& request, const CheckReadableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckReadableOutcomeCallable checkReadableCallable(const Model::CheckReadableRequest& request) const;
CreateEmbedTokenOutcome createEmbedToken(const Model::CreateEmbedTokenRequest &request)const;
void createEmbedTokenAsync(const Model::CreateEmbedTokenRequest& request, const CreateEmbedTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateEmbedTokenOutcomeCallable createEmbedTokenCallable(const Model::CreateEmbedTokenRequest& request) const;
CreateTicketOutcome createTicket(const Model::CreateTicketRequest &request)const;
void createTicketAsync(const Model::CreateTicketRequest& request, const CreateTicketAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateTicketOutcomeCallable createTicketCallable(const Model::CreateTicketRequest& request) const;
CreateUserGroupOutcome createUserGroup(const Model::CreateUserGroupRequest &request)const;
void createUserGroupAsync(const Model::CreateUserGroupRequest& request, const CreateUserGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateUserGroupOutcomeCallable createUserGroupCallable(const Model::CreateUserGroupRequest& request) const;
DelayEmbedTokenOutcome delayEmbedToken(const Model::DelayEmbedTokenRequest &request)const;
void delayEmbedTokenAsync(const Model::DelayEmbedTokenRequest& request, const DelayEmbedTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DelayEmbedTokenOutcomeCallable delayEmbedTokenCallable(const Model::DelayEmbedTokenRequest& request) const;
DelayTicketExpireTimeOutcome delayTicketExpireTime(const Model::DelayTicketExpireTimeRequest &request)const;
void delayTicketExpireTimeAsync(const Model::DelayTicketExpireTimeRequest& request, const DelayTicketExpireTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DelayTicketExpireTimeOutcomeCallable delayTicketExpireTimeCallable(const Model::DelayTicketExpireTimeRequest& request) const;
@@ -520,9 +486,6 @@ namespace AlibabaCloud
DeleteDataLevelRuleConfigOutcome deleteDataLevelRuleConfig(const Model::DeleteDataLevelRuleConfigRequest &request)const;
void deleteDataLevelRuleConfigAsync(const Model::DeleteDataLevelRuleConfigRequest& request, const DeleteDataLevelRuleConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDataLevelRuleConfigOutcomeCallable deleteDataLevelRuleConfigCallable(const Model::DeleteDataLevelRuleConfigRequest& request) const;
DeleteEmbedTokenOutcome deleteEmbedToken(const Model::DeleteEmbedTokenRequest &request)const;
void deleteEmbedTokenAsync(const Model::DeleteEmbedTokenRequest& request, const DeleteEmbedTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteEmbedTokenOutcomeCallable deleteEmbedTokenCallable(const Model::DeleteEmbedTokenRequest& request) const;
DeleteTicketOutcome deleteTicket(const Model::DeleteTicketRequest &request)const;
void deleteTicketAsync(const Model::DeleteTicketRequest& request, const DeleteTicketAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteTicketOutcomeCallable deleteTicketCallable(const Model::DeleteTicketRequest& request) const;
@@ -592,9 +555,6 @@ namespace AlibabaCloud
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;
QueryEmbedTokenInfoOutcome queryEmbedTokenInfo(const Model::QueryEmbedTokenInfoRequest &request)const;
void queryEmbedTokenInfoAsync(const Model::QueryEmbedTokenInfoRequest& request, const QueryEmbedTokenInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryEmbedTokenInfoOutcomeCallable queryEmbedTokenInfoCallable(const Model::QueryEmbedTokenInfoRequest& request) const;
QueryEmbeddedInfoOutcome queryEmbeddedInfo(const Model::QueryEmbeddedInfoRequest &request)const;
void queryEmbeddedInfoAsync(const Model::QueryEmbeddedInfoRequest& request, const QueryEmbeddedInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
QueryEmbeddedInfoOutcomeCallable queryEmbeddedInfoCallable(const Model::QueryEmbeddedInfoRequest& request) const;

18
quickbi-public/include/alibabacloud/quickbi-public/model/AddShareReportRequest.h
View File

@@ -35,14 +35,8 @@ namespace AlibabaCloud
AddShareReportRequest();
~AddShareReportRequest();
int getShareToType()const;
void setShareToType(int shareToType);
std::string getWorksId()const;
void setWorksId(const std::string& worksId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getShareToId()const;
void setShareToId(const std::string& shareToId);
std::string getAccessPoint()const;
void setAccessPoint(const std::string& accessPoint);
int getAuthPoint()const;
@@ -51,16 +45,22 @@ namespace AlibabaCloud
void setSignType(const std::string& signType);
long getExpireDate()const;
void setExpireDate(long expireDate);
int getShareToType()const;
void setShareToType(int shareToType);
std::string getWorksId()const;
void setWorksId(const std::string& worksId);
std::string getShareToId()const;
void setShareToId(const std::string& shareToId);
private:
int shareToType_;
std::string worksId_;
std::string clientToken_;
std::string shareToId_;
std::string accessPoint_;
int authPoint_;
std::string signType_;
long expireDate_;
int shareToType_;
std::string worksId_;
std::string shareToId_;
};
}

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

@@ -36,8 +36,8 @@ namespace AlibabaCloud
{
std::string failureDetail;
int total;
int success;
int failure;
int success;
};

75
quickbi-public/include/alibabacloud/quickbi-public/model/BuildSignatureUrlRequest.h
View File

@@ -1,75 +0,0 @@
/*
* 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_BUILDSIGNATUREURLREQUEST_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_BUILDSIGNATUREURLREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
namespace AlibabaCloud
{
namespace Quickbi_public
{
namespace Model
{
class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT BuildSignatureUrlRequest : public RpcServiceRequest
{
public:
BuildSignatureUrlRequest();
~BuildSignatureUrlRequest();
std::string getWatermark()const;
void setWatermark(const std::string& watermark);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getAccessPoint()const;
void setAccessPoint(const std::string& accessPoint);
int getAccountType()const;
void setAccountType(int accountType);
std::string getSignType()const;
void setSignType(const std::string& signType);
std::string getUserId()const;
void setUserId(const std::string& userId);
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
std::string getWorksId()const;
void setWorksId(const std::string& worksId);
bool getWithHost()const;
void setWithHost(bool withHost);
int getExpireMin()const;
void setExpireMin(int expireMin);
private:
std::string watermark_;
std::string clientToken_;
std::string accessPoint_;
int accountType_;
std::string signType_;
std::string userId_;
std::string accountName_;
std::string worksId_;
bool withHost_;
int expireMin_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_BUILDSIGNATUREURLREQUEST_H_

53
quickbi-public/include/alibabacloud/quickbi-public/model/BuildSignatureUrlResult.h
View File

@@ -1,53 +0,0 @@
/*
* 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_BUILDSIGNATUREURLRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_BUILDSIGNATUREURLRESULT_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 BuildSignatureUrlResult : public ServiceResult
{
public:
BuildSignatureUrlResult();
explicit BuildSignatureUrlResult(const std::string &payload);
~BuildSignatureUrlResult();
bool getSuccess()const;
std::string getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
std::string result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_BUILDSIGNATUREURLRESULT_H_

69
quickbi-public/include/alibabacloud/quickbi-public/model/CreateEmbedTokenRequest.h
View File

@@ -1,69 +0,0 @@
/*
* 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_CREATEEMBEDTOKENREQUEST_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEEMBEDTOKENREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
namespace AlibabaCloud
{
namespace Quickbi_public
{
namespace Model
{
class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT CreateEmbedTokenRequest : public RpcServiceRequest
{
public:
CreateEmbedTokenRequest();
~CreateEmbedTokenRequest();
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getWorksId()const;
void setWorksId(const std::string& worksId);
std::string getAccessPoint()const;
void setAccessPoint(const std::string& accessPoint);
int getAccountType()const;
void setAccountType(int accountType);
std::string getSignType()const;
void setSignType(const std::string& signType);
int getExpireMin()const;
void setExpireMin(int expireMin);
std::string getUserId()const;
void setUserId(const std::string& userId);
private:
std::string accountName_;
std::string clientToken_;
std::string worksId_;
std::string accessPoint_;
int accountType_;
std::string signType_;
int expireMin_;
std::string userId_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEEMBEDTOKENREQUEST_H_

60
quickbi-public/include/alibabacloud/quickbi-public/model/CreateEmbedTokenResult.h
View File

@@ -1,60 +0,0 @@
/*
* 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_CREATEEMBEDTOKENRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEEMBEDTOKENRESULT_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 CreateEmbedTokenResult : public ServiceResult
{
public:
struct Result
{
std::string registerTime;
std::string accessToken;
long tokeType;
std::string invalidTime;
};
CreateEmbedTokenResult();
explicit CreateEmbedTokenResult(const std::string &payload);
~CreateEmbedTokenResult();
bool getSuccess()const;
Result getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
Result result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEEMBEDTOKENRESULT_H_

60
quickbi-public/include/alibabacloud/quickbi-public/model/DelayEmbedTokenRequest.h
View File

@@ -1,60 +0,0 @@
/*
* 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_DELAYEMBEDTOKENREQUEST_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DELAYEMBEDTOKENREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
namespace AlibabaCloud
{
namespace Quickbi_public
{
namespace Model
{
class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT DelayEmbedTokenRequest : public RpcServiceRequest
{
public:
DelayEmbedTokenRequest();
~DelayEmbedTokenRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getAccessPoint()const;
void setAccessPoint(const std::string& accessPoint);
std::string getSignType()const;
void setSignType(const std::string& signType);
int getExpireMin()const;
void setExpireMin(int expireMin);
std::string getToken()const;
void setToken(const std::string& token);
private:
std::string clientToken_;
std::string accessPoint_;
std::string signType_;
int expireMin_;
std::string token_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DELAYEMBEDTOKENREQUEST_H_

53
quickbi-public/include/alibabacloud/quickbi-public/model/DelayEmbedTokenResult.h
View File

@@ -1,53 +0,0 @@
/*
* 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_DELAYEMBEDTOKENRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DELAYEMBEDTOKENRESULT_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 DelayEmbedTokenResult : public ServiceResult
{
public:
DelayEmbedTokenResult();
explicit DelayEmbedTokenResult(const std::string &payload);
~DelayEmbedTokenResult();
bool getSuccess()const;
bool getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
bool result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DELAYEMBEDTOKENRESULT_H_

57
quickbi-public/include/alibabacloud/quickbi-public/model/DeleteEmbedTokenRequest.h
View File

@@ -1,57 +0,0 @@
/*
* 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_DELETEEMBEDTOKENREQUEST_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DELETEEMBEDTOKENREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
namespace AlibabaCloud
{
namespace Quickbi_public
{
namespace Model
{
class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT DeleteEmbedTokenRequest : public RpcServiceRequest
{
public:
DeleteEmbedTokenRequest();
~DeleteEmbedTokenRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getAccessPoint()const;
void setAccessPoint(const std::string& accessPoint);
std::string getSignType()const;
void setSignType(const std::string& signType);
std::string getToken()const;
void setToken(const std::string& token);
private:
std::string clientToken_;
std::string accessPoint_;
std::string signType_;
std::string token_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DELETEEMBEDTOKENREQUEST_H_

53
quickbi-public/include/alibabacloud/quickbi-public/model/DeleteEmbedTokenResult.h
View File

@@ -1,53 +0,0 @@
/*
* 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_DELETEEMBEDTOKENRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DELETEEMBEDTOKENRESULT_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 DeleteEmbedTokenResult : public ServiceResult
{
public:
DeleteEmbedTokenResult();
explicit DeleteEmbedTokenResult(const std::string &payload);
~DeleteEmbedTokenResult();
bool getSuccess()const;
bool getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
bool result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DELETEEMBEDTOKENRESULT_H_

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

@@ -35,8 +35,8 @@ namespace AlibabaCloud
struct Data
{
std::string modifyUser;
std::string usergroupDesc;
std::string modifiedTime;
std::string usergroupDesc;
std::string identifiedPath;
std::string createTime;
std::string parentUsergroupId;

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

@@ -37,8 +37,8 @@ namespace AlibabaCloud
struct UserGroupModelsItem
{
std::string modifyUser;
std::string usergroupDesc;
std::string modifiedTime;
std::string usergroupDesc;
std::string identifiedPath;
std::string createTime;
std::string parentUsergroupId;

24
quickbi-public/include/alibabacloud/quickbi-public/model/ListRecentViewReportsRequest.h
View File

@@ -35,32 +35,32 @@ namespace AlibabaCloud
ListRecentViewReportsRequest();
~ListRecentViewReportsRequest();
std::string getQueryMode()const;
void setQueryMode(const std::string& queryMode);
std::string getTreeType()const;
void setTreeType(const std::string& treeType);
std::string getAccessPoint()const;
void setAccessPoint(const std::string& accessPoint);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getSignType()const;
void setSignType(const std::string& signType);
int getOffsetDay()const;
void setOffsetDay(int offsetDay);
std::string getKeyword()const;
void setKeyword(const std::string& keyword);
std::string getUserId()const;
void setUserId(const std::string& userId);
std::string getQueryMode()const;
void setQueryMode(const std::string& queryMode);
std::string getTreeType()const;
void setTreeType(const std::string& treeType);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getKeyword()const;
void setKeyword(const std::string& keyword);
private:
std::string queryMode_;
std::string treeType_;
std::string accessPoint_;
int pageSize_;
std::string signType_;
int offsetDay_;
std::string keyword_;
std::string userId_;
std::string queryMode_;
std::string treeType_;
int pageSize_;
std::string keyword_;
};
}

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

@@ -35,8 +35,8 @@ namespace AlibabaCloud
struct Data
{
std::string modifyUser;
std::string usergroupDesc;
std::string modifiedTime;
std::string usergroupDesc;
std::string identifiedPath;
std::string createTime;
std::string parentUsergroupId;

12
quickbi-public/include/alibabacloud/quickbi-public/model/QueryDatasetListRequest.h
View File

@@ -37,29 +37,29 @@ namespace AlibabaCloud
std::string getAccessPoint()const;
void setAccessPoint(const std::string& accessPoint);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getSignType()const;
void setSignType(const std::string& signType);
int getPageNum()const;
void setPageNum(int pageNum);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getDirectoryId()const;
void setDirectoryId(const std::string& directoryId);
bool getWithChildren()const;
void setWithChildren(bool withChildren);
std::string getKeyword()const;
void setKeyword(const std::string& keyword);
int getPageNum()const;
void setPageNum(int pageNum);
std::string getWorkspaceId()const;
void setWorkspaceId(const std::string& workspaceId);
private:
std::string accessPoint_;
int pageSize_;
std::string signType_;
int pageNum_;
int pageSize_;
std::string directoryId_;
bool withChildren_;
std::string keyword_;
int pageNum_;
std::string workspaceId_;
};

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

@@ -45,8 +45,8 @@ namespace AlibabaCloud
struct Directory
{
std::string pathId;
std::string id;
std::string pathName;
std::string id;
std::string name;
};
std::string modifyTime;

57
quickbi-public/include/alibabacloud/quickbi-public/model/QueryEmbedTokenInfoRequest.h
View File

@@ -1,57 +0,0 @@
/*
* 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_QUERYEMBEDTOKENINFOREQUEST_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYEMBEDTOKENINFOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
namespace AlibabaCloud
{
namespace Quickbi_public
{
namespace Model
{
class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryEmbedTokenInfoRequest : public RpcServiceRequest
{
public:
QueryEmbedTokenInfoRequest();
~QueryEmbedTokenInfoRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getAccessPoint()const;
void setAccessPoint(const std::string& accessPoint);
std::string getSignType()const;
void setSignType(const std::string& signType);
std::string getToken()const;
void setToken(const std::string& token);
private:
std::string clientToken_;
std::string accessPoint_;
std::string signType_;
std::string token_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYEMBEDTOKENINFOREQUEST_H_

60
quickbi-public/include/alibabacloud/quickbi-public/model/QueryEmbedTokenInfoResult.h
View File

@@ -1,60 +0,0 @@
/*
* 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_QUERYEMBEDTOKENINFORESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYEMBEDTOKENINFORESULT_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 QueryEmbedTokenInfoResult : public ServiceResult
{
public:
struct Result
{
std::string registerTime;
std::string accessToken;
long tokeType;
std::string invalidTime;
};
QueryEmbedTokenInfoResult();
explicit QueryEmbedTokenInfoResult(const std::string &payload);
~QueryEmbedTokenInfoResult();
bool getSuccess()const;
Result getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
Result result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYEMBEDTOKENINFORESULT_H_

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

@@ -39,8 +39,8 @@ namespace AlibabaCloud
std::string workspaceDescription;
std::string owner;
std::string modifyUser;
std::string ownerAccountName;
std::string createTime;
std::string ownerAccountName;
std::string workspaceId;
std::string createUser;
std::string organizationId;

4
quickbi-public/include/alibabacloud/quickbi-public/model/QueryReadableResourcesListByUserIdResult.h
View File

@@ -37,8 +37,8 @@ namespace AlibabaCloud
struct Directory
{
std::string pathId;
std::string id;
std::string pathName;
std::string id;
std::string name;
};
int status;
@@ -51,8 +51,8 @@ namespace AlibabaCloud
std::string workspaceId;
int thirdPartAuthFlag;
std::string ownerId;
std::string workName;
std::string securityLevel;
std::string workName;
std::string workspaceName;
std::string worksId;
Directory directory;

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

@@ -36,8 +36,8 @@ namespace AlibabaCloud
{
std::string shareId;
std::string shareToId;
int shareToType;
long expireDate;
int shareToType;
int authPoint;
std::string shareToName;
std::string reportId;

4
quickbi-public/include/alibabacloud/quickbi-public/model/QuerySharesToUserListResult.h
View File

@@ -37,8 +37,8 @@ namespace AlibabaCloud
struct Directory
{
std::string pathId;
std::string id;
std::string pathName;
std::string id;
std::string name;
};
int status;
@@ -51,8 +51,8 @@ namespace AlibabaCloud
std::string workspaceId;
int thirdPartAuthFlag;
std::string ownerId;
std::string workName;
std::string securityLevel;
std::string workName;
std::string workspaceName;
std::string worksId;
Directory directory;

4
quickbi-public/include/alibabacloud/quickbi-public/model/QueryUserGroupListByParentIdResult.h
View File

@@ -37,10 +37,10 @@ namespace AlibabaCloud
std::string parentUserGroupId;
std::string modifyUser;
std::string modifiedTime;
std::string userGroupId;
std::string userGroupName;
std::string identifiedPath;
std::string createTime;
std::string userGroupId;
std::string userGroupName;
std::string createUser;
std::string userGroupDescription;
};

4
quickbi-public/include/alibabacloud/quickbi-public/model/QueryUserInfoByAccountResult.h
View File

@@ -34,10 +34,10 @@ namespace AlibabaCloud
public:
struct Result
{
std::string accountId;
std::string email;
std::string phone;
std::string accountId;
std::string userId;
std::string phone;
bool adminUser;
std::string nickName;
int userType;

4
quickbi-public/include/alibabacloud/quickbi-public/model/QueryUserInfoByUserIdResult.h
View File

@@ -34,10 +34,10 @@ namespace AlibabaCloud
public:
struct Result
{
std::string accountId;
std::string email;
std::string phone;
std::string accountId;
std::string userId;
std::string phone;
bool adminUser;
std::string nickName;
int userType;

4
quickbi-public/include/alibabacloud/quickbi-public/model/QueryUserListResult.h
View File

@@ -36,10 +36,10 @@ namespace AlibabaCloud
{
struct DataItem
{
std::string accountId;
std::string email;
std::string phone;
std::string accountId;
std::string userId;
std::string phone;
bool adminUser;
std::string nickName;
int userType;

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

@@ -35,8 +35,8 @@ namespace AlibabaCloud
struct Result
{
std::string roleName;
long roleId;
std::string roleCode;
long roleId;
};

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

@@ -39,8 +39,8 @@ namespace AlibabaCloud
struct Directory
{
std::string pathId;
std::string id;
std::string pathName;
std::string id;
std::string name;
};
int status;

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

@@ -41,12 +41,12 @@ namespace AlibabaCloud
void setThirdPartAuthFlag(int thirdPartAuthFlag);
std::string getAccessPoint()const;
void setAccessPoint(const std::string& accessPoint);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getSignType()const;
void setSignType(const std::string& signType);
int getPageNum()const;
void setPageNum(int pageNum);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getWorkspaceId()const;
void setWorkspaceId(const std::string& workspaceId);
int getStatus()const;
@@ -56,9 +56,9 @@ namespace AlibabaCloud
std::string worksType_;
int thirdPartAuthFlag_;
std::string accessPoint_;
int pageSize_;
std::string signType_;
int pageNum_;
int pageSize_;
std::string workspaceId_;
int status_;

4
quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorkspaceUserListResult.h
View File

@@ -39,8 +39,8 @@ namespace AlibabaCloud
struct Role
{
std::string roleName;
long roleId;
std::string roleCode;
long roleId;
};
Role role;
std::string email;
@@ -51,8 +51,8 @@ namespace AlibabaCloud
std::string accountName;
};
int totalNum;
int pageSize;
int pageNum;
int pageSize;
std::vector<DataItem> data;
int totalPages;
};

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

@@ -36,8 +36,8 @@ namespace AlibabaCloud
{
std::string failureDetail;
int total;
int success;
int failure;
int success;
};

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

@@ -411,42 +411,6 @@ Quickbi_publicClient::AuthorizeMenuOutcomeCallable Quickbi_publicClient::authori
return task->get_future();
}
Quickbi_publicClient::BuildSignatureUrlOutcome Quickbi_publicClient::buildSignatureUrl(const BuildSignatureUrlRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return BuildSignatureUrlOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return BuildSignatureUrlOutcome(BuildSignatureUrlResult(outcome.result()));
else
return BuildSignatureUrlOutcome(outcome.error());
}
void Quickbi_publicClient::buildSignatureUrlAsync(const BuildSignatureUrlRequest& request, const BuildSignatureUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, buildSignatureUrl(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::BuildSignatureUrlOutcomeCallable Quickbi_publicClient::buildSignatureUrlCallable(const BuildSignatureUrlRequest &request) const
{
auto task = std::make_shared<std::packaged_task<BuildSignatureUrlOutcome()>>(
[this, request]()
{
return this->buildSignatureUrl(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::CancelAuthorizationMenuOutcome Quickbi_publicClient::cancelAuthorizationMenu(const CancelAuthorizationMenuRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -627,42 +591,6 @@ Quickbi_publicClient::CheckReadableOutcomeCallable Quickbi_publicClient::checkRe
return task->get_future();
}
Quickbi_publicClient::CreateEmbedTokenOutcome Quickbi_publicClient::createEmbedToken(const CreateEmbedTokenRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateEmbedTokenOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateEmbedTokenOutcome(CreateEmbedTokenResult(outcome.result()));
else
return CreateEmbedTokenOutcome(outcome.error());
}
void Quickbi_publicClient::createEmbedTokenAsync(const CreateEmbedTokenRequest& request, const CreateEmbedTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createEmbedToken(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::CreateEmbedTokenOutcomeCallable Quickbi_publicClient::createEmbedTokenCallable(const CreateEmbedTokenRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateEmbedTokenOutcome()>>(
[this, request]()
{
return this->createEmbedToken(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::CreateTicketOutcome Quickbi_publicClient::createTicket(const CreateTicketRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -735,42 +663,6 @@ Quickbi_publicClient::CreateUserGroupOutcomeCallable Quickbi_publicClient::creat
return task->get_future();
}
Quickbi_publicClient::DelayEmbedTokenOutcome Quickbi_publicClient::delayEmbedToken(const DelayEmbedTokenRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DelayEmbedTokenOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DelayEmbedTokenOutcome(DelayEmbedTokenResult(outcome.result()));
else
return DelayEmbedTokenOutcome(outcome.error());
}
void Quickbi_publicClient::delayEmbedTokenAsync(const DelayEmbedTokenRequest& request, const DelayEmbedTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, delayEmbedToken(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::DelayEmbedTokenOutcomeCallable Quickbi_publicClient::delayEmbedTokenCallable(const DelayEmbedTokenRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DelayEmbedTokenOutcome()>>(
[this, request]()
{
return this->delayEmbedToken(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::DelayTicketExpireTimeOutcome Quickbi_publicClient::delayTicketExpireTime(const DelayTicketExpireTimeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -879,42 +771,6 @@ Quickbi_publicClient::DeleteDataLevelRuleConfigOutcomeCallable Quickbi_publicCli
return task->get_future();
}
Quickbi_publicClient::DeleteEmbedTokenOutcome Quickbi_publicClient::deleteEmbedToken(const DeleteEmbedTokenRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteEmbedTokenOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteEmbedTokenOutcome(DeleteEmbedTokenResult(outcome.result()));
else
return DeleteEmbedTokenOutcome(outcome.error());
}
void Quickbi_publicClient::deleteEmbedTokenAsync(const DeleteEmbedTokenRequest& request, const DeleteEmbedTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteEmbedToken(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::DeleteEmbedTokenOutcomeCallable Quickbi_publicClient::deleteEmbedTokenCallable(const DeleteEmbedTokenRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteEmbedTokenOutcome()>>(
[this, request]()
{
return this->deleteEmbedToken(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::DeleteTicketOutcome Quickbi_publicClient::deleteTicket(const DeleteTicketRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1743,42 +1599,6 @@ Quickbi_publicClient::QueryDatasetSwitchInfoOutcomeCallable Quickbi_publicClient
return task->get_future();
}
Quickbi_publicClient::QueryEmbedTokenInfoOutcome Quickbi_publicClient::queryEmbedTokenInfo(const QueryEmbedTokenInfoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QueryEmbedTokenInfoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QueryEmbedTokenInfoOutcome(QueryEmbedTokenInfoResult(outcome.result()));
else
return QueryEmbedTokenInfoOutcome(outcome.error());
}
void Quickbi_publicClient::queryEmbedTokenInfoAsync(const QueryEmbedTokenInfoRequest& request, const QueryEmbedTokenInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, queryEmbedTokenInfo(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::QueryEmbedTokenInfoOutcomeCallable Quickbi_publicClient::queryEmbedTokenInfoCallable(const QueryEmbedTokenInfoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QueryEmbedTokenInfoOutcome()>>(
[this, request]()
{
return this->queryEmbedTokenInfo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::QueryEmbeddedInfoOutcome Quickbi_publicClient::queryEmbeddedInfo(const QueryEmbeddedInfoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::AddDataLevelPermissionRuleUsersRequest;
AddDataLevelPermissionRuleUsersRequest::AddDataLevelPermissionRuleUsersRequest() :
RpcServiceRequest("quickbi-public", "2020-11-11", "AddDataLevelPermissionRuleUsers")
RpcServiceRequest("quickbi-public", "2022-01-01", "AddDataLevelPermissionRuleUsers")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::AddDataLevelPermissionWhiteListRequest;
AddDataLevelPermissionWhiteListRequest::AddDataLevelPermissionWhiteListRequest() :
RpcServiceRequest("quickbi-public", "2020-11-11", "AddDataLevelPermissionWhiteList")
RpcServiceRequest("quickbi-public", "2022-01-01", "AddDataLevelPermissionWhiteList")
{
setMethod(HttpRequest::Method::Post);
}

68
quickbi-public/src/model/AddShareReportRequest.cc
View File

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::AddShareReportRequest;
AddShareReportRequest::AddShareReportRequest() :
RpcServiceRequest("quickbi-public", "2020-08-04", "AddShareReport")
RpcServiceRequest("quickbi-public", "2022-01-01", "AddShareReport")
{
setMethod(HttpRequest::Method::Post);
}
@@ -27,28 +27,6 @@ AddShareReportRequest::AddShareReportRequest() :
AddShareReportRequest::~AddShareReportRequest()
{}
int AddShareReportRequest::getShareToType()const
{
return shareToType_;
}
void AddShareReportRequest::setShareToType(int shareToType)
{
shareToType_ = shareToType;
setParameter("ShareToType", std::to_string(shareToType));
}
std::string AddShareReportRequest::getWorksId()const
{
return worksId_;
}
void AddShareReportRequest::setWorksId(const std::string& worksId)
{
worksId_ = worksId;
setParameter("WorksId", worksId);
}
std::string AddShareReportRequest::getClientToken()const
{
return clientToken_;
@@ -60,17 +38,6 @@ void AddShareReportRequest::setClientToken(const std::string& clientToken)
setParameter("ClientToken", clientToken);
}
std::string AddShareReportRequest::getShareToId()const
{
return shareToId_;
}
void AddShareReportRequest::setShareToId(const std::string& shareToId)
{
shareToId_ = shareToId;
setParameter("ShareToId", shareToId);
}
std::string AddShareReportRequest::getAccessPoint()const
{
return accessPoint_;
@@ -115,3 +82,36 @@ void AddShareReportRequest::setExpireDate(long expireDate)
setParameter("ExpireDate", std::to_string(expireDate));
}
int AddShareReportRequest::getShareToType()const
{
return shareToType_;
}
void AddShareReportRequest::setShareToType(int shareToType)
{
shareToType_ = shareToType;
setParameter("ShareToType", std::to_string(shareToType));
}
std::string AddShareReportRequest::getWorksId()const
{
return worksId_;
}
void AddShareReportRequest::setWorksId(const std::string& worksId)
{
worksId_ = worksId;
setParameter("WorksId", worksId);
}
std::string AddShareReportRequest::getShareToId()const
{
return shareToId_;
}
void AddShareReportRequest::setShareToId(const std::string& shareToId)
{
shareToId_ = shareToId;
setParameter("ShareToId", shareToId);
}

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

@@ -39,10 +39,10 @@ void AddShareReportResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Result"].isNull())
result_ = value["Result"].asString() == "true";
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::AddUserGroupMemberRequest;
AddUserGroupMemberRequest::AddUserGroupMemberRequest() :
RpcServiceRequest("quickbi-public", "2020-07-31", "AddUserGroupMember")
RpcServiceRequest("quickbi-public", "2022-01-01", "AddUserGroupMember")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::AddUserGroupMembersRequest;
AddUserGroupMembersRequest::AddUserGroupMembersRequest() :
RpcServiceRequest("quickbi-public", "2020-07-31", "AddUserGroupMembers")
RpcServiceRequest("quickbi-public", "2022-01-01", "AddUserGroupMembers")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::AddUserRequest;
AddUserRequest::AddUserRequest() :
RpcServiceRequest("quickbi-public", "2020-08-01", "AddUser")
RpcServiceRequest("quickbi-public", "2022-01-01", "AddUser")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::AddUserTagMetaRequest;
AddUserTagMetaRequest::AddUserTagMetaRequest() :
RpcServiceRequest("quickbi-public", "2020-08-02", "AddUserTagMeta")
RpcServiceRequest("quickbi-public", "2022-01-01", "AddUserTagMeta")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::AddUserToWorkspaceRequest;
AddUserToWorkspaceRequest::AddUserToWorkspaceRequest() :
RpcServiceRequest("quickbi-public", "2020-08-03", "AddUserToWorkspace")
RpcServiceRequest("quickbi-public", "2022-01-01", "AddUserToWorkspace")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -39,10 +39,10 @@ void AddUserToWorkspaceResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Result"].isNull())
result_ = value["Result"].asString() == "true";
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::AddWorkspaceUsersRequest;
AddWorkspaceUsersRequest::AddWorkspaceUsersRequest() :
RpcServiceRequest("quickbi-public", "2020-08-03", "AddWorkspaceUsers")
RpcServiceRequest("quickbi-public", "2022-01-01", "AddWorkspaceUsers")
{
setMethod(HttpRequest::Method::Post);
}

8
quickbi-public/src/model/AddWorkspaceUsersResult.cc
View File

@@ -40,14 +40,14 @@ void AddWorkspaceUsersResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto resultNode = value["Result"];
if(!resultNode["Total"].isNull())
result_.total = std::stoi(resultNode["Total"].asString());
if(!resultNode["Success"].isNull())
result_.success = std::stoi(resultNode["Success"].asString());
if(!resultNode["Failure"].isNull())
result_.failure = std::stoi(resultNode["Failure"].asString());
if(!resultNode["FailureDetail"].isNull())
result_.failureDetail = resultNode["FailureDetail"].asString();
if(!resultNode["Total"].isNull())
result_.total = std::stoi(resultNode["Total"].asString());
if(!resultNode["Success"].isNull())
result_.success = std::stoi(resultNode["Success"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::AuthorizeMenuRequest;
AuthorizeMenuRequest::AuthorizeMenuRequest() :
RpcServiceRequest("quickbi-public", "2020-08-08", "AuthorizeMenu")
RpcServiceRequest("quickbi-public", "2022-01-01", "AuthorizeMenu")
{
setMethod(HttpRequest::Method::Post);
}

139
quickbi-public/src/model/BuildSignatureUrlRequest.cc
View File

@@ -1,139 +0,0 @@
/*
* 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/BuildSignatureUrlRequest.h>
using AlibabaCloud::Quickbi_public::Model::BuildSignatureUrlRequest;
BuildSignatureUrlRequest::BuildSignatureUrlRequest() :
RpcServiceRequest("quickbi-public", "2021-03-25", "BuildSignatureUrl")
{
setMethod(HttpRequest::Method::Post);
}
BuildSignatureUrlRequest::~BuildSignatureUrlRequest()
{}
std::string BuildSignatureUrlRequest::getWatermark()const
{
return watermark_;
}
void BuildSignatureUrlRequest::setWatermark(const std::string& watermark)
{
watermark_ = watermark;
setParameter("Watermark", watermark);
}
std::string BuildSignatureUrlRequest::getClientToken()const
{
return clientToken_;
}
void BuildSignatureUrlRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string BuildSignatureUrlRequest::getAccessPoint()const
{
return accessPoint_;
}
void BuildSignatureUrlRequest::setAccessPoint(const std::string& accessPoint)
{
accessPoint_ = accessPoint;
setParameter("AccessPoint", accessPoint);
}
int BuildSignatureUrlRequest::getAccountType()const
{
return accountType_;
}
void BuildSignatureUrlRequest::setAccountType(int accountType)
{
accountType_ = accountType;
setParameter("AccountType", std::to_string(accountType));
}
std::string BuildSignatureUrlRequest::getSignType()const
{
return signType_;
}
void BuildSignatureUrlRequest::setSignType(const std::string& signType)
{
signType_ = signType;
setParameter("SignType", signType);
}
std::string BuildSignatureUrlRequest::getUserId()const
{
return userId_;
}
void BuildSignatureUrlRequest::setUserId(const std::string& userId)
{
userId_ = userId;
setParameter("UserId", userId);
}
std::string BuildSignatureUrlRequest::getAccountName()const
{
return accountName_;
}
void BuildSignatureUrlRequest::setAccountName(const std::string& accountName)
{
accountName_ = accountName;
setParameter("AccountName", accountName);
}
std::string BuildSignatureUrlRequest::getWorksId()const
{
return worksId_;
}
void BuildSignatureUrlRequest::setWorksId(const std::string& worksId)
{
worksId_ = worksId;
setParameter("WorksId", worksId);
}
bool BuildSignatureUrlRequest::getWithHost()const
{
return withHost_;
}
void BuildSignatureUrlRequest::setWithHost(bool withHost)
{
withHost_ = withHost;
setParameter("WithHost", withHost ? "true" : "false");
}
int BuildSignatureUrlRequest::getExpireMin()const
{
return expireMin_;
}
void BuildSignatureUrlRequest::setExpireMin(int expireMin)
{
expireMin_ = expireMin;
setParameter("ExpireMin", std::to_string(expireMin));
}

58
quickbi-public/src/model/BuildSignatureUrlResult.cc
View File

@@ -1,58 +0,0 @@
/*
* 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/BuildSignatureUrlResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
BuildSignatureUrlResult::BuildSignatureUrlResult() :
ServiceResult()
{}
BuildSignatureUrlResult::BuildSignatureUrlResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
BuildSignatureUrlResult::~BuildSignatureUrlResult()
{}
void BuildSignatureUrlResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Result"].isNull())
result_ = value["Result"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool BuildSignatureUrlResult::getSuccess()const
{
return success_;
}
std::string BuildSignatureUrlResult::getResult()const
{
return result_;
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::CancelAuthorizationMenuRequest;
CancelAuthorizationMenuRequest::CancelAuthorizationMenuRequest() :
RpcServiceRequest("quickbi-public", "2020-08-08", "CancelAuthorizationMenu")
RpcServiceRequest("quickbi-public", "2022-01-01", "CancelAuthorizationMenu")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -39,10 +39,10 @@ void CancelAuthorizationMenuResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Result"].isNull())
result_ = std::stoi(value["Result"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::CancelCollectionRequest;
CancelCollectionRequest::CancelCollectionRequest() :
RpcServiceRequest("quickbi-public", "2020-08-09", "CancelCollection")
RpcServiceRequest("quickbi-public", "2022-01-01", "CancelCollection")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -39,10 +39,10 @@ void CancelCollectionResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Result"].isNull())
result_ = value["Result"].asString() == "true";
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::CancelReportShareRequest;
CancelReportShareRequest::CancelReportShareRequest() :
RpcServiceRequest("quickbi-public", "2020-08-04", "CancelReportShare")
RpcServiceRequest("quickbi-public", "2022-01-01", "CancelReportShare")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::ChangeVisibilityModelRequest;
ChangeVisibilityModelRequest::ChangeVisibilityModelRequest() :
RpcServiceRequest("quickbi-public", "2020-08-08", "ChangeVisibilityModel")
RpcServiceRequest("quickbi-public", "2022-01-01", "ChangeVisibilityModel")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -39,10 +39,10 @@ void ChangeVisibilityModelResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Result"].isNull())
result_ = std::stoi(value["Result"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::CheckReadableRequest;
CheckReadableRequest::CheckReadableRequest() :
RpcServiceRequest("quickbi-public", "2020-08-07", "CheckReadable")
RpcServiceRequest("quickbi-public", "2022-01-01", "CheckReadable")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -39,10 +39,10 @@ void CheckReadableResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Result"].isNull())
result_ = value["Result"].asString() == "true";
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

117
quickbi-public/src/model/CreateEmbedTokenRequest.cc
View File

@@ -1,117 +0,0 @@
/*
* 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/CreateEmbedTokenRequest.h>
using AlibabaCloud::Quickbi_public::Model::CreateEmbedTokenRequest;
CreateEmbedTokenRequest::CreateEmbedTokenRequest() :
RpcServiceRequest("quickbi-public", "2021-03-25", "CreateEmbedToken")
{
setMethod(HttpRequest::Method::Post);
}
CreateEmbedTokenRequest::~CreateEmbedTokenRequest()
{}
std::string CreateEmbedTokenRequest::getAccountName()const
{
return accountName_;
}
void CreateEmbedTokenRequest::setAccountName(const std::string& accountName)
{
accountName_ = accountName;
setParameter("AccountName", accountName);
}
std::string CreateEmbedTokenRequest::getClientToken()const
{
return clientToken_;
}
void CreateEmbedTokenRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateEmbedTokenRequest::getWorksId()const
{
return worksId_;
}
void CreateEmbedTokenRequest::setWorksId(const std::string& worksId)
{
worksId_ = worksId;
setParameter("WorksId", worksId);
}
std::string CreateEmbedTokenRequest::getAccessPoint()const
{
return accessPoint_;
}
void CreateEmbedTokenRequest::setAccessPoint(const std::string& accessPoint)
{
accessPoint_ = accessPoint;
setParameter("AccessPoint", accessPoint);
}
int CreateEmbedTokenRequest::getAccountType()const
{
return accountType_;
}
void CreateEmbedTokenRequest::setAccountType(int accountType)
{
accountType_ = accountType;
setParameter("AccountType", std::to_string(accountType));
}
std::string CreateEmbedTokenRequest::getSignType()const
{
return signType_;
}
void CreateEmbedTokenRequest::setSignType(const std::string& signType)
{
signType_ = signType;
setParameter("SignType", signType);
}
int CreateEmbedTokenRequest::getExpireMin()const
{
return expireMin_;
}
void CreateEmbedTokenRequest::setExpireMin(int expireMin)
{
expireMin_ = expireMin;
setParameter("ExpireMin", std::to_string(expireMin));
}
std::string CreateEmbedTokenRequest::getUserId()const
{
return userId_;
}
void CreateEmbedTokenRequest::setUserId(const std::string& userId)
{
userId_ = userId;
setParameter("UserId", userId);
}

65
quickbi-public/src/model/CreateEmbedTokenResult.cc
View File

@@ -1,65 +0,0 @@
/*
* 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/CreateEmbedTokenResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
CreateEmbedTokenResult::CreateEmbedTokenResult() :
ServiceResult()
{}
CreateEmbedTokenResult::CreateEmbedTokenResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateEmbedTokenResult::~CreateEmbedTokenResult()
{}
void CreateEmbedTokenResult::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["AccessToken"].isNull())
result_.accessToken = resultNode["AccessToken"].asString();
if(!resultNode["TokeType"].isNull())
result_.tokeType = std::stol(resultNode["TokeType"].asString());
if(!resultNode["InvalidTime"].isNull())
result_.invalidTime = resultNode["InvalidTime"].asString();
if(!resultNode["RegisterTime"].isNull())
result_.registerTime = resultNode["RegisterTime"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool CreateEmbedTokenResult::getSuccess()const
{
return success_;
}
CreateEmbedTokenResult::Result CreateEmbedTokenResult::getResult()const
{
return result_;
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::CreateTicketRequest;
CreateTicketRequest::CreateTicketRequest() :
RpcServiceRequest("quickbi-public", "2021-03-25", "CreateTicket")
RpcServiceRequest("quickbi-public", "2022-01-01", "CreateTicket")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::CreateUserGroupRequest;
CreateUserGroupRequest::CreateUserGroupRequest() :
RpcServiceRequest("quickbi-public", "2020-07-31", "CreateUserGroup")
RpcServiceRequest("quickbi-public", "2022-01-01", "CreateUserGroup")
{
setMethod(HttpRequest::Method::Post);
}

84
quickbi-public/src/model/DelayEmbedTokenRequest.cc
View File

@@ -1,84 +0,0 @@
/*
* 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/DelayEmbedTokenRequest.h>
using AlibabaCloud::Quickbi_public::Model::DelayEmbedTokenRequest;
DelayEmbedTokenRequest::DelayEmbedTokenRequest() :
RpcServiceRequest("quickbi-public", "2021-03-25", "DelayEmbedToken")
{
setMethod(HttpRequest::Method::Post);
}
DelayEmbedTokenRequest::~DelayEmbedTokenRequest()
{}
std::string DelayEmbedTokenRequest::getClientToken()const
{
return clientToken_;
}
void DelayEmbedTokenRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DelayEmbedTokenRequest::getAccessPoint()const
{
return accessPoint_;
}
void DelayEmbedTokenRequest::setAccessPoint(const std::string& accessPoint)
{
accessPoint_ = accessPoint;
setParameter("AccessPoint", accessPoint);
}
std::string DelayEmbedTokenRequest::getSignType()const
{
return signType_;
}
void DelayEmbedTokenRequest::setSignType(const std::string& signType)
{
signType_ = signType;
setParameter("SignType", signType);
}
int DelayEmbedTokenRequest::getExpireMin()const
{
return expireMin_;
}
void DelayEmbedTokenRequest::setExpireMin(int expireMin)
{
expireMin_ = expireMin;
setParameter("ExpireMin", std::to_string(expireMin));
}
std::string DelayEmbedTokenRequest::getToken()const
{
return token_;
}
void DelayEmbedTokenRequest::setToken(const std::string& token)
{
token_ = token;
setParameter("Token", token);
}

58
quickbi-public/src/model/DelayEmbedTokenResult.cc
View File

@@ -1,58 +0,0 @@
/*
* 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/DelayEmbedTokenResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
DelayEmbedTokenResult::DelayEmbedTokenResult() :
ServiceResult()
{}
DelayEmbedTokenResult::DelayEmbedTokenResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DelayEmbedTokenResult::~DelayEmbedTokenResult()
{}
void DelayEmbedTokenResult::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 DelayEmbedTokenResult::getSuccess()const
{
return success_;
}
bool DelayEmbedTokenResult::getResult()const
{
return result_;
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::DelayTicketExpireTimeRequest;
DelayTicketExpireTimeRequest::DelayTicketExpireTimeRequest() :
RpcServiceRequest("quickbi-public", "2021-03-25", "DelayTicketExpireTime")
RpcServiceRequest("quickbi-public", "2022-01-01", "DelayTicketExpireTime")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::DeleteDataLevelPermissionRuleUsersRequest;
DeleteDataLevelPermissionRuleUsersRequest::DeleteDataLevelPermissionRuleUsersRequest() :
RpcServiceRequest("quickbi-public", "2020-11-11", "DeleteDataLevelPermissionRuleUsers")
RpcServiceRequest("quickbi-public", "2022-01-01", "DeleteDataLevelPermissionRuleUsers")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::DeleteDataLevelRuleConfigRequest;
DeleteDataLevelRuleConfigRequest::DeleteDataLevelRuleConfigRequest() :
RpcServiceRequest("quickbi-public", "2020-11-11", "DeleteDataLevelRuleConfig")
RpcServiceRequest("quickbi-public", "2022-01-01", "DeleteDataLevelRuleConfig")
{
setMethod(HttpRequest::Method::Post);
}

73
quickbi-public/src/model/DeleteEmbedTokenRequest.cc
View File

@@ -1,73 +0,0 @@
/*
* 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/DeleteEmbedTokenRequest.h>
using AlibabaCloud::Quickbi_public::Model::DeleteEmbedTokenRequest;
DeleteEmbedTokenRequest::DeleteEmbedTokenRequest() :
RpcServiceRequest("quickbi-public", "2021-03-25", "DeleteEmbedToken")
{
setMethod(HttpRequest::Method::Post);
}
DeleteEmbedTokenRequest::~DeleteEmbedTokenRequest()
{}
std::string DeleteEmbedTokenRequest::getClientToken()const
{
return clientToken_;
}
void DeleteEmbedTokenRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string DeleteEmbedTokenRequest::getAccessPoint()const
{
return accessPoint_;
}
void DeleteEmbedTokenRequest::setAccessPoint(const std::string& accessPoint)
{
accessPoint_ = accessPoint;
setParameter("AccessPoint", accessPoint);
}
std::string DeleteEmbedTokenRequest::getSignType()const
{
return signType_;
}
void DeleteEmbedTokenRequest::setSignType(const std::string& signType)
{
signType_ = signType;
setParameter("SignType", signType);
}
std::string DeleteEmbedTokenRequest::getToken()const
{
return token_;
}
void DeleteEmbedTokenRequest::setToken(const std::string& token)
{
token_ = token;
setParameter("Token", token);
}

58
quickbi-public/src/model/DeleteEmbedTokenResult.cc
View File

@@ -1,58 +0,0 @@
/*
* 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/DeleteEmbedTokenResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
DeleteEmbedTokenResult::DeleteEmbedTokenResult() :
ServiceResult()
{}
DeleteEmbedTokenResult::DeleteEmbedTokenResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteEmbedTokenResult::~DeleteEmbedTokenResult()
{}
void DeleteEmbedTokenResult::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 DeleteEmbedTokenResult::getSuccess()const
{
return success_;
}
bool DeleteEmbedTokenResult::getResult()const
{
return result_;
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::DeleteTicketRequest;
DeleteTicketRequest::DeleteTicketRequest() :
RpcServiceRequest("quickbi-public", "2021-03-25", "DeleteTicket")
RpcServiceRequest("quickbi-public", "2022-01-01", "DeleteTicket")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::DeleteUserFromWorkspaceRequest;
DeleteUserFromWorkspaceRequest::DeleteUserFromWorkspaceRequest() :
RpcServiceRequest("quickbi-public", "2020-08-03", "DeleteUserFromWorkspace")
RpcServiceRequest("quickbi-public", "2022-01-01", "DeleteUserFromWorkspace")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -39,10 +39,10 @@ void DeleteUserFromWorkspaceResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["Result"].isNull())
result_ = value["Result"].asString() == "true";
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::DeleteUserGroupMemberRequest;
DeleteUserGroupMemberRequest::DeleteUserGroupMemberRequest() :
RpcServiceRequest("quickbi-public", "2020-07-31", "DeleteUserGroupMember")
RpcServiceRequest("quickbi-public", "2022-01-01", "DeleteUserGroupMember")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::DeleteUserGroupMembersRequest;
DeleteUserGroupMembersRequest::DeleteUserGroupMembersRequest() :
RpcServiceRequest("quickbi-public", "2020-07-31", "DeleteUserGroupMembers")
RpcServiceRequest("quickbi-public", "2022-01-01", "DeleteUserGroupMembers")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::DeleteUserGroupRequest;
DeleteUserGroupRequest::DeleteUserGroupRequest() :
RpcServiceRequest("quickbi-public", "2020-07-31", "DeleteUserGroup")
RpcServiceRequest("quickbi-public", "2022-01-01", "DeleteUserGroup")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::DeleteUserRequest;
DeleteUserRequest::DeleteUserRequest() :
RpcServiceRequest("quickbi-public", "2020-08-01", "DeleteUser")
RpcServiceRequest("quickbi-public", "2022-01-01", "DeleteUser")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::DeleteUserTagMetaRequest;
DeleteUserTagMetaRequest::DeleteUserTagMetaRequest() :
RpcServiceRequest("quickbi-public", "2020-08-02", "DeleteUserTagMeta")
RpcServiceRequest("quickbi-public", "2022-01-01", "DeleteUserTagMeta")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::GetUserGroupInfoRequest;
GetUserGroupInfoRequest::GetUserGroupInfoRequest() :
RpcServiceRequest("quickbi-public", "2020-07-31", "GetUserGroupInfo")
RpcServiceRequest("quickbi-public", "2022-01-01", "GetUserGroupInfo")
{
setMethod(HttpRequest::Method::Post);
}

28
quickbi-public/src/model/GetUserGroupInfoResult.cc
View File

@@ -43,24 +43,24 @@ void GetUserGroupInfoResult::parse(const std::string &payload)
for (auto valueResultData : allResultNode)
{
Data resultObject;
if(!valueResultData["UsergroupId"].isNull())
resultObject.usergroupId = valueResultData["UsergroupId"].asString();
if(!valueResultData["UsergroupName"].isNull())
resultObject.usergroupName = valueResultData["UsergroupName"].asString();
if(!valueResultData["UsergroupDesc"].isNull())
resultObject.usergroupDesc = valueResultData["UsergroupDesc"].asString();
if(!valueResultData["ParentUsergroupId"].isNull())
resultObject.parentUsergroupId = valueResultData["ParentUsergroupId"].asString();
if(!valueResultData["IdentifiedPath"].isNull())
resultObject.identifiedPath = valueResultData["IdentifiedPath"].asString();
if(!valueResultData["CreateUser"].isNull())
resultObject.createUser = valueResultData["CreateUser"].asString();
if(!valueResultData["ModifyUser"].isNull())
resultObject.modifyUser = valueResultData["ModifyUser"].asString();
if(!valueResultData["CreateTime"].isNull())
resultObject.createTime = valueResultData["CreateTime"].asString();
if(!valueResultData["ParentUsergroupId"].isNull())
resultObject.parentUsergroupId = valueResultData["ParentUsergroupId"].asString();
if(!valueResultData["ModifiedTime"].isNull())
resultObject.modifiedTime = valueResultData["ModifiedTime"].asString();
if(!valueResultData["CreateUser"].isNull())
resultObject.createUser = valueResultData["CreateUser"].asString();
if(!valueResultData["UsergroupName"].isNull())
resultObject.usergroupName = valueResultData["UsergroupName"].asString();
if(!valueResultData["CreateTime"].isNull())
resultObject.createTime = valueResultData["CreateTime"].asString();
if(!valueResultData["UsergroupDesc"].isNull())
resultObject.usergroupDesc = valueResultData["UsergroupDesc"].asString();
if(!valueResultData["UsergroupId"].isNull())
resultObject.usergroupId = valueResultData["UsergroupId"].asString();
if(!valueResultData["ModifyUser"].isNull())
resultObject.modifyUser = valueResultData["ModifyUser"].asString();
result_.push_back(resultObject);
}
if(!value["Success"].isNull())

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::ListByUserGroupIdRequest;
ListByUserGroupIdRequest::ListByUserGroupIdRequest() :
RpcServiceRequest("quickbi-public", "2020-07-31", "ListByUserGroupId")
RpcServiceRequest("quickbi-public", "2022-01-01", "ListByUserGroupId")
{
setMethod(HttpRequest::Method::Post);
}

28
quickbi-public/src/model/ListByUserGroupIdResult.cc
View File

@@ -44,24 +44,24 @@ void ListByUserGroupIdResult::parse(const std::string &payload)
for (auto resultNodeUserGroupModelsUserGroupModelsItem : allUserGroupModelsNode)
{
Result::UserGroupModelsItem userGroupModelsItemObject;
if(!resultNodeUserGroupModelsUserGroupModelsItem["UsergroupId"].isNull())
userGroupModelsItemObject.usergroupId = resultNodeUserGroupModelsUserGroupModelsItem["UsergroupId"].asString();
if(!resultNodeUserGroupModelsUserGroupModelsItem["UsergroupName"].isNull())
userGroupModelsItemObject.usergroupName = resultNodeUserGroupModelsUserGroupModelsItem["UsergroupName"].asString();
if(!resultNodeUserGroupModelsUserGroupModelsItem["UsergroupDesc"].isNull())
userGroupModelsItemObject.usergroupDesc = resultNodeUserGroupModelsUserGroupModelsItem["UsergroupDesc"].asString();
if(!resultNodeUserGroupModelsUserGroupModelsItem["ParentUsergroupId"].isNull())
userGroupModelsItemObject.parentUsergroupId = resultNodeUserGroupModelsUserGroupModelsItem["ParentUsergroupId"].asString();
if(!resultNodeUserGroupModelsUserGroupModelsItem["IdentifiedPath"].isNull())
userGroupModelsItemObject.identifiedPath = resultNodeUserGroupModelsUserGroupModelsItem["IdentifiedPath"].asString();
if(!resultNodeUserGroupModelsUserGroupModelsItem["CreateUser"].isNull())
userGroupModelsItemObject.createUser = resultNodeUserGroupModelsUserGroupModelsItem["CreateUser"].asString();
if(!resultNodeUserGroupModelsUserGroupModelsItem["ModifyUser"].isNull())
userGroupModelsItemObject.modifyUser = resultNodeUserGroupModelsUserGroupModelsItem["ModifyUser"].asString();
if(!resultNodeUserGroupModelsUserGroupModelsItem["CreateTime"].isNull())
userGroupModelsItemObject.createTime = resultNodeUserGroupModelsUserGroupModelsItem["CreateTime"].asString();
if(!resultNodeUserGroupModelsUserGroupModelsItem["ParentUsergroupId"].isNull())
userGroupModelsItemObject.parentUsergroupId = resultNodeUserGroupModelsUserGroupModelsItem["ParentUsergroupId"].asString();
if(!resultNodeUserGroupModelsUserGroupModelsItem["ModifiedTime"].isNull())
userGroupModelsItemObject.modifiedTime = resultNodeUserGroupModelsUserGroupModelsItem["ModifiedTime"].asString();
if(!resultNodeUserGroupModelsUserGroupModelsItem["CreateUser"].isNull())
userGroupModelsItemObject.createUser = resultNodeUserGroupModelsUserGroupModelsItem["CreateUser"].asString();
if(!resultNodeUserGroupModelsUserGroupModelsItem["UsergroupName"].isNull())
userGroupModelsItemObject.usergroupName = resultNodeUserGroupModelsUserGroupModelsItem["UsergroupName"].asString();
if(!resultNodeUserGroupModelsUserGroupModelsItem["CreateTime"].isNull())
userGroupModelsItemObject.createTime = resultNodeUserGroupModelsUserGroupModelsItem["CreateTime"].asString();
if(!resultNodeUserGroupModelsUserGroupModelsItem["UsergroupDesc"].isNull())
userGroupModelsItemObject.usergroupDesc = resultNodeUserGroupModelsUserGroupModelsItem["UsergroupDesc"].asString();
if(!resultNodeUserGroupModelsUserGroupModelsItem["UsergroupId"].isNull())
userGroupModelsItemObject.usergroupId = resultNodeUserGroupModelsUserGroupModelsItem["UsergroupId"].asString();
if(!resultNodeUserGroupModelsUserGroupModelsItem["ModifyUser"].isNull())
userGroupModelsItemObject.modifyUser = resultNodeUserGroupModelsUserGroupModelsItem["ModifyUser"].asString();
result_.userGroupModels.push_back(userGroupModelsItemObject);
}
auto allFailedUserGroupIds = resultNode["FailedUserGroupIds"]["FailedUserGroupIds"];

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::ListCollectionsRequest;
ListCollectionsRequest::ListCollectionsRequest() :
RpcServiceRequest("quickbi-public", "2020-08-09", "ListCollections")
RpcServiceRequest("quickbi-public", "2022-01-01", "ListCollections")
{
setMethod(HttpRequest::Method::Post);
}

12
quickbi-public/src/model/ListCollectionsResult.cc
View File

@@ -43,20 +43,20 @@ void ListCollectionsResult::parse(const std::string &payload)
for (auto valueResultData : allResultNode)
{
Data resultObject;
if(!valueResultData["WorkspaceId"].isNull())
resultObject.workspaceId = valueResultData["WorkspaceId"].asString();
if(!valueResultData["WorksType"].isNull())
resultObject.worksType = valueResultData["WorksType"].asString();
if(!valueResultData["FavoriteId"].isNull())
resultObject.favoriteId = std::stoi(valueResultData["FavoriteId"].asString());
if(!valueResultData["OwnerId"].isNull())
resultObject.ownerId = valueResultData["OwnerId"].asString();
if(!valueResultData["WorksId"].isNull())
resultObject.worksId = valueResultData["WorksId"].asString();
if(!valueResultData["WorksName"].isNull())
resultObject.worksName = valueResultData["WorksName"].asString();
if(!valueResultData["WorksType"].isNull())
resultObject.worksType = valueResultData["WorksType"].asString();
if(!valueResultData["WorkspaceId"].isNull())
resultObject.workspaceId = valueResultData["WorkspaceId"].asString();
if(!valueResultData["WorkspaceName"].isNull())
resultObject.workspaceName = valueResultData["WorkspaceName"].asString();
if(!valueResultData["OwnerId"].isNull())
resultObject.ownerId = valueResultData["OwnerId"].asString();
result_.push_back(resultObject);
}
if(!value["Success"].isNull())

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::ListCubeDataLevelPermissionConfigRequest;
ListCubeDataLevelPermissionConfigRequest::ListCubeDataLevelPermissionConfigRequest() :
RpcServiceRequest("quickbi-public", "2020-11-11", "ListCubeDataLevelPermissionConfig")
RpcServiceRequest("quickbi-public", "2022-01-01", "ListCubeDataLevelPermissionConfig")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::ListDataLevelPermissionWhiteListRequest;
ListDataLevelPermissionWhiteListRequest::ListDataLevelPermissionWhiteListRequest() :
RpcServiceRequest("quickbi-public", "2020-11-11", "ListDataLevelPermissionWhiteList")
RpcServiceRequest("quickbi-public", "2022-01-01", "ListDataLevelPermissionWhiteList")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::ListFavoriteReportsRequest;
ListFavoriteReportsRequest::ListFavoriteReportsRequest() :
RpcServiceRequest("quickbi-public", "2020-08-09", "ListFavoriteReports")
RpcServiceRequest("quickbi-public", "2022-01-01", "ListFavoriteReports")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::ListPortalMenuAuthorizationRequest;
ListPortalMenuAuthorizationRequest::ListPortalMenuAuthorizationRequest() :
RpcServiceRequest("quickbi-public", "2020-08-08", "ListPortalMenuAuthorization")
RpcServiceRequest("quickbi-public", "2022-01-01", "ListPortalMenuAuthorization")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -43,10 +43,10 @@ void ListPortalMenuAuthorizationResult::parse(const std::string &payload)
for (auto valueResultData : allResultNode)
{
Data resultObject;
if(!valueResultData["MenuId"].isNull())
resultObject.menuId = valueResultData["MenuId"].asString();
if(!valueResultData["ShowOnlyWithAccess"].isNull())
resultObject.showOnlyWithAccess = valueResultData["ShowOnlyWithAccess"].asString() == "true";
if(!valueResultData["MenuId"].isNull())
resultObject.menuId = valueResultData["MenuId"].asString();
auto allReceiversNode = valueResultData["Receivers"]["ReceiversItem"];
for (auto valueResultDataReceiversReceiversItem : allReceiversNode)
{

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::ListPortalMenusRequest;
ListPortalMenusRequest::ListPortalMenusRequest() :
RpcServiceRequest("quickbi-public", "2020-08-08", "ListPortalMenus")
RpcServiceRequest("quickbi-public", "2022-01-01", "ListPortalMenus")
{
setMethod(HttpRequest::Method::Post);
}

90
quickbi-public/src/model/ListRecentViewReportsRequest.cc
View File

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::ListRecentViewReportsRequest;
ListRecentViewReportsRequest::ListRecentViewReportsRequest() :
RpcServiceRequest("quickbi-public", "2020-08-09", "ListRecentViewReports")
RpcServiceRequest("quickbi-public", "2022-01-01", "ListRecentViewReports")
{
setMethod(HttpRequest::Method::Post);
}
@@ -27,28 +27,6 @@ ListRecentViewReportsRequest::ListRecentViewReportsRequest() :
ListRecentViewReportsRequest::~ListRecentViewReportsRequest()
{}
std::string ListRecentViewReportsRequest::getQueryMode()const
{
return queryMode_;
}
void ListRecentViewReportsRequest::setQueryMode(const std::string& queryMode)
{
queryMode_ = queryMode;
setParameter("QueryMode", queryMode);
}
std::string ListRecentViewReportsRequest::getTreeType()const
{
return treeType_;
}
void ListRecentViewReportsRequest::setTreeType(const std::string& treeType)
{
treeType_ = treeType;
setParameter("TreeType", treeType);
}
std::string ListRecentViewReportsRequest::getAccessPoint()const
{
return accessPoint_;
@@ -60,17 +38,6 @@ void ListRecentViewReportsRequest::setAccessPoint(const std::string& accessPoint
setParameter("AccessPoint", accessPoint);
}
int ListRecentViewReportsRequest::getPageSize()const
{
return pageSize_;
}
void ListRecentViewReportsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string ListRecentViewReportsRequest::getSignType()const
{
return signType_;
@@ -93,17 +60,6 @@ void ListRecentViewReportsRequest::setOffsetDay(int offsetDay)
setParameter("OffsetDay", std::to_string(offsetDay));
}
std::string ListRecentViewReportsRequest::getKeyword()const
{
return keyword_;
}
void ListRecentViewReportsRequest::setKeyword(const std::string& keyword)
{
keyword_ = keyword;
setParameter("Keyword", keyword);
}
std::string ListRecentViewReportsRequest::getUserId()const
{
return userId_;
@@ -115,3 +71,47 @@ void ListRecentViewReportsRequest::setUserId(const std::string& userId)
setParameter("UserId", userId);
}
std::string ListRecentViewReportsRequest::getQueryMode()const
{
return queryMode_;
}
void ListRecentViewReportsRequest::setQueryMode(const std::string& queryMode)
{
queryMode_ = queryMode;
setParameter("QueryMode", queryMode);
}
std::string ListRecentViewReportsRequest::getTreeType()const
{
return treeType_;
}
void ListRecentViewReportsRequest::setTreeType(const std::string& treeType)
{
treeType_ = treeType;
setParameter("TreeType", treeType);
}
int ListRecentViewReportsRequest::getPageSize()const
{
return pageSize_;
}
void ListRecentViewReportsRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string ListRecentViewReportsRequest::getKeyword()const
{
return keyword_;
}
void ListRecentViewReportsRequest::setKeyword(const std::string& keyword)
{
keyword_ = keyword;
setParameter("Keyword", keyword);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::ListSharedReportsRequest;
ListSharedReportsRequest::ListSharedReportsRequest() :
RpcServiceRequest("quickbi-public", "2020-08-09", "ListSharedReports")
RpcServiceRequest("quickbi-public", "2022-01-01", "ListSharedReports")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::ListUserGroupsByUserIdRequest;
ListUserGroupsByUserIdRequest::ListUserGroupsByUserIdRequest() :
RpcServiceRequest("quickbi-public", "2020-07-31", "ListUserGroupsByUserId")
RpcServiceRequest("quickbi-public", "2022-01-01", "ListUserGroupsByUserId")
{
setMethod(HttpRequest::Method::Post);
}

28
quickbi-public/src/model/ListUserGroupsByUserIdResult.cc
View File

@@ -43,24 +43,24 @@ void ListUserGroupsByUserIdResult::parse(const std::string &payload)
for (auto valueResultData : allResultNode)
{
Data resultObject;
if(!valueResultData["UsergroupId"].isNull())
resultObject.usergroupId = valueResultData["UsergroupId"].asString();
if(!valueResultData["UsergroupName"].isNull())
resultObject.usergroupName = valueResultData["UsergroupName"].asString();
if(!valueResultData["UsergroupDesc"].isNull())
resultObject.usergroupDesc = valueResultData["UsergroupDesc"].asString();
if(!valueResultData["ParentUsergroupId"].isNull())
resultObject.parentUsergroupId = valueResultData["ParentUsergroupId"].asString();
if(!valueResultData["IdentifiedPath"].isNull())
resultObject.identifiedPath = valueResultData["IdentifiedPath"].asString();
if(!valueResultData["CreateUser"].isNull())
resultObject.createUser = valueResultData["CreateUser"].asString();
if(!valueResultData["ModifyUser"].isNull())
resultObject.modifyUser = valueResultData["ModifyUser"].asString();
if(!valueResultData["CreateTime"].isNull())
resultObject.createTime = valueResultData["CreateTime"].asString();
if(!valueResultData["ParentUsergroupId"].isNull())
resultObject.parentUsergroupId = valueResultData["ParentUsergroupId"].asString();
if(!valueResultData["ModifiedTime"].isNull())
resultObject.modifiedTime = valueResultData["ModifiedTime"].asString();
if(!valueResultData["CreateUser"].isNull())
resultObject.createUser = valueResultData["CreateUser"].asString();
if(!valueResultData["UsergroupName"].isNull())
resultObject.usergroupName = valueResultData["UsergroupName"].asString();
if(!valueResultData["CreateTime"].isNull())
resultObject.createTime = valueResultData["CreateTime"].asString();
if(!valueResultData["UsergroupDesc"].isNull())
resultObject.usergroupDesc = valueResultData["UsergroupDesc"].asString();
if(!valueResultData["UsergroupId"].isNull())
resultObject.usergroupId = valueResultData["UsergroupId"].asString();
if(!valueResultData["ModifyUser"].isNull())
resultObject.modifyUser = valueResultData["ModifyUser"].asString();
result_.push_back(resultObject);
}
if(!value["Success"].isNull())

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::QueryDataServiceRequest;
QueryDataServiceRequest::QueryDataServiceRequest() :
RpcServiceRequest("quickbi-public", "2020-07-30", "QueryDataService")
RpcServiceRequest("quickbi-public", "2022-01-01", "QueryDataService")
{
setMethod(HttpRequest::Method::Post);
}

8
quickbi-public/src/model/QueryDataServiceResult.cc
View File

@@ -46,18 +46,18 @@ void QueryDataServiceResult::parse(const std::string &payload)
for (auto resultNodeHeadersHeadersItem : allHeadersNode)
{
Result::HeadersItem headersItemObject;
if(!resultNodeHeadersHeadersItem["Label"].isNull())
headersItemObject.label = resultNodeHeadersHeadersItem["Label"].asString();
if(!resultNodeHeadersHeadersItem["Type"].isNull())
headersItemObject.type = resultNodeHeadersHeadersItem["Type"].asString();
if(!resultNodeHeadersHeadersItem["DataType"].isNull())
headersItemObject.dataType = resultNodeHeadersHeadersItem["DataType"].asString();
if(!resultNodeHeadersHeadersItem["Granularity"].isNull())
headersItemObject.granularity = resultNodeHeadersHeadersItem["Granularity"].asString();
if(!resultNodeHeadersHeadersItem["Label"].isNull())
headersItemObject.label = resultNodeHeadersHeadersItem["Label"].asString();
if(!resultNodeHeadersHeadersItem["Column"].isNull())
headersItemObject.column = resultNodeHeadersHeadersItem["Column"].asString();
if(!resultNodeHeadersHeadersItem["Aggregator"].isNull())
headersItemObject.aggregator = resultNodeHeadersHeadersItem["Aggregator"].asString();
if(!resultNodeHeadersHeadersItem["Granularity"].isNull())
headersItemObject.granularity = resultNodeHeadersHeadersItem["Granularity"].asString();
result_.headers.push_back(headersItemObject);
}
auto allValues = resultNode["Values"]["Values"];

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::QueryDatasetDetailInfoRequest;
QueryDatasetDetailInfoRequest::QueryDatasetDetailInfoRequest() :
RpcServiceRequest("quickbi-public", "2020-08-06", "QueryDatasetDetailInfo")
RpcServiceRequest("quickbi-public", "2022-01-01", "QueryDatasetDetailInfo")
{
setMethod(HttpRequest::Method::Post);
}

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

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::QueryDatasetInfoRequest;
QueryDatasetInfoRequest::QueryDatasetInfoRequest() :
RpcServiceRequest("quickbi-public", "2020-08-06", "QueryDatasetInfo")
RpcServiceRequest("quickbi-public", "2022-01-01", "QueryDatasetInfo")
{
setMethod(HttpRequest::Method::Post);
}

46
quickbi-public/src/model/QueryDatasetListRequest.cc
View File

@@ -19,7 +19,7 @@
using AlibabaCloud::Quickbi_public::Model::QueryDatasetListRequest;
QueryDatasetListRequest::QueryDatasetListRequest() :
RpcServiceRequest("quickbi-public", "2020-08-06", "QueryDatasetList")
RpcServiceRequest("quickbi-public", "2022-01-01", "QueryDatasetList")
{
setMethod(HttpRequest::Method::Post);
}
@@ -38,17 +38,6 @@ void QueryDatasetListRequest::setAccessPoint(const std::string& accessPoint)
setParameter("AccessPoint", accessPoint);
}
int QueryDatasetListRequest::getPageSize()const
{
return pageSize_;
}
void QueryDatasetListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string QueryDatasetListRequest::getSignType()const
{
return signType_;
@@ -60,6 +49,28 @@ void QueryDatasetListRequest::setSignType(const std::string& signType)
setParameter("SignType", signType);
}
int QueryDatasetListRequest::getPageNum()const
{
return pageNum_;
}
void QueryDatasetListRequest::setPageNum(int pageNum)
{
pageNum_ = pageNum;
setParameter("PageNum", std::to_string(pageNum));
}
int QueryDatasetListRequest::getPageSize()const
{
return pageSize_;
}
void QueryDatasetListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string QueryDatasetListRequest::getDirectoryId()const
{
return directoryId_;
@@ -93,17 +104,6 @@ void QueryDatasetListRequest::setKeyword(const std::string& keyword)
setParameter("Keyword", keyword);
}
int QueryDatasetListRequest::getPageNum()const
{
return pageNum_;
}
void QueryDatasetListRequest::setPageNum(int pageNum)
{
pageNum_ = pageNum;
setParameter("PageNum", std::to_string(pageNum));
}
std::string QueryDatasetListRequest::getWorkspaceId()const
{
return workspaceId_;

Some files were not shown because too many files have changed in this diff Show More