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

Add some APIs.

Browse Source
This commit is contained in:
sdk-team
2025-09-11 06:41:57 +00:00
parent 1d3414a920
commit 9d5401c5cc
36 changed files with 2272 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.2105
1.36.2106

32
quickbi-public/CMakeLists.txt
View File

@@ -25,6 +25,8 @@ set(quickbi-public_public_header_model
include/alibabacloud/quickbi-public/model/AddDataLevelPermissionRuleUsersResult.h
include/alibabacloud/quickbi-public/model/AddDataLevelPermissionWhiteListRequest.h
include/alibabacloud/quickbi-public/model/AddDataLevelPermissionWhiteListResult.h
include/alibabacloud/quickbi-public/model/AddDataSourceRequest.h
include/alibabacloud/quickbi-public/model/AddDataSourceResult.h
include/alibabacloud/quickbi-public/model/AddShareReportRequest.h
include/alibabacloud/quickbi-public/model/AddShareReportResult.h
include/alibabacloud/quickbi-public/model/AddUserRequest.h
@@ -53,8 +55,16 @@ set(quickbi-public_public_header_model
include/alibabacloud/quickbi-public/model/CancelReportShareResult.h
include/alibabacloud/quickbi-public/model/ChangeVisibilityModelRequest.h
include/alibabacloud/quickbi-public/model/ChangeVisibilityModelResult.h
include/alibabacloud/quickbi-public/model/CheckDatasetExistedRequest.h
include/alibabacloud/quickbi-public/model/CheckDatasetExistedResult.h
include/alibabacloud/quickbi-public/model/CheckOrganizationMemberRequest.h
include/alibabacloud/quickbi-public/model/CheckOrganizationMemberResult.h
include/alibabacloud/quickbi-public/model/CheckReadableRequest.h
include/alibabacloud/quickbi-public/model/CheckReadableResult.h
include/alibabacloud/quickbi-public/model/CreateCubeBySqlRequest.h
include/alibabacloud/quickbi-public/model/CreateCubeBySqlResult.h
include/alibabacloud/quickbi-public/model/CreateDatasetRequest.h
include/alibabacloud/quickbi-public/model/CreateDatasetResult.h
include/alibabacloud/quickbi-public/model/CreateTicketRequest.h
include/alibabacloud/quickbi-public/model/CreateTicketResult.h
include/alibabacloud/quickbi-public/model/CreateTicket4CopilotRequest.h
@@ -127,6 +137,8 @@ set(quickbi-public_public_header_model
include/alibabacloud/quickbi-public/model/ListWorkspaceRoleUsersResult.h
include/alibabacloud/quickbi-public/model/ListWorkspaceRolesRequest.h
include/alibabacloud/quickbi-public/model/ListWorkspaceRolesResult.h
include/alibabacloud/quickbi-public/model/ListWorkspaceUserRolesByUserIdRequest.h
include/alibabacloud/quickbi-public/model/ListWorkspaceUserRolesByUserIdResult.h
include/alibabacloud/quickbi-public/model/ManualRunMailTaskRequest.h
include/alibabacloud/quickbi-public/model/ManualRunMailTaskResult.h
include/alibabacloud/quickbi-public/model/ModifyApiDatasourceParametersRequest.h
@@ -235,8 +247,12 @@ set(quickbi-public_public_header_model
include/alibabacloud/quickbi-public/model/SmartqAuthorizeResult.h
include/alibabacloud/quickbi-public/model/SmartqQueryAbilityRequest.h
include/alibabacloud/quickbi-public/model/SmartqQueryAbilityResult.h
include/alibabacloud/quickbi-public/model/UpdateCubeBySqlRequest.h
include/alibabacloud/quickbi-public/model/UpdateCubeBySqlResult.h
include/alibabacloud/quickbi-public/model/UpdateDataLevelPermissionStatusRequest.h
include/alibabacloud/quickbi-public/model/UpdateDataLevelPermissionStatusResult.h
include/alibabacloud/quickbi-public/model/UpdateDataSourceRequest.h
include/alibabacloud/quickbi-public/model/UpdateDataSourceResult.h
include/alibabacloud/quickbi-public/model/UpdateEmbeddedStatusRequest.h
include/alibabacloud/quickbi-public/model/UpdateEmbeddedStatusResult.h
include/alibabacloud/quickbi-public/model/UpdateTicketNumRequest.h
@@ -262,6 +278,8 @@ set(quickbi-public_src
src/model/AddDataLevelPermissionRuleUsersResult.cc
src/model/AddDataLevelPermissionWhiteListRequest.cc
src/model/AddDataLevelPermissionWhiteListResult.cc
src/model/AddDataSourceRequest.cc
src/model/AddDataSourceResult.cc
src/model/AddShareReportRequest.cc
src/model/AddShareReportResult.cc
src/model/AddUserRequest.cc
@@ -290,8 +308,16 @@ set(quickbi-public_src
src/model/CancelReportShareResult.cc
src/model/ChangeVisibilityModelRequest.cc
src/model/ChangeVisibilityModelResult.cc
src/model/CheckDatasetExistedRequest.cc
src/model/CheckDatasetExistedResult.cc
src/model/CheckOrganizationMemberRequest.cc
src/model/CheckOrganizationMemberResult.cc
src/model/CheckReadableRequest.cc
src/model/CheckReadableResult.cc
src/model/CreateCubeBySqlRequest.cc
src/model/CreateCubeBySqlResult.cc
src/model/CreateDatasetRequest.cc
src/model/CreateDatasetResult.cc
src/model/CreateTicketRequest.cc
src/model/CreateTicketResult.cc
src/model/CreateTicket4CopilotRequest.cc
@@ -364,6 +390,8 @@ set(quickbi-public_src
src/model/ListWorkspaceRoleUsersResult.cc
src/model/ListWorkspaceRolesRequest.cc
src/model/ListWorkspaceRolesResult.cc
src/model/ListWorkspaceUserRolesByUserIdRequest.cc
src/model/ListWorkspaceUserRolesByUserIdResult.cc
src/model/ManualRunMailTaskRequest.cc
src/model/ManualRunMailTaskResult.cc
src/model/ModifyApiDatasourceParametersRequest.cc
@@ -472,8 +500,12 @@ set(quickbi-public_src
src/model/SmartqAuthorizeResult.cc
src/model/SmartqQueryAbilityRequest.cc
src/model/SmartqQueryAbilityResult.cc
src/model/UpdateCubeBySqlRequest.cc
src/model/UpdateCubeBySqlResult.cc
src/model/UpdateDataLevelPermissionStatusRequest.cc
src/model/UpdateDataLevelPermissionStatusResult.cc
src/model/UpdateDataSourceRequest.cc
src/model/UpdateDataSourceResult.cc
src/model/UpdateEmbeddedStatusRequest.cc
src/model/UpdateEmbeddedStatusResult.cc
src/model/UpdateTicketNumRequest.cc

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

@@ -26,6 +26,8 @@
#include "model/AddDataLevelPermissionRuleUsersResult.h"
#include "model/AddDataLevelPermissionWhiteListRequest.h"
#include "model/AddDataLevelPermissionWhiteListResult.h"
#include "model/AddDataSourceRequest.h"
#include "model/AddDataSourceResult.h"
#include "model/AddShareReportRequest.h"
#include "model/AddShareReportResult.h"
#include "model/AddUserRequest.h"
@@ -54,8 +56,16 @@
#include "model/CancelReportShareResult.h"
#include "model/ChangeVisibilityModelRequest.h"
#include "model/ChangeVisibilityModelResult.h"
#include "model/CheckDatasetExistedRequest.h"
#include "model/CheckDatasetExistedResult.h"
#include "model/CheckOrganizationMemberRequest.h"
#include "model/CheckOrganizationMemberResult.h"
#include "model/CheckReadableRequest.h"
#include "model/CheckReadableResult.h"
#include "model/CreateCubeBySqlRequest.h"
#include "model/CreateCubeBySqlResult.h"
#include "model/CreateDatasetRequest.h"
#include "model/CreateDatasetResult.h"
#include "model/CreateTicketRequest.h"
#include "model/CreateTicketResult.h"
#include "model/CreateTicket4CopilotRequest.h"
@@ -128,6 +138,8 @@
#include "model/ListWorkspaceRoleUsersResult.h"
#include "model/ListWorkspaceRolesRequest.h"
#include "model/ListWorkspaceRolesResult.h"
#include "model/ListWorkspaceUserRolesByUserIdRequest.h"
#include "model/ListWorkspaceUserRolesByUserIdResult.h"
#include "model/ManualRunMailTaskRequest.h"
#include "model/ManualRunMailTaskResult.h"
#include "model/ModifyApiDatasourceParametersRequest.h"
@@ -236,8 +248,12 @@
#include "model/SmartqAuthorizeResult.h"
#include "model/SmartqQueryAbilityRequest.h"
#include "model/SmartqQueryAbilityResult.h"
#include "model/UpdateCubeBySqlRequest.h"
#include "model/UpdateCubeBySqlResult.h"
#include "model/UpdateDataLevelPermissionStatusRequest.h"
#include "model/UpdateDataLevelPermissionStatusResult.h"
#include "model/UpdateDataSourceRequest.h"
#include "model/UpdateDataSourceResult.h"
#include "model/UpdateEmbeddedStatusRequest.h"
#include "model/UpdateEmbeddedStatusResult.h"
#include "model/UpdateTicketNumRequest.h"
@@ -271,6 +287,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::AddDataLevelPermissionWhiteListResult> AddDataLevelPermissionWhiteListOutcome;
typedef std::future<AddDataLevelPermissionWhiteListOutcome> AddDataLevelPermissionWhiteListOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::AddDataLevelPermissionWhiteListRequest&, const AddDataLevelPermissionWhiteListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddDataLevelPermissionWhiteListAsyncHandler;
typedef Outcome<Error, Model::AddDataSourceResult> AddDataSourceOutcome;
typedef std::future<AddDataSourceOutcome> AddDataSourceOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::AddDataSourceRequest&, const AddDataSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddDataSourceAsyncHandler;
typedef Outcome<Error, Model::AddShareReportResult> AddShareReportOutcome;
typedef std::future<AddShareReportOutcome> AddShareReportOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::AddShareReportRequest&, const AddShareReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddShareReportAsyncHandler;
@@ -313,9 +332,21 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ChangeVisibilityModelResult> ChangeVisibilityModelOutcome;
typedef std::future<ChangeVisibilityModelOutcome> ChangeVisibilityModelOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::ChangeVisibilityModelRequest&, const ChangeVisibilityModelOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ChangeVisibilityModelAsyncHandler;
typedef Outcome<Error, Model::CheckDatasetExistedResult> CheckDatasetExistedOutcome;
typedef std::future<CheckDatasetExistedOutcome> CheckDatasetExistedOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::CheckDatasetExistedRequest&, const CheckDatasetExistedOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckDatasetExistedAsyncHandler;
typedef Outcome<Error, Model::CheckOrganizationMemberResult> CheckOrganizationMemberOutcome;
typedef std::future<CheckOrganizationMemberOutcome> CheckOrganizationMemberOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::CheckOrganizationMemberRequest&, const CheckOrganizationMemberOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckOrganizationMemberAsyncHandler;
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::CreateCubeBySqlResult> CreateCubeBySqlOutcome;
typedef std::future<CreateCubeBySqlOutcome> CreateCubeBySqlOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::CreateCubeBySqlRequest&, const CreateCubeBySqlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCubeBySqlAsyncHandler;
typedef Outcome<Error, Model::CreateDatasetResult> CreateDatasetOutcome;
typedef std::future<CreateDatasetOutcome> CreateDatasetOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::CreateDatasetRequest&, const CreateDatasetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDatasetAsyncHandler;
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;
@@ -424,6 +455,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ListWorkspaceRolesResult> ListWorkspaceRolesOutcome;
typedef std::future<ListWorkspaceRolesOutcome> ListWorkspaceRolesOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::ListWorkspaceRolesRequest&, const ListWorkspaceRolesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListWorkspaceRolesAsyncHandler;
typedef Outcome<Error, Model::ListWorkspaceUserRolesByUserIdResult> ListWorkspaceUserRolesByUserIdOutcome;
typedef std::future<ListWorkspaceUserRolesByUserIdOutcome> ListWorkspaceUserRolesByUserIdOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::ListWorkspaceUserRolesByUserIdRequest&, const ListWorkspaceUserRolesByUserIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListWorkspaceUserRolesByUserIdAsyncHandler;
typedef Outcome<Error, Model::ManualRunMailTaskResult> ManualRunMailTaskOutcome;
typedef std::future<ManualRunMailTaskOutcome> ManualRunMailTaskOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::ManualRunMailTaskRequest&, const ManualRunMailTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ManualRunMailTaskAsyncHandler;
@@ -586,9 +620,15 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::SmartqQueryAbilityResult> SmartqQueryAbilityOutcome;
typedef std::future<SmartqQueryAbilityOutcome> SmartqQueryAbilityOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::SmartqQueryAbilityRequest&, const SmartqQueryAbilityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SmartqQueryAbilityAsyncHandler;
typedef Outcome<Error, Model::UpdateCubeBySqlResult> UpdateCubeBySqlOutcome;
typedef std::future<UpdateCubeBySqlOutcome> UpdateCubeBySqlOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::UpdateCubeBySqlRequest&, const UpdateCubeBySqlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateCubeBySqlAsyncHandler;
typedef Outcome<Error, Model::UpdateDataLevelPermissionStatusResult> UpdateDataLevelPermissionStatusOutcome;
typedef std::future<UpdateDataLevelPermissionStatusOutcome> UpdateDataLevelPermissionStatusOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::UpdateDataLevelPermissionStatusRequest&, const UpdateDataLevelPermissionStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateDataLevelPermissionStatusAsyncHandler;
typedef Outcome<Error, Model::UpdateDataSourceResult> UpdateDataSourceOutcome;
typedef std::future<UpdateDataSourceOutcome> UpdateDataSourceOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::UpdateDataSourceRequest&, const UpdateDataSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateDataSourceAsyncHandler;
typedef Outcome<Error, Model::UpdateEmbeddedStatusResult> UpdateEmbeddedStatusOutcome;
typedef std::future<UpdateEmbeddedStatusOutcome> UpdateEmbeddedStatusOutcomeCallable;
typedef std::function<void(const Quickbi_publicClient*, const Model::UpdateEmbeddedStatusRequest&, const UpdateEmbeddedStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateEmbeddedStatusAsyncHandler;
@@ -627,6 +667,9 @@ namespace AlibabaCloud
AddDataLevelPermissionWhiteListOutcome addDataLevelPermissionWhiteList(const Model::AddDataLevelPermissionWhiteListRequest &request)const;
void addDataLevelPermissionWhiteListAsync(const Model::AddDataLevelPermissionWhiteListRequest& request, const AddDataLevelPermissionWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddDataLevelPermissionWhiteListOutcomeCallable addDataLevelPermissionWhiteListCallable(const Model::AddDataLevelPermissionWhiteListRequest& request) const;
AddDataSourceOutcome addDataSource(const Model::AddDataSourceRequest &request)const;
void addDataSourceAsync(const Model::AddDataSourceRequest& request, const AddDataSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddDataSourceOutcomeCallable addDataSourceCallable(const Model::AddDataSourceRequest& request) const;
AddShareReportOutcome addShareReport(const Model::AddShareReportRequest &request)const;
void addShareReportAsync(const Model::AddShareReportRequest& request, const AddShareReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddShareReportOutcomeCallable addShareReportCallable(const Model::AddShareReportRequest& request) const;
@@ -669,9 +712,21 @@ namespace AlibabaCloud
ChangeVisibilityModelOutcome changeVisibilityModel(const Model::ChangeVisibilityModelRequest &request)const;
void changeVisibilityModelAsync(const Model::ChangeVisibilityModelRequest& request, const ChangeVisibilityModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ChangeVisibilityModelOutcomeCallable changeVisibilityModelCallable(const Model::ChangeVisibilityModelRequest& request) const;
CheckDatasetExistedOutcome checkDatasetExisted(const Model::CheckDatasetExistedRequest &request)const;
void checkDatasetExistedAsync(const Model::CheckDatasetExistedRequest& request, const CheckDatasetExistedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckDatasetExistedOutcomeCallable checkDatasetExistedCallable(const Model::CheckDatasetExistedRequest& request) const;
CheckOrganizationMemberOutcome checkOrganizationMember(const Model::CheckOrganizationMemberRequest &request)const;
void checkOrganizationMemberAsync(const Model::CheckOrganizationMemberRequest& request, const CheckOrganizationMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckOrganizationMemberOutcomeCallable checkOrganizationMemberCallable(const Model::CheckOrganizationMemberRequest& request) const;
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;
CreateCubeBySqlOutcome createCubeBySql(const Model::CreateCubeBySqlRequest &request)const;
void createCubeBySqlAsync(const Model::CreateCubeBySqlRequest& request, const CreateCubeBySqlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateCubeBySqlOutcomeCallable createCubeBySqlCallable(const Model::CreateCubeBySqlRequest& request) const;
CreateDatasetOutcome createDataset(const Model::CreateDatasetRequest &request)const;
void createDatasetAsync(const Model::CreateDatasetRequest& request, const CreateDatasetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDatasetOutcomeCallable createDatasetCallable(const Model::CreateDatasetRequest& 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;
@@ -780,6 +835,9 @@ namespace AlibabaCloud
ListWorkspaceRolesOutcome listWorkspaceRoles(const Model::ListWorkspaceRolesRequest &request)const;
void listWorkspaceRolesAsync(const Model::ListWorkspaceRolesRequest& request, const ListWorkspaceRolesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListWorkspaceRolesOutcomeCallable listWorkspaceRolesCallable(const Model::ListWorkspaceRolesRequest& request) const;
ListWorkspaceUserRolesByUserIdOutcome listWorkspaceUserRolesByUserId(const Model::ListWorkspaceUserRolesByUserIdRequest &request)const;
void listWorkspaceUserRolesByUserIdAsync(const Model::ListWorkspaceUserRolesByUserIdRequest& request, const ListWorkspaceUserRolesByUserIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListWorkspaceUserRolesByUserIdOutcomeCallable listWorkspaceUserRolesByUserIdCallable(const Model::ListWorkspaceUserRolesByUserIdRequest& request) const;
ManualRunMailTaskOutcome manualRunMailTask(const Model::ManualRunMailTaskRequest &request)const;
void manualRunMailTaskAsync(const Model::ManualRunMailTaskRequest& request, const ManualRunMailTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ManualRunMailTaskOutcomeCallable manualRunMailTaskCallable(const Model::ManualRunMailTaskRequest& request) const;
@@ -942,9 +1000,15 @@ namespace AlibabaCloud
SmartqQueryAbilityOutcome smartqQueryAbility(const Model::SmartqQueryAbilityRequest &request)const;
void smartqQueryAbilityAsync(const Model::SmartqQueryAbilityRequest& request, const SmartqQueryAbilityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SmartqQueryAbilityOutcomeCallable smartqQueryAbilityCallable(const Model::SmartqQueryAbilityRequest& request) const;
UpdateCubeBySqlOutcome updateCubeBySql(const Model::UpdateCubeBySqlRequest &request)const;
void updateCubeBySqlAsync(const Model::UpdateCubeBySqlRequest& request, const UpdateCubeBySqlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateCubeBySqlOutcomeCallable updateCubeBySqlCallable(const Model::UpdateCubeBySqlRequest& request) const;
UpdateDataLevelPermissionStatusOutcome updateDataLevelPermissionStatus(const Model::UpdateDataLevelPermissionStatusRequest &request)const;
void updateDataLevelPermissionStatusAsync(const Model::UpdateDataLevelPermissionStatusRequest& request, const UpdateDataLevelPermissionStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateDataLevelPermissionStatusOutcomeCallable updateDataLevelPermissionStatusCallable(const Model::UpdateDataLevelPermissionStatusRequest& request) const;
UpdateDataSourceOutcome updateDataSource(const Model::UpdateDataSourceRequest &request)const;
void updateDataSourceAsync(const Model::UpdateDataSourceRequest& request, const UpdateDataSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateDataSourceOutcomeCallable updateDataSourceCallable(const Model::UpdateDataSourceRequest& request) const;
UpdateEmbeddedStatusOutcome updateEmbeddedStatus(const Model::UpdateEmbeddedStatusRequest &request)const;
void updateEmbeddedStatusAsync(const Model::UpdateEmbeddedStatusRequest& request, const UpdateEmbeddedStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateEmbeddedStatusOutcomeCallable updateEmbeddedStatusCallable(const Model::UpdateEmbeddedStatusRequest& request) const;

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

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

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

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_ADDDATASOURCERESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_ADDDATASOURCERESULT_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 AddDataSourceResult : public ServiceResult
{
public:
AddDataSourceResult();
explicit AddDataSourceResult(const std::string &payload);
~AddDataSourceResult();
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_ADDDATASOURCERESULT_H_

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

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

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

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CHECKDATASETEXISTEDRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CHECKDATASETEXISTEDRESULT_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 CheckDatasetExistedResult : public ServiceResult
{
public:
CheckDatasetExistedResult();
explicit CheckDatasetExistedResult(const std::string &payload);
~CheckDatasetExistedResult();
bool getSuccess()const;
bool getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
bool result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CHECKDATASETEXISTEDRESULT_H_

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

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

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

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CHECKORGANIZATIONMEMBERRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CHECKORGANIZATIONMEMBERRESULT_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 CheckOrganizationMemberResult : public ServiceResult
{
public:
CheckOrganizationMemberResult();
explicit CheckOrganizationMemberResult(const std::string &payload);
~CheckOrganizationMemberResult();
bool getSuccess()const;
bool getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
bool result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CHECKORGANIZATIONMEMBERRESULT_H_

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

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

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

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATECUBEBYSQLRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATECUBEBYSQLRESULT_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 CreateCubeBySqlResult : public ServiceResult
{
public:
CreateCubeBySqlResult();
explicit CreateCubeBySqlResult(const std::string &payload);
~CreateCubeBySqlResult();
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_CREATECUBEBYSQLRESULT_H_

63
quickbi-public/include/alibabacloud/quickbi-public/model/CreateDatasetRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEDATASETREQUEST_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEDATASETREQUEST_H_
#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Quickbi_public {
namespace Model {
class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT CreateDatasetRequest : public RpcServiceRequest {
public:
CreateDatasetRequest();
~CreateDatasetRequest();
std::string getDsId() const;
void setDsId(const std::string &dsId);
std::string getAccessPoint() const;
void setAccessPoint(const std::string &accessPoint);
std::string getUserId() const;
void setUserId(const std::string &userId);
std::string getTableName() const;
void setTableName(const std::string &tableName);
std::string getTargetDirectoryId() const;
void setTargetDirectoryId(const std::string &targetDirectoryId);
std::string getSignType() const;
void setSignType(const std::string &signType);
std::string getUserDefineCubeName() const;
void setUserDefineCubeName(const std::string &userDefineCubeName);
std::string getWorkspaceId() const;
void setWorkspaceId(const std::string &workspaceId);
private:
std::string dsId_;
std::string accessPoint_;
std::string userId_;
std::string tableName_;
std::string targetDirectoryId_;
std::string signType_;
std::string userDefineCubeName_;
std::string workspaceId_;
};
} // namespace Model
} // namespace Quickbi_public
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEDATASETREQUEST_H_

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

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEDATASETRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_CREATEDATASETRESULT_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 CreateDatasetResult : public ServiceResult
{
public:
CreateDatasetResult();
explicit CreateDatasetResult(const std::string &payload);
~CreateDatasetResult();
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_CREATEDATASETRESULT_H_

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

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

65
quickbi-public/include/alibabacloud/quickbi-public/model/ListWorkspaceUserRolesByUserIdResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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_LISTWORKSPACEUSERROLESBYUSERIDRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTWORKSPACEUSERROLESBYUSERIDRESULT_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 ListWorkspaceUserRolesByUserIdResult : public ServiceResult
{
public:
struct Data
{
struct RoleModel
{
std::string roleName;
std::string roleId;
std::string roleCode;
};
std::string workspaceId;
std::string workspaceName;
RoleModel roleModel;
};
ListWorkspaceUserRolesByUserIdResult();
explicit ListWorkspaceUserRolesByUserIdResult(const std::string &payload);
~ListWorkspaceUserRolesByUserIdResult();
bool getSuccess()const;
std::vector<Data> getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
std::vector<Data> result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_LISTWORKSPACEUSERROLESBYUSERIDRESULT_H_

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

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

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

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_UPDATECUBEBYSQLRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_UPDATECUBEBYSQLRESULT_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 UpdateCubeBySqlResult : public ServiceResult
{
public:
UpdateCubeBySqlResult();
explicit UpdateCubeBySqlResult(const std::string &payload);
~UpdateCubeBySqlResult();
bool getSuccess()const;
bool getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
bool result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_UPDATECUBEBYSQLRESULT_H_

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

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

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

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_UPDATEDATASOURCERESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_UPDATEDATASOURCERESULT_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 UpdateDataSourceResult : public ServiceResult
{
public:
UpdateDataSourceResult();
explicit UpdateDataSourceResult(const std::string &payload);
~UpdateDataSourceResult();
bool getSuccess()const;
bool getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
bool result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_UPDATEDATASOURCERESULT_H_

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

@@ -123,6 +123,42 @@ Quickbi_publicClient::AddDataLevelPermissionWhiteListOutcomeCallable Quickbi_pub
return task->get_future();
}
Quickbi_publicClient::AddDataSourceOutcome Quickbi_publicClient::addDataSource(const AddDataSourceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddDataSourceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddDataSourceOutcome(AddDataSourceResult(outcome.result()));
else
return AddDataSourceOutcome(outcome.error());
}
void Quickbi_publicClient::addDataSourceAsync(const AddDataSourceRequest& request, const AddDataSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addDataSource(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::AddDataSourceOutcomeCallable Quickbi_publicClient::addDataSourceCallable(const AddDataSourceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddDataSourceOutcome()>>(
[this, request]()
{
return this->addDataSource(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::AddShareReportOutcome Quickbi_publicClient::addShareReport(const AddShareReportRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -627,6 +663,78 @@ Quickbi_publicClient::ChangeVisibilityModelOutcomeCallable Quickbi_publicClient:
return task->get_future();
}
Quickbi_publicClient::CheckDatasetExistedOutcome Quickbi_publicClient::checkDatasetExisted(const CheckDatasetExistedRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CheckDatasetExistedOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CheckDatasetExistedOutcome(CheckDatasetExistedResult(outcome.result()));
else
return CheckDatasetExistedOutcome(outcome.error());
}
void Quickbi_publicClient::checkDatasetExistedAsync(const CheckDatasetExistedRequest& request, const CheckDatasetExistedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, checkDatasetExisted(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::CheckDatasetExistedOutcomeCallable Quickbi_publicClient::checkDatasetExistedCallable(const CheckDatasetExistedRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CheckDatasetExistedOutcome()>>(
[this, request]()
{
return this->checkDatasetExisted(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::CheckOrganizationMemberOutcome Quickbi_publicClient::checkOrganizationMember(const CheckOrganizationMemberRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CheckOrganizationMemberOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CheckOrganizationMemberOutcome(CheckOrganizationMemberResult(outcome.result()));
else
return CheckOrganizationMemberOutcome(outcome.error());
}
void Quickbi_publicClient::checkOrganizationMemberAsync(const CheckOrganizationMemberRequest& request, const CheckOrganizationMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, checkOrganizationMember(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::CheckOrganizationMemberOutcomeCallable Quickbi_publicClient::checkOrganizationMemberCallable(const CheckOrganizationMemberRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CheckOrganizationMemberOutcome()>>(
[this, request]()
{
return this->checkOrganizationMember(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::CheckReadableOutcome Quickbi_publicClient::checkReadable(const CheckReadableRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -663,6 +771,78 @@ Quickbi_publicClient::CheckReadableOutcomeCallable Quickbi_publicClient::checkRe
return task->get_future();
}
Quickbi_publicClient::CreateCubeBySqlOutcome Quickbi_publicClient::createCubeBySql(const CreateCubeBySqlRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateCubeBySqlOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateCubeBySqlOutcome(CreateCubeBySqlResult(outcome.result()));
else
return CreateCubeBySqlOutcome(outcome.error());
}
void Quickbi_publicClient::createCubeBySqlAsync(const CreateCubeBySqlRequest& request, const CreateCubeBySqlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createCubeBySql(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::CreateCubeBySqlOutcomeCallable Quickbi_publicClient::createCubeBySqlCallable(const CreateCubeBySqlRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateCubeBySqlOutcome()>>(
[this, request]()
{
return this->createCubeBySql(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::CreateDatasetOutcome Quickbi_publicClient::createDataset(const CreateDatasetRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDatasetOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDatasetOutcome(CreateDatasetResult(outcome.result()));
else
return CreateDatasetOutcome(outcome.error());
}
void Quickbi_publicClient::createDatasetAsync(const CreateDatasetRequest& request, const CreateDatasetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDataset(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::CreateDatasetOutcomeCallable Quickbi_publicClient::createDatasetCallable(const CreateDatasetRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDatasetOutcome()>>(
[this, request]()
{
return this->createDataset(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::CreateTicketOutcome Quickbi_publicClient::createTicket(const CreateTicketRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1959,6 +2139,42 @@ Quickbi_publicClient::ListWorkspaceRolesOutcomeCallable Quickbi_publicClient::li
return task->get_future();
}
Quickbi_publicClient::ListWorkspaceUserRolesByUserIdOutcome Quickbi_publicClient::listWorkspaceUserRolesByUserId(const ListWorkspaceUserRolesByUserIdRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListWorkspaceUserRolesByUserIdOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListWorkspaceUserRolesByUserIdOutcome(ListWorkspaceUserRolesByUserIdResult(outcome.result()));
else
return ListWorkspaceUserRolesByUserIdOutcome(outcome.error());
}
void Quickbi_publicClient::listWorkspaceUserRolesByUserIdAsync(const ListWorkspaceUserRolesByUserIdRequest& request, const ListWorkspaceUserRolesByUserIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listWorkspaceUserRolesByUserId(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::ListWorkspaceUserRolesByUserIdOutcomeCallable Quickbi_publicClient::listWorkspaceUserRolesByUserIdCallable(const ListWorkspaceUserRolesByUserIdRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListWorkspaceUserRolesByUserIdOutcome()>>(
[this, request]()
{
return this->listWorkspaceUserRolesByUserId(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::ManualRunMailTaskOutcome Quickbi_publicClient::manualRunMailTask(const ManualRunMailTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3903,6 +4119,42 @@ Quickbi_publicClient::SmartqQueryAbilityOutcomeCallable Quickbi_publicClient::sm
return task->get_future();
}
Quickbi_publicClient::UpdateCubeBySqlOutcome Quickbi_publicClient::updateCubeBySql(const UpdateCubeBySqlRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateCubeBySqlOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateCubeBySqlOutcome(UpdateCubeBySqlResult(outcome.result()));
else
return UpdateCubeBySqlOutcome(outcome.error());
}
void Quickbi_publicClient::updateCubeBySqlAsync(const UpdateCubeBySqlRequest& request, const UpdateCubeBySqlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateCubeBySql(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::UpdateCubeBySqlOutcomeCallable Quickbi_publicClient::updateCubeBySqlCallable(const UpdateCubeBySqlRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateCubeBySqlOutcome()>>(
[this, request]()
{
return this->updateCubeBySql(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::UpdateDataLevelPermissionStatusOutcome Quickbi_publicClient::updateDataLevelPermissionStatus(const UpdateDataLevelPermissionStatusRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3939,6 +4191,42 @@ Quickbi_publicClient::UpdateDataLevelPermissionStatusOutcomeCallable Quickbi_pub
return task->get_future();
}
Quickbi_publicClient::UpdateDataSourceOutcome Quickbi_publicClient::updateDataSource(const UpdateDataSourceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateDataSourceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateDataSourceOutcome(UpdateDataSourceResult(outcome.result()));
else
return UpdateDataSourceOutcome(outcome.error());
}
void Quickbi_publicClient::updateDataSourceAsync(const UpdateDataSourceRequest& request, const UpdateDataSourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateDataSource(request), context);
};
asyncExecute(new Runnable(fn));
}
Quickbi_publicClient::UpdateDataSourceOutcomeCallable Quickbi_publicClient::updateDataSourceCallable(const UpdateDataSourceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateDataSourceOutcome()>>(
[this, request]()
{
return this->updateDataSource(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Quickbi_publicClient::UpdateEmbeddedStatusOutcome Quickbi_publicClient::updateEmbeddedStatus(const UpdateEmbeddedStatusRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

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

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

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

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/quickbi-public/model/AddDataSourceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
AddDataSourceResult::AddDataSourceResult() :
ServiceResult()
{}
AddDataSourceResult::AddDataSourceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AddDataSourceResult::~AddDataSourceResult()
{}
void AddDataSourceResult::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 AddDataSourceResult::getSuccess()const
{
return success_;
}
std::string AddDataSourceResult::getResult()const
{
return result_;
}

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

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

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

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/quickbi-public/model/CheckDatasetExistedResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
CheckDatasetExistedResult::CheckDatasetExistedResult() :
ServiceResult()
{}
CheckDatasetExistedResult::CheckDatasetExistedResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CheckDatasetExistedResult::~CheckDatasetExistedResult()
{}
void CheckDatasetExistedResult::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 CheckDatasetExistedResult::getSuccess()const
{
return success_;
}
bool CheckDatasetExistedResult::getResult()const
{
return result_;
}

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

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

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

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/quickbi-public/model/CheckOrganizationMemberResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
CheckOrganizationMemberResult::CheckOrganizationMemberResult() :
ServiceResult()
{}
CheckOrganizationMemberResult::CheckOrganizationMemberResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CheckOrganizationMemberResult::~CheckOrganizationMemberResult()
{}
void CheckOrganizationMemberResult::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 CheckOrganizationMemberResult::getSuccess()const
{
return success_;
}
bool CheckOrganizationMemberResult::getResult()const
{
return result_;
}

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

@@ -0,0 +1,90 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/quickbi-public/model/CreateCubeBySqlRequest.h>
using AlibabaCloud::Quickbi_public::Model::CreateCubeBySqlRequest;
CreateCubeBySqlRequest::CreateCubeBySqlRequest()
: RpcServiceRequest("quickbi-public", "2022-01-01", "CreateCubeBySql") {
setMethod(HttpRequest::Method::Post);
}
CreateCubeBySqlRequest::~CreateCubeBySqlRequest() {}
std::string CreateCubeBySqlRequest::getDsId() const {
return dsId_;
}
void CreateCubeBySqlRequest::setDsId(const std::string &dsId) {
dsId_ = dsId;
setParameter(std::string("DsId"), dsId);
}
std::string CreateCubeBySqlRequest::getAccessPoint() const {
return accessPoint_;
}
void CreateCubeBySqlRequest::setAccessPoint(const std::string &accessPoint) {
accessPoint_ = accessPoint;
setParameter(std::string("AccessPoint"), accessPoint);
}
std::string CreateCubeBySqlRequest::getCaption() const {
return caption_;
}
void CreateCubeBySqlRequest::setCaption(const std::string &caption) {
caption_ = caption;
setParameter(std::string("Caption"), caption);
}
std::string CreateCubeBySqlRequest::getUserId() const {
return userId_;
}
void CreateCubeBySqlRequest::setUserId(const std::string &userId) {
userId_ = userId;
setParameter(std::string("UserId"), userId);
}
std::string CreateCubeBySqlRequest::getSignType() const {
return signType_;
}
void CreateCubeBySqlRequest::setSignType(const std::string &signType) {
signType_ = signType;
setParameter(std::string("SignType"), signType);
}
std::string CreateCubeBySqlRequest::getCustomSql() const {
return customSql_;
}
void CreateCubeBySqlRequest::setCustomSql(const std::string &customSql) {
customSql_ = customSql;
setParameter(std::string("CustomSql"), customSql);
}
std::string CreateCubeBySqlRequest::getWorkspaceId() const {
return workspaceId_;
}
void CreateCubeBySqlRequest::setWorkspaceId(const std::string &workspaceId) {
workspaceId_ = workspaceId;
setParameter(std::string("WorkspaceId"), workspaceId);
}

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

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/quickbi-public/model/CreateCubeBySqlResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
CreateCubeBySqlResult::CreateCubeBySqlResult() :
ServiceResult()
{}
CreateCubeBySqlResult::CreateCubeBySqlResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateCubeBySqlResult::~CreateCubeBySqlResult()
{}
void CreateCubeBySqlResult::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 CreateCubeBySqlResult::getSuccess()const
{
return success_;
}
std::string CreateCubeBySqlResult::getResult()const
{
return result_;
}

99
quickbi-public/src/model/CreateDatasetRequest.cc Normal file
View File

@@ -0,0 +1,99 @@
/*
* 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/CreateDatasetRequest.h>
using AlibabaCloud::Quickbi_public::Model::CreateDatasetRequest;
CreateDatasetRequest::CreateDatasetRequest()
: RpcServiceRequest("quickbi-public", "2022-01-01", "CreateDataset") {
setMethod(HttpRequest::Method::Post);
}
CreateDatasetRequest::~CreateDatasetRequest() {}
std::string CreateDatasetRequest::getDsId() const {
return dsId_;
}
void CreateDatasetRequest::setDsId(const std::string &dsId) {
dsId_ = dsId;
setParameter(std::string("DsId"), dsId);
}
std::string CreateDatasetRequest::getAccessPoint() const {
return accessPoint_;
}
void CreateDatasetRequest::setAccessPoint(const std::string &accessPoint) {
accessPoint_ = accessPoint;
setParameter(std::string("AccessPoint"), accessPoint);
}
std::string CreateDatasetRequest::getUserId() const {
return userId_;
}
void CreateDatasetRequest::setUserId(const std::string &userId) {
userId_ = userId;
setParameter(std::string("UserId"), userId);
}
std::string CreateDatasetRequest::getTableName() const {
return tableName_;
}
void CreateDatasetRequest::setTableName(const std::string &tableName) {
tableName_ = tableName;
setParameter(std::string("TableName"), tableName);
}
std::string CreateDatasetRequest::getTargetDirectoryId() const {
return targetDirectoryId_;
}
void CreateDatasetRequest::setTargetDirectoryId(const std::string &targetDirectoryId) {
targetDirectoryId_ = targetDirectoryId;
setParameter(std::string("TargetDirectoryId"), targetDirectoryId);
}
std::string CreateDatasetRequest::getSignType() const {
return signType_;
}
void CreateDatasetRequest::setSignType(const std::string &signType) {
signType_ = signType;
setParameter(std::string("SignType"), signType);
}
std::string CreateDatasetRequest::getUserDefineCubeName() const {
return userDefineCubeName_;
}
void CreateDatasetRequest::setUserDefineCubeName(const std::string &userDefineCubeName) {
userDefineCubeName_ = userDefineCubeName;
setParameter(std::string("UserDefineCubeName"), userDefineCubeName);
}
std::string CreateDatasetRequest::getWorkspaceId() const {
return workspaceId_;
}
void CreateDatasetRequest::setWorkspaceId(const std::string &workspaceId) {
workspaceId_ = workspaceId;
setParameter(std::string("WorkspaceId"), workspaceId);
}

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

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/quickbi-public/model/CreateDatasetResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
CreateDatasetResult::CreateDatasetResult() :
ServiceResult()
{}
CreateDatasetResult::CreateDatasetResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateDatasetResult::~CreateDatasetResult()
{}
void CreateDatasetResult::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 CreateDatasetResult::getSuccess()const
{
return success_;
}
std::string CreateDatasetResult::getResult()const
{
return result_;
}

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

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

73
quickbi-public/src/model/ListWorkspaceUserRolesByUserIdResult.cc Normal file
View File

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

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

@@ -0,0 +1,90 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/quickbi-public/model/UpdateCubeBySqlRequest.h>
using AlibabaCloud::Quickbi_public::Model::UpdateCubeBySqlRequest;
UpdateCubeBySqlRequest::UpdateCubeBySqlRequest()
: RpcServiceRequest("quickbi-public", "2022-01-01", "UpdateCubeBySql") {
setMethod(HttpRequest::Method::Post);
}
UpdateCubeBySqlRequest::~UpdateCubeBySqlRequest() {}
std::string UpdateCubeBySqlRequest::getDsId() const {
return dsId_;
}
void UpdateCubeBySqlRequest::setDsId(const std::string &dsId) {
dsId_ = dsId;
setParameter(std::string("DsId"), dsId);
}
std::string UpdateCubeBySqlRequest::getAccessPoint() const {
return accessPoint_;
}
void UpdateCubeBySqlRequest::setAccessPoint(const std::string &accessPoint) {
accessPoint_ = accessPoint;
setParameter(std::string("AccessPoint"), accessPoint);
}
std::string UpdateCubeBySqlRequest::getUserId() const {
return userId_;
}
void UpdateCubeBySqlRequest::setUserId(const std::string &userId) {
userId_ = userId;
setParameter(std::string("UserId"), userId);
}
std::string UpdateCubeBySqlRequest::getCubeId() const {
return cubeId_;
}
void UpdateCubeBySqlRequest::setCubeId(const std::string &cubeId) {
cubeId_ = cubeId;
setParameter(std::string("CubeId"), cubeId);
}
std::string UpdateCubeBySqlRequest::getSignType() const {
return signType_;
}
void UpdateCubeBySqlRequest::setSignType(const std::string &signType) {
signType_ = signType;
setParameter(std::string("SignType"), signType);
}
std::string UpdateCubeBySqlRequest::getCustomSql() const {
return customSql_;
}
void UpdateCubeBySqlRequest::setCustomSql(const std::string &customSql) {
customSql_ = customSql;
setParameter(std::string("CustomSql"), customSql);
}
std::string UpdateCubeBySqlRequest::getWorkspaceId() const {
return workspaceId_;
}
void UpdateCubeBySqlRequest::setWorkspaceId(const std::string &workspaceId) {
workspaceId_ = workspaceId;
setParameter(std::string("WorkspaceId"), workspaceId);
}

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

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/quickbi-public/model/UpdateCubeBySqlResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
UpdateCubeBySqlResult::UpdateCubeBySqlResult() :
ServiceResult()
{}
UpdateCubeBySqlResult::UpdateCubeBySqlResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateCubeBySqlResult::~UpdateCubeBySqlResult()
{}
void UpdateCubeBySqlResult::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 UpdateCubeBySqlResult::getSuccess()const
{
return success_;
}
bool UpdateCubeBySqlResult::getResult()const
{
return result_;
}

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

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

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

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/quickbi-public/model/UpdateDataSourceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
UpdateDataSourceResult::UpdateDataSourceResult() :
ServiceResult()
{}
UpdateDataSourceResult::UpdateDataSourceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateDataSourceResult::~UpdateDataSourceResult()
{}
void UpdateDataSourceResult::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 UpdateDataSourceResult::getSuccess()const
{
return success_;
}
bool UpdateDataSourceResult::getResult()const
{
return result_;
}