diff --git a/VERSION b/VERSION index a0b879a7c..df46e331f 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1941 \ No newline at end of file +1.36.1942 \ No newline at end of file diff --git a/quickbi-public/CMakeLists.txt b/quickbi-public/CMakeLists.txt index f3ac99cb6..e194eeb91 100644 --- a/quickbi-public/CMakeLists.txt +++ b/quickbi-public/CMakeLists.txt @@ -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 diff --git a/quickbi-public/include/alibabacloud/quickbi-public/Quickbi_publicClient.h b/quickbi-public/include/alibabacloud/quickbi-public/Quickbi_publicClient.h index d95c68801..dd95a6873 100644 --- a/quickbi-public/include/alibabacloud/quickbi-public/Quickbi_publicClient.h +++ b/quickbi-public/include/alibabacloud/quickbi-public/Quickbi_publicClient.h @@ -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 CreateUserGroupOutcome; typedef std::future CreateUserGroupOutcomeCallable; typedef std::function&)> CreateUserGroupAsyncHandler; + typedef Outcome DataSetBloodOutcome; + typedef std::future DataSetBloodOutcomeCallable; + typedef std::function&)> DataSetBloodAsyncHandler; + typedef Outcome DataSourceBloodOutcome; + typedef std::future DataSourceBloodOutcomeCallable; + typedef std::function&)> DataSourceBloodAsyncHandler; typedef Outcome DelayTicketExpireTimeOutcome; typedef std::future DelayTicketExpireTimeOutcomeCallable; typedef std::function&)> DelayTicketExpireTimeAsyncHandler; @@ -358,6 +374,12 @@ namespace AlibabaCloud typedef Outcome ModifyApiDatasourceParametersOutcome; typedef std::future ModifyApiDatasourceParametersOutcomeCallable; typedef std::function&)> ModifyApiDatasourceParametersAsyncHandler; + typedef Outcome QueryApprovalInfoOutcome; + typedef std::future QueryApprovalInfoOutcomeCallable; + typedef std::function&)> QueryApprovalInfoAsyncHandler; + typedef Outcome QueryAuditLogOutcome; + typedef std::future QueryAuditLogOutcomeCallable; + typedef std::function&)> QueryAuditLogAsyncHandler; typedef Outcome QueryComponentPerformanceOutcome; typedef std::future QueryComponentPerformanceOutcomeCallable; typedef std::function&)> QueryComponentPerformanceAsyncHandler; @@ -370,6 +392,9 @@ namespace AlibabaCloud typedef Outcome QueryDataServiceOutcome; typedef std::future QueryDataServiceOutcomeCallable; typedef std::function&)> QueryDataServiceAsyncHandler; + typedef Outcome QueryDataServiceListOutcome; + typedef std::future QueryDataServiceListOutcomeCallable; + typedef std::function&)> QueryDataServiceListAsyncHandler; typedef Outcome QueryDatasetDetailInfoOutcome; typedef std::future QueryDatasetDetailInfoOutcomeCallable; typedef std::function&)> 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& context = nullptr) const; QueryDatasetDetailInfoOutcomeCallable queryDatasetDetailInfoCallable(const Model::QueryDatasetDetailInfoRequest& request) const; diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/DataSetBloodRequest.h b/quickbi-public/include/alibabacloud/quickbi-public/model/DataSetBloodRequest.h new file mode 100644 index 000000000..6fd6500a4 --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/DataSetBloodRequest.h @@ -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 +#include +#include +#include +#include + +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_ diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/DataSetBloodResult.h b/quickbi-public/include/alibabacloud/quickbi-public/model/DataSetBloodResult.h new file mode 100644 index 000000000..784434e8f --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/DataSetBloodResult.h @@ -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 +#include +#include +#include +#include + +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 getResult()const; + + protected: + void parse(const std::string &payload); + private: + bool success_; + std::vector result_; + + }; + } + } +} +#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASETBLOODRESULT_H_ \ No newline at end of file diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/DataSourceBloodRequest.h b/quickbi-public/include/alibabacloud/quickbi-public/model/DataSourceBloodRequest.h new file mode 100644 index 000000000..6eaa44548 --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/DataSourceBloodRequest.h @@ -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 +#include +#include +#include +#include + +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_ diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/DataSourceBloodResult.h b/quickbi-public/include/alibabacloud/quickbi-public/model/DataSourceBloodResult.h new file mode 100644 index 000000000..b8a24dd7b --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/DataSourceBloodResult.h @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASOURCEBLOODRESULT_H_ +#define ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASOURCEBLOODRESULT_H_ + +#include +#include +#include +#include +#include + +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 getResult()const; + + protected: + void parse(const std::string &payload); + private: + bool success_; + std::vector result_; + + }; + } + } +} +#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_DATASOURCEBLOODRESULT_H_ \ No newline at end of file diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryApprovalInfoRequest.h b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryApprovalInfoRequest.h new file mode 100644 index 000000000..f65214d12 --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryApprovalInfoRequest.h @@ -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 +#include +#include +#include +#include + +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_ diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryApprovalInfoResult.h b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryApprovalInfoResult.h new file mode 100644 index 000000000..ef5c1eb63 --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryApprovalInfoResult.h @@ -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 +#include +#include +#include +#include + +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 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_ \ No newline at end of file diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryAuditLogRequest.h b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryAuditLogRequest.h new file mode 100644 index 000000000..03d6989d3 --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryAuditLogRequest.h @@ -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 +#include +#include +#include +#include + +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_ diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryAuditLogResult.h b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryAuditLogResult.h new file mode 100644 index 000000000..1dcb000ab --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryAuditLogResult.h @@ -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 +#include +#include +#include +#include + +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 getResult()const; + + protected: + void parse(const std::string &payload); + private: + bool success_; + std::vector result_; + + }; + } + } +} +#endif // !ALIBABACLOUD_QUICKBI_PUBLIC_MODEL_QUERYAUDITLOGRESULT_H_ \ No newline at end of file diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryDataServiceListRequest.h b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryDataServiceListRequest.h new file mode 100644 index 000000000..21e970ca1 --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryDataServiceListRequest.h @@ -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 +#include +#include +#include +#include + +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_ diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryDataServiceListResult.h b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryDataServiceListResult.h new file mode 100644 index 000000000..abed8f214 --- /dev/null +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryDataServiceListResult.h @@ -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 +#include +#include +#include +#include + +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 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 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 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_ \ No newline at end of file diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryUserListResult.h b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryUserListResult.h index 1b18eb725..538cea5e3 100644 --- a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryUserListResult.h +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryUserListResult.h @@ -36,6 +36,7 @@ namespace AlibabaCloud { struct DataItem { + long lastLoginTime; std::vector 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; }; diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksByOrganizationResult.h b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksByOrganizationResult.h index d66f6e728..9bd80101f 100644 --- a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksByOrganizationResult.h +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksByOrganizationResult.h @@ -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; }; diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksByWorkspaceResult.h b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksByWorkspaceResult.h index db015eb0f..3444a3486 100644 --- a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksByWorkspaceResult.h +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksByWorkspaceResult.h @@ -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; }; diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksResult.h b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksResult.h index 14ca50305..e02450842 100644 --- a/quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksResult.h +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/QueryWorksResult.h @@ -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; }; diff --git a/quickbi-public/include/alibabacloud/quickbi-public/model/UpdateUserRequest.h b/quickbi-public/include/alibabacloud/quickbi-public/model/UpdateUserRequest.h index 732103dcd..1e8f81b65 100644 --- a/quickbi-public/include/alibabacloud/quickbi-public/model/UpdateUserRequest.h +++ b/quickbi-public/include/alibabacloud/quickbi-public/model/UpdateUserRequest.h @@ -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_; diff --git a/quickbi-public/src/Quickbi-publicClient.cc b/quickbi-public/src/Quickbi-publicClient.cc index 902d7ed52..61f687287 100644 --- a/quickbi-public/src/Quickbi-publicClient.cc +++ b/quickbi-public/src/Quickbi-publicClient.cc @@ -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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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(); diff --git a/quickbi-public/src/model/DataSetBloodRequest.cc b/quickbi-public/src/model/DataSetBloodRequest.cc new file mode 100644 index 000000000..8478f86fe --- /dev/null +++ b/quickbi-public/src/model/DataSetBloodRequest.cc @@ -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 + +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); +} + diff --git a/quickbi-public/src/model/DataSetBloodResult.cc b/quickbi-public/src/model/DataSetBloodResult.cc new file mode 100644 index 000000000..b65f87d45 --- /dev/null +++ b/quickbi-public/src/model/DataSetBloodResult.cc @@ -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 +#include + +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::getResult()const +{ + return result_; +} + diff --git a/quickbi-public/src/model/DataSourceBloodRequest.cc b/quickbi-public/src/model/DataSourceBloodRequest.cc new file mode 100644 index 000000000..d2b203f20 --- /dev/null +++ b/quickbi-public/src/model/DataSourceBloodRequest.cc @@ -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 + +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); +} + diff --git a/quickbi-public/src/model/DataSourceBloodResult.cc b/quickbi-public/src/model/DataSourceBloodResult.cc new file mode 100644 index 000000000..aa8c2219a --- /dev/null +++ b/quickbi-public/src/model/DataSourceBloodResult.cc @@ -0,0 +1,59 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Quickbi_public; +using namespace AlibabaCloud::Quickbi_public::Model; + +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 DataSourceBloodResult::getResult()const +{ + return result_; +} + diff --git a/quickbi-public/src/model/QueryApprovalInfoRequest.cc b/quickbi-public/src/model/QueryApprovalInfoRequest.cc new file mode 100644 index 000000000..46a4f9629 --- /dev/null +++ b/quickbi-public/src/model/QueryApprovalInfoRequest.cc @@ -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 + +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)); +} + diff --git a/quickbi-public/src/model/QueryApprovalInfoResult.cc b/quickbi-public/src/model/QueryApprovalInfoResult.cc new file mode 100644 index 000000000..d077b519d --- /dev/null +++ b/quickbi-public/src/model/QueryApprovalInfoResult.cc @@ -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 +#include + +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_; +} + diff --git a/quickbi-public/src/model/QueryAuditLogRequest.cc b/quickbi-public/src/model/QueryAuditLogRequest.cc new file mode 100644 index 000000000..c59c85cc4 --- /dev/null +++ b/quickbi-public/src/model/QueryAuditLogRequest.cc @@ -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 + +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); +} + diff --git a/quickbi-public/src/model/QueryAuditLogResult.cc b/quickbi-public/src/model/QueryAuditLogResult.cc new file mode 100644 index 000000000..406a241d2 --- /dev/null +++ b/quickbi-public/src/model/QueryAuditLogResult.cc @@ -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 +#include + +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::getResult()const +{ + return result_; +} + diff --git a/quickbi-public/src/model/QueryDataServiceListRequest.cc b/quickbi-public/src/model/QueryDataServiceListRequest.cc new file mode 100644 index 000000000..f177ca122 --- /dev/null +++ b/quickbi-public/src/model/QueryDataServiceListRequest.cc @@ -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 + +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); +} + diff --git a/quickbi-public/src/model/QueryDataServiceListResult.cc b/quickbi-public/src/model/QueryDataServiceListResult.cc new file mode 100644 index 000000000..174cc9f9a --- /dev/null +++ b/quickbi-public/src/model/QueryDataServiceListResult.cc @@ -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 +#include + +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_; +} + diff --git a/quickbi-public/src/model/QueryUserListResult.cc b/quickbi-public/src/model/QueryUserListResult.cc index b2c6199d4..f0e8e6b23 100644 --- a/quickbi-public/src/model/QueryUserListResult.cc +++ b/quickbi-public/src/model/QueryUserListResult.cc @@ -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()); diff --git a/quickbi-public/src/model/QueryWorksByOrganizationResult.cc b/quickbi-public/src/model/QueryWorksByOrganizationResult.cc index a37696404..a43009504 100644 --- a/quickbi-public/src/model/QueryWorksByOrganizationResult.cc +++ b/quickbi-public/src/model/QueryWorksByOrganizationResult.cc @@ -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(); diff --git a/quickbi-public/src/model/QueryWorksByWorkspaceResult.cc b/quickbi-public/src/model/QueryWorksByWorkspaceResult.cc index 30d0639f7..04c7f3b27 100644 --- a/quickbi-public/src/model/QueryWorksByWorkspaceResult.cc +++ b/quickbi-public/src/model/QueryWorksByWorkspaceResult.cc @@ -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(); diff --git a/quickbi-public/src/model/QueryWorksResult.cc b/quickbi-public/src/model/QueryWorksResult.cc index a84b658f3..9040d4f5e 100644 --- a/quickbi-public/src/model/QueryWorksResult.cc +++ b/quickbi-public/src/model/QueryWorksResult.cc @@ -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(); diff --git a/quickbi-public/src/model/UpdateUserRequest.cc b/quickbi-public/src/model/UpdateUserRequest.cc index 9ebbf370b..75194bdca 100644 --- a/quickbi-public/src/model/UpdateUserRequest.cc +++ b/quickbi-public/src/model/UpdateUserRequest.cc @@ -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_; }