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

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

Browse Source
This commit is contained in:
sdk-team
2024-06-28 02:40:37 +00:00
parent 7ad42a297f
commit afc1ac57c3
34 changed files with 1773 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1941
1.36.1942

20
quickbi-public/CMakeLists.txt
View File

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

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

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

54
quickbi-public/include/alibabacloud/quickbi-public/model/DataSetBloodRequest.h 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.
*/
#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASETBLOODREQUEST_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASETBLOODREQUEST_H_
#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Quickbi_public {
namespace Model {
class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT DataSetBloodRequest : public RpcServiceRequest {
public:
DataSetBloodRequest();
~DataSetBloodRequest();
std::string getDataSetIds() const;
void setDataSetIds(const std::string &dataSetIds);
std::string getWorksType() const;
void setWorksType(const std::string &worksType);
std::string getAccessPoint() const;
void setAccessPoint(const std::string &accessPoint);
std::string getSignType() const;
void setSignType(const std::string &signType);
std::string getUserId() const;
void setUserId(const std::string &userId);
private:
std::string dataSetIds_;
std::string worksType_;
std::string accessPoint_;
std::string signType_;
std::string userId_;
};
} // namespace Model
} // namespace Quickbi_public
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASETBLOODREQUEST_H_

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

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

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

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

57
quickbi-public/include/alibabacloud/quickbi-public/model/QueryApprovalInfoRequest.h Normal file
View File

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

81
quickbi-public/include/alibabacloud/quickbi-public/model/QueryApprovalInfoResult.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAPPROVALINFORESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAPPROVALINFORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
namespace AlibabaCloud
{
namespace Quickbi_public
{
namespace Model
{
class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryApprovalInfoResult : public ServiceResult
{
public:
struct Result
{
struct ApprovalsResultModel
{
long expireDate;
int flagStatus;
std::string resourceName;
std::string applicantName;
long gmtModified;
std::string resourceType;
std::string handleReason;
std::string applyReason;
bool deleteFlag;
long gmtCreate;
std::string resourceId;
std::string applicantId;
std::string approverId;
std::string workspaceName;
std::string approverName;
std::string applicationId;
};
int pageSize;
int start;
int total;
std::vector<ApprovalsResultModel> data;
int totalPages;
int page;
};
QueryApprovalInfoResult();
explicit QueryApprovalInfoResult(const std::string &payload);
~QueryApprovalInfoResult();
bool getSuccess()const;
Result getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
Result result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAPPROVALINFORESULT_H_

66
quickbi-public/include/alibabacloud/quickbi-public/model/QueryAuditLogRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAUDITLOGREQUEST_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAUDITLOGREQUEST_H_
#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Quickbi_public {
namespace Model {
class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryAuditLogRequest : public RpcServiceRequest {
public:
QueryAuditLogRequest();
~QueryAuditLogRequest();
std::string getAccessPoint() const;
void setAccessPoint(const std::string &accessPoint);
std::string getSignType() const;
void setSignType(const std::string &signType);
std::string getStartDate() const;
void setStartDate(const std::string &startDate);
std::string getResourceType() const;
void setResourceType(const std::string &resourceType);
std::string getOperatorTypes() const;
void setOperatorTypes(const std::string &operatorTypes);
std::string getLogType() const;
void setLogType(const std::string &logType);
std::string getEndDate() const;
void setEndDate(const std::string &endDate);
std::string getOperatorId() const;
void setOperatorId(const std::string &operatorId);
std::string getWorkspaceId() const;
void setWorkspaceId(const std::string &workspaceId);
private:
std::string accessPoint_;
std::string signType_;
std::string startDate_;
std::string resourceType_;
std::string operatorTypes_;
std::string logType_;
std::string endDate_;
std::string operatorId_;
std::string workspaceId_;
};
} // namespace Model
} // namespace Quickbi_public
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAUDITLOGREQUEST_H_

63
quickbi-public/include/alibabacloud/quickbi-public/model/QueryAuditLogResult.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_QUERYAUDITLOGRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAUDITLOGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
namespace AlibabaCloud
{
namespace Quickbi_public
{
namespace Model
{
class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryAuditLogResult : public ServiceResult
{
public:
struct LogApiResultModel
{
std::string operatorAccountName;
std::string operatorName;
std::string gmtCreate;
std::string workspaceId;
std::string targetType;
std::string targetName;
std::string operatorType;
};
QueryAuditLogResult();
explicit QueryAuditLogResult(const std::string &payload);
~QueryAuditLogResult();
bool getSuccess()const;
std::vector<LogApiResultModel> getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
std::vector<LogApiResultModel> result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAUDITLOGRESULT_H_

57
quickbi-public/include/alibabacloud/quickbi-public/model/QueryDataServiceListRequest.h Normal file
View File

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

112
quickbi-public/include/alibabacloud/quickbi-public/model/QueryDataServiceListResult.h Normal file
View File

@@ -0,0 +1,112 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATASERVICELISTRESULT_H_
#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATASERVICELISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/quickbi-public/Quickbi_publicExport.h>
namespace AlibabaCloud
{
namespace Quickbi_public
{
namespace Model
{
class ALIBABACLOUD_QUICKBI_PUBLIC_EXPORT QueryDataServiceListResult : public ServiceResult
{
public:
struct Result
{
struct QueryDataServiceModel
{
struct Content
{
struct Filter
{
std::string type;
std::vector<std::string> filters;
std::string logicalOperator;
};
struct SelectFieldModel
{
struct Field
{
std::string fid;
std::string type;
std::string column;
std::string dataType;
std::string granularity;
std::string caption;
std::string name;
};
std::string orderby;
Field field;
std::string desc;
std::string alias;
std::string aggregator;
};
std::string cubeId;
std::vector<SelectFieldModel> returnFields;
Filter filter;
std::string cubeName;
bool detail;
};
std::string ownerName;
std::string cubeId;
std::string creatorId;
std::string modifierName;
std::string workspaceId;
std::string gmtModified;
std::string sid;
std::string name;
std::string desc;
std::string gmtCreate;
std::string ownerId;
Content content;
std::string cubeName;
std::string workspaceName;
std::string creatorName;
std::string modifierId;
};
int totalNum;
int pageNum;
int pageSize;
std::vector<QueryDataServiceModel> data;
int totalPages;
};
QueryDataServiceListResult();
explicit QueryDataServiceListResult(const std::string &payload);
~QueryDataServiceListResult();
bool getSuccess()const;
Result getResult()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
Result result_;
};
}
}
}
#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYDATASERVICELISTRESULT_H_

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

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

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

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

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

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

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

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

3
quickbi-public/include/alibabacloud/quickbi-public/model/UpdateUserRequest.h
View File

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

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

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

72
quickbi-public/src/model/DataSetBloodRequest.cc Normal file
View File

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

66
quickbi-public/src/model/DataSetBloodResult.cc Normal file
View File

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

54
quickbi-public/src/model/DataSourceBloodRequest.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/DataSourceBloodRequest.h>
using AlibabaCloud::Quickbi_public::Model::DataSourceBloodRequest;
DataSourceBloodRequest::DataSourceBloodRequest()
: RpcServiceRequest("quickbi-public", "2022-01-01", "DataSourceBlood") {
setMethod(HttpRequest::Method::Post);
}
DataSourceBloodRequest::~DataSourceBloodRequest() {}
std::string DataSourceBloodRequest::getAccessPoint() const {
return accessPoint_;
}
void DataSourceBloodRequest::setAccessPoint(const std::string &accessPoint) {
accessPoint_ = accessPoint;
setParameter(std::string("AccessPoint"), accessPoint);
}
std::string DataSourceBloodRequest::getDataSourceId() const {
return dataSourceId_;
}
void DataSourceBloodRequest::setDataSourceId(const std::string &dataSourceId) {
dataSourceId_ = dataSourceId;
setParameter(std::string("DataSourceId"), dataSourceId);
}
std::string DataSourceBloodRequest::getSignType() const {
return signType_;
}
void DataSourceBloodRequest::setSignType(const std::string &signType) {
signType_ = signType;
setParameter(std::string("SignType"), signType);
}

59
quickbi-public/src/model/DataSourceBloodResult.cc Normal file
View File

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

81
quickbi-public/src/model/QueryApprovalInfoRequest.cc Normal file
View File

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

105
quickbi-public/src/model/QueryApprovalInfoResult.cc Normal file
View File

@@ -0,0 +1,105 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/quickbi-public/model/QueryApprovalInfoResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
QueryApprovalInfoResult::QueryApprovalInfoResult() :
ServiceResult()
{}
QueryApprovalInfoResult::QueryApprovalInfoResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
QueryApprovalInfoResult::~QueryApprovalInfoResult()
{}
void QueryApprovalInfoResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto resultNode = value["Result"];
if(!resultNode["Total"].isNull())
result_.total = std::stoi(resultNode["Total"].asString());
if(!resultNode["TotalPages"].isNull())
result_.totalPages = std::stoi(resultNode["TotalPages"].asString());
if(!resultNode["Start"].isNull())
result_.start = std::stoi(resultNode["Start"].asString());
if(!resultNode["PageSize"].isNull())
result_.pageSize = std::stoi(resultNode["PageSize"].asString());
if(!resultNode["Page"].isNull())
result_.page = std::stoi(resultNode["Page"].asString());
auto allDataNode = resultNode["Data"]["ApprovalsResultModel"];
for (auto resultNodeDataApprovalsResultModel : allDataNode)
{
Result::ApprovalsResultModel approvalsResultModelObject;
if(!resultNodeDataApprovalsResultModel["WorkspaceName"].isNull())
approvalsResultModelObject.workspaceName = resultNodeDataApprovalsResultModel["WorkspaceName"].asString();
if(!resultNodeDataApprovalsResultModel["ApplicationId"].isNull())
approvalsResultModelObject.applicationId = resultNodeDataApprovalsResultModel["ApplicationId"].asString();
if(!resultNodeDataApprovalsResultModel["ApplicantId"].isNull())
approvalsResultModelObject.applicantId = resultNodeDataApprovalsResultModel["ApplicantId"].asString();
if(!resultNodeDataApprovalsResultModel["ApplicantName"].isNull())
approvalsResultModelObject.applicantName = resultNodeDataApprovalsResultModel["ApplicantName"].asString();
if(!resultNodeDataApprovalsResultModel["ApproverId"].isNull())
approvalsResultModelObject.approverId = resultNodeDataApprovalsResultModel["ApproverId"].asString();
if(!resultNodeDataApprovalsResultModel["ApproverName"].isNull())
approvalsResultModelObject.approverName = resultNodeDataApprovalsResultModel["ApproverName"].asString();
if(!resultNodeDataApprovalsResultModel["ResourceId"].isNull())
approvalsResultModelObject.resourceId = resultNodeDataApprovalsResultModel["ResourceId"].asString();
if(!resultNodeDataApprovalsResultModel["ResourceName"].isNull())
approvalsResultModelObject.resourceName = resultNodeDataApprovalsResultModel["ResourceName"].asString();
if(!resultNodeDataApprovalsResultModel["ResourceType"].isNull())
approvalsResultModelObject.resourceType = resultNodeDataApprovalsResultModel["ResourceType"].asString();
if(!resultNodeDataApprovalsResultModel["ApplyReason"].isNull())
approvalsResultModelObject.applyReason = resultNodeDataApprovalsResultModel["ApplyReason"].asString();
if(!resultNodeDataApprovalsResultModel["HandleReason"].isNull())
approvalsResultModelObject.handleReason = resultNodeDataApprovalsResultModel["HandleReason"].asString();
if(!resultNodeDataApprovalsResultModel["ExpireDate"].isNull())
approvalsResultModelObject.expireDate = std::stol(resultNodeDataApprovalsResultModel["ExpireDate"].asString());
if(!resultNodeDataApprovalsResultModel["GmtCreate"].isNull())
approvalsResultModelObject.gmtCreate = std::stol(resultNodeDataApprovalsResultModel["GmtCreate"].asString());
if(!resultNodeDataApprovalsResultModel["GmtModified"].isNull())
approvalsResultModelObject.gmtModified = std::stol(resultNodeDataApprovalsResultModel["GmtModified"].asString());
if(!resultNodeDataApprovalsResultModel["FlagStatus"].isNull())
approvalsResultModelObject.flagStatus = std::stoi(resultNodeDataApprovalsResultModel["FlagStatus"].asString());
if(!resultNodeDataApprovalsResultModel["DeleteFlag"].isNull())
approvalsResultModelObject.deleteFlag = resultNodeDataApprovalsResultModel["DeleteFlag"].asString() == "true";
result_.data.push_back(approvalsResultModelObject);
}
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool QueryApprovalInfoResult::getSuccess()const
{
return success_;
}
QueryApprovalInfoResult::Result QueryApprovalInfoResult::getResult()const
{
return result_;
}

108
quickbi-public/src/model/QueryAuditLogRequest.cc Normal file
View File

@@ -0,0 +1,108 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/quickbi-public/model/QueryAuditLogRequest.h>
using AlibabaCloud::Quickbi_public::Model::QueryAuditLogRequest;
QueryAuditLogRequest::QueryAuditLogRequest()
: RpcServiceRequest("quickbi-public", "2022-01-01", "QueryAuditLog") {
setMethod(HttpRequest::Method::Post);
}
QueryAuditLogRequest::~QueryAuditLogRequest() {}
std::string QueryAuditLogRequest::getAccessPoint() const {
return accessPoint_;
}
void QueryAuditLogRequest::setAccessPoint(const std::string &accessPoint) {
accessPoint_ = accessPoint;
setParameter(std::string("AccessPoint"), accessPoint);
}
std::string QueryAuditLogRequest::getSignType() const {
return signType_;
}
void QueryAuditLogRequest::setSignType(const std::string &signType) {
signType_ = signType;
setParameter(std::string("SignType"), signType);
}
std::string QueryAuditLogRequest::getStartDate() const {
return startDate_;
}
void QueryAuditLogRequest::setStartDate(const std::string &startDate) {
startDate_ = startDate;
setParameter(std::string("StartDate"), startDate);
}
std::string QueryAuditLogRequest::getResourceType() const {
return resourceType_;
}
void QueryAuditLogRequest::setResourceType(const std::string &resourceType) {
resourceType_ = resourceType;
setParameter(std::string("ResourceType"), resourceType);
}
std::string QueryAuditLogRequest::getOperatorTypes() const {
return operatorTypes_;
}
void QueryAuditLogRequest::setOperatorTypes(const std::string &operatorTypes) {
operatorTypes_ = operatorTypes;
setParameter(std::string("OperatorTypes"), operatorTypes);
}
std::string QueryAuditLogRequest::getLogType() const {
return logType_;
}
void QueryAuditLogRequest::setLogType(const std::string &logType) {
logType_ = logType;
setParameter(std::string("LogType"), logType);
}
std::string QueryAuditLogRequest::getEndDate() const {
return endDate_;
}
void QueryAuditLogRequest::setEndDate(const std::string &endDate) {
endDate_ = endDate;
setParameter(std::string("EndDate"), endDate);
}
std::string QueryAuditLogRequest::getOperatorId() const {
return operatorId_;
}
void QueryAuditLogRequest::setOperatorId(const std::string &operatorId) {
operatorId_ = operatorId;
setParameter(std::string("OperatorId"), operatorId);
}
std::string QueryAuditLogRequest::getWorkspaceId() const {
return workspaceId_;
}
void QueryAuditLogRequest::setWorkspaceId(const std::string &workspaceId) {
workspaceId_ = workspaceId;
setParameter(std::string("WorkspaceId"), workspaceId);
}

76
quickbi-public/src/model/QueryAuditLogResult.cc Normal file
View File

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

81
quickbi-public/src/model/QueryDataServiceListRequest.cc Normal file
View File

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

145
quickbi-public/src/model/QueryDataServiceListResult.cc Normal file
View File

@@ -0,0 +1,145 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/quickbi-public/model/QueryDataServiceListResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Quickbi_public;
using namespace AlibabaCloud::Quickbi_public::Model;
QueryDataServiceListResult::QueryDataServiceListResult() :
ServiceResult()
{}
QueryDataServiceListResult::QueryDataServiceListResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
QueryDataServiceListResult::~QueryDataServiceListResult()
{}
void QueryDataServiceListResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto resultNode = value["Result"];
if(!resultNode["TotalPages"].isNull())
result_.totalPages = std::stoi(resultNode["TotalPages"].asString());
if(!resultNode["TotalNum"].isNull())
result_.totalNum = std::stoi(resultNode["TotalNum"].asString());
if(!resultNode["PageNum"].isNull())
result_.pageNum = std::stoi(resultNode["PageNum"].asString());
if(!resultNode["PageSize"].isNull())
result_.pageSize = std::stoi(resultNode["PageSize"].asString());
auto allDataNode = resultNode["Data"]["QueryDataServiceModel"];
for (auto resultNodeDataQueryDataServiceModel : allDataNode)
{
Result::QueryDataServiceModel queryDataServiceModelObject;
if(!resultNodeDataQueryDataServiceModel["Sid"].isNull())
queryDataServiceModelObject.sid = resultNodeDataQueryDataServiceModel["Sid"].asString();
if(!resultNodeDataQueryDataServiceModel["Name"].isNull())
queryDataServiceModelObject.name = resultNodeDataQueryDataServiceModel["Name"].asString();
if(!resultNodeDataQueryDataServiceModel["Desc"].isNull())
queryDataServiceModelObject.desc = resultNodeDataQueryDataServiceModel["Desc"].asString();
if(!resultNodeDataQueryDataServiceModel["CubeId"].isNull())
queryDataServiceModelObject.cubeId = resultNodeDataQueryDataServiceModel["CubeId"].asString();
if(!resultNodeDataQueryDataServiceModel["CubeName"].isNull())
queryDataServiceModelObject.cubeName = resultNodeDataQueryDataServiceModel["CubeName"].asString();
if(!resultNodeDataQueryDataServiceModel["WorkspaceId"].isNull())
queryDataServiceModelObject.workspaceId = resultNodeDataQueryDataServiceModel["WorkspaceId"].asString();
if(!resultNodeDataQueryDataServiceModel["WorkspaceName"].isNull())
queryDataServiceModelObject.workspaceName = resultNodeDataQueryDataServiceModel["WorkspaceName"].asString();
if(!resultNodeDataQueryDataServiceModel["GmtCreate"].isNull())
queryDataServiceModelObject.gmtCreate = resultNodeDataQueryDataServiceModel["GmtCreate"].asString();
if(!resultNodeDataQueryDataServiceModel["GmtModified"].isNull())
queryDataServiceModelObject.gmtModified = resultNodeDataQueryDataServiceModel["GmtModified"].asString();
if(!resultNodeDataQueryDataServiceModel["CreatorId"].isNull())
queryDataServiceModelObject.creatorId = resultNodeDataQueryDataServiceModel["CreatorId"].asString();
if(!resultNodeDataQueryDataServiceModel["CreatorName"].isNull())
queryDataServiceModelObject.creatorName = resultNodeDataQueryDataServiceModel["CreatorName"].asString();
if(!resultNodeDataQueryDataServiceModel["ModifierId"].isNull())
queryDataServiceModelObject.modifierId = resultNodeDataQueryDataServiceModel["ModifierId"].asString();
if(!resultNodeDataQueryDataServiceModel["ModifierName"].isNull())
queryDataServiceModelObject.modifierName = resultNodeDataQueryDataServiceModel["ModifierName"].asString();
if(!resultNodeDataQueryDataServiceModel["OwnerId"].isNull())
queryDataServiceModelObject.ownerId = resultNodeDataQueryDataServiceModel["OwnerId"].asString();
if(!resultNodeDataQueryDataServiceModel["OwnerName"].isNull())
queryDataServiceModelObject.ownerName = resultNodeDataQueryDataServiceModel["OwnerName"].asString();
auto contentNode = value["Content"];
if(!contentNode["CubeId"].isNull())
queryDataServiceModelObject.content.cubeId = contentNode["CubeId"].asString();
if(!contentNode["CubeName"].isNull())
queryDataServiceModelObject.content.cubeName = contentNode["CubeName"].asString();
if(!contentNode["Detail"].isNull())
queryDataServiceModelObject.content.detail = contentNode["Detail"].asString() == "true";
auto allReturnFieldsNode = contentNode["ReturnFields"]["SelectFieldModel"];
for (auto contentNodeReturnFieldsSelectFieldModel : allReturnFieldsNode)
{
Result::QueryDataServiceModel::Content::SelectFieldModel selectFieldModelObject;
if(!contentNodeReturnFieldsSelectFieldModel["Alias"].isNull())
selectFieldModelObject.alias = contentNodeReturnFieldsSelectFieldModel["Alias"].asString();
if(!contentNodeReturnFieldsSelectFieldModel["Desc"].isNull())
selectFieldModelObject.desc = contentNodeReturnFieldsSelectFieldModel["Desc"].asString();
if(!contentNodeReturnFieldsSelectFieldModel["Aggregator"].isNull())
selectFieldModelObject.aggregator = contentNodeReturnFieldsSelectFieldModel["Aggregator"].asString();
if(!contentNodeReturnFieldsSelectFieldModel["Orderby"].isNull())
selectFieldModelObject.orderby = contentNodeReturnFieldsSelectFieldModel["Orderby"].asString();
auto fieldNode = value["Field"];
if(!fieldNode["Fid"].isNull())
selectFieldModelObject.field.fid = fieldNode["Fid"].asString();
if(!fieldNode["Name"].isNull())
selectFieldModelObject.field.name = fieldNode["Name"].asString();
if(!fieldNode["Type"].isNull())
selectFieldModelObject.field.type = fieldNode["Type"].asString();
if(!fieldNode["Caption"].isNull())
selectFieldModelObject.field.caption = fieldNode["Caption"].asString();
if(!fieldNode["Column"].isNull())
selectFieldModelObject.field.column = fieldNode["Column"].asString();
if(!fieldNode["DataType"].isNull())
selectFieldModelObject.field.dataType = fieldNode["DataType"].asString();
if(!fieldNode["Granularity"].isNull())
selectFieldModelObject.field.granularity = fieldNode["Granularity"].asString();
queryDataServiceModelObject.content.returnFields.push_back(selectFieldModelObject);
}
auto filterNode = contentNode["Filter"];
if(!filterNode["LogicalOperator"].isNull())
queryDataServiceModelObject.content.filter.logicalOperator = filterNode["LogicalOperator"].asString();
if(!filterNode["Type"].isNull())
queryDataServiceModelObject.content.filter.type = filterNode["Type"].asString();
auto allFilters = filterNode["Filters"]["AbstractFilter"];
for (auto value : allFilters)
queryDataServiceModelObject.content.filter.filters.push_back(value.asString());
result_.data.push_back(queryDataServiceModelObject);
}
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
bool QueryDataServiceListResult::getSuccess()const
{
return success_;
}
QueryDataServiceListResult::Result QueryDataServiceListResult::getResult()const
{
return result_;
}

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

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

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

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

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

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

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

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

9
quickbi-public/src/model/UpdateUserRequest.cc
View File

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