diff --git a/CHANGELOG b/CHANGELOG index 916e91f54..5102bb232 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2021-12-06 Version: 1.36.965 +- Generated 2020-05-18 for `dataworks-public`. + 2021-12-06 Version: 1.36.964 - Modify the input parameter Action of DescribeCenInterRegionBandwidthLimits to be required. diff --git a/VERSION b/VERSION index 47e3d0af6..a5028ec45 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.964 \ No newline at end of file +1.36.965 \ No newline at end of file diff --git a/dataworks-public/CMakeLists.txt b/dataworks-public/CMakeLists.txt index 7998849e4..dd251db73 100644 --- a/dataworks-public/CMakeLists.txt +++ b/dataworks-public/CMakeLists.txt @@ -61,6 +61,8 @@ set(dataworks-public_public_header_model include/alibabacloud/dataworks-public/model/CreateDataServiceGroupResult.h include/alibabacloud/dataworks-public/model/CreateDataSourceRequest.h include/alibabacloud/dataworks-public/model/CreateDataSourceResult.h + include/alibabacloud/dataworks-public/model/CreateExportMigrationRequest.h + include/alibabacloud/dataworks-public/model/CreateExportMigrationResult.h include/alibabacloud/dataworks-public/model/CreateFileRequest.h include/alibabacloud/dataworks-public/model/CreateFileResult.h include/alibabacloud/dataworks-public/model/CreateFolderRequest.h @@ -195,6 +197,8 @@ set(dataworks-public_public_header_model include/alibabacloud/dataworks-public/model/GetFileVersionResult.h include/alibabacloud/dataworks-public/model/GetFolderRequest.h include/alibabacloud/dataworks-public/model/GetFolderResult.h + include/alibabacloud/dataworks-public/model/GetIDEEventDetailRequest.h + include/alibabacloud/dataworks-public/model/GetIDEEventDetailResult.h include/alibabacloud/dataworks-public/model/GetInstanceRequest.h include/alibabacloud/dataworks-public/model/GetInstanceResult.h include/alibabacloud/dataworks-public/model/GetInstanceConsumeTimeRankRequest.h @@ -241,6 +245,8 @@ set(dataworks-public_public_header_model include/alibabacloud/dataworks-public/model/GetMetaTableThemeLevelResult.h include/alibabacloud/dataworks-public/model/GetMigrationProcessRequest.h include/alibabacloud/dataworks-public/model/GetMigrationProcessResult.h + include/alibabacloud/dataworks-public/model/GetMigrationSummaryRequest.h + include/alibabacloud/dataworks-public/model/GetMigrationSummaryResult.h include/alibabacloud/dataworks-public/model/GetNodeRequest.h include/alibabacloud/dataworks-public/model/GetNodeResult.h include/alibabacloud/dataworks-public/model/GetNodeChildrenRequest.h @@ -301,6 +307,8 @@ set(dataworks-public_public_header_model include/alibabacloud/dataworks-public/model/ListDIProjectConfigResult.h include/alibabacloud/dataworks-public/model/ListDISyncTasksRequest.h include/alibabacloud/dataworks-public/model/ListDISyncTasksResult.h + include/alibabacloud/dataworks-public/model/ListDagsRequest.h + include/alibabacloud/dataworks-public/model/ListDagsResult.h include/alibabacloud/dataworks-public/model/ListDataServiceApiAuthoritiesRequest.h include/alibabacloud/dataworks-public/model/ListDataServiceApiAuthoritiesResult.h include/alibabacloud/dataworks-public/model/ListDataServiceApisRequest.h @@ -317,6 +325,8 @@ set(dataworks-public_public_header_model include/alibabacloud/dataworks-public/model/ListDataServicePublishedApisResult.h include/alibabacloud/dataworks-public/model/ListDataSourcesRequest.h include/alibabacloud/dataworks-public/model/ListDataSourcesResult.h + include/alibabacloud/dataworks-public/model/ListDeploymentsRequest.h + include/alibabacloud/dataworks-public/model/ListDeploymentsResult.h include/alibabacloud/dataworks-public/model/ListFileTypeRequest.h include/alibabacloud/dataworks-public/model/ListFileTypeResult.h include/alibabacloud/dataworks-public/model/ListFileVersionsRequest.h @@ -447,6 +457,8 @@ set(dataworks-public_public_header_model include/alibabacloud/dataworks-public/model/UpdateFileResult.h include/alibabacloud/dataworks-public/model/UpdateFolderRequest.h include/alibabacloud/dataworks-public/model/UpdateFolderResult.h + include/alibabacloud/dataworks-public/model/UpdateIDEEventResultRequest.h + include/alibabacloud/dataworks-public/model/UpdateIDEEventResultResult.h include/alibabacloud/dataworks-public/model/UpdateMetaCategoryRequest.h include/alibabacloud/dataworks-public/model/UpdateMetaCategoryResult.h include/alibabacloud/dataworks-public/model/UpdateMetaTableRequest.h @@ -518,6 +530,8 @@ set(dataworks-public_src src/model/CreateDataServiceGroupResult.cc src/model/CreateDataSourceRequest.cc src/model/CreateDataSourceResult.cc + src/model/CreateExportMigrationRequest.cc + src/model/CreateExportMigrationResult.cc src/model/CreateFileRequest.cc src/model/CreateFileResult.cc src/model/CreateFolderRequest.cc @@ -652,6 +666,8 @@ set(dataworks-public_src src/model/GetFileVersionResult.cc src/model/GetFolderRequest.cc src/model/GetFolderResult.cc + src/model/GetIDEEventDetailRequest.cc + src/model/GetIDEEventDetailResult.cc src/model/GetInstanceRequest.cc src/model/GetInstanceResult.cc src/model/GetInstanceConsumeTimeRankRequest.cc @@ -698,6 +714,8 @@ set(dataworks-public_src src/model/GetMetaTableThemeLevelResult.cc src/model/GetMigrationProcessRequest.cc src/model/GetMigrationProcessResult.cc + src/model/GetMigrationSummaryRequest.cc + src/model/GetMigrationSummaryResult.cc src/model/GetNodeRequest.cc src/model/GetNodeResult.cc src/model/GetNodeChildrenRequest.cc @@ -758,6 +776,8 @@ set(dataworks-public_src src/model/ListDIProjectConfigResult.cc src/model/ListDISyncTasksRequest.cc src/model/ListDISyncTasksResult.cc + src/model/ListDagsRequest.cc + src/model/ListDagsResult.cc src/model/ListDataServiceApiAuthoritiesRequest.cc src/model/ListDataServiceApiAuthoritiesResult.cc src/model/ListDataServiceApisRequest.cc @@ -774,6 +794,8 @@ set(dataworks-public_src src/model/ListDataServicePublishedApisResult.cc src/model/ListDataSourcesRequest.cc src/model/ListDataSourcesResult.cc + src/model/ListDeploymentsRequest.cc + src/model/ListDeploymentsResult.cc src/model/ListFileTypeRequest.cc src/model/ListFileTypeResult.cc src/model/ListFileVersionsRequest.cc @@ -904,6 +926,8 @@ set(dataworks-public_src src/model/UpdateFileResult.cc src/model/UpdateFolderRequest.cc src/model/UpdateFolderResult.cc + src/model/UpdateIDEEventResultRequest.cc + src/model/UpdateIDEEventResultResult.cc src/model/UpdateMetaCategoryRequest.cc src/model/UpdateMetaCategoryResult.cc src/model/UpdateMetaTableRequest.cc diff --git a/dataworks-public/include/alibabacloud/dataworks-public/Dataworks_publicClient.h b/dataworks-public/include/alibabacloud/dataworks-public/Dataworks_publicClient.h index 36f1003d5..8c9178d1e 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/Dataworks_publicClient.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/Dataworks_publicClient.h @@ -62,6 +62,8 @@ #include "model/CreateDataServiceGroupResult.h" #include "model/CreateDataSourceRequest.h" #include "model/CreateDataSourceResult.h" +#include "model/CreateExportMigrationRequest.h" +#include "model/CreateExportMigrationResult.h" #include "model/CreateFileRequest.h" #include "model/CreateFileResult.h" #include "model/CreateFolderRequest.h" @@ -196,6 +198,8 @@ #include "model/GetFileVersionResult.h" #include "model/GetFolderRequest.h" #include "model/GetFolderResult.h" +#include "model/GetIDEEventDetailRequest.h" +#include "model/GetIDEEventDetailResult.h" #include "model/GetInstanceRequest.h" #include "model/GetInstanceResult.h" #include "model/GetInstanceConsumeTimeRankRequest.h" @@ -242,6 +246,8 @@ #include "model/GetMetaTableThemeLevelResult.h" #include "model/GetMigrationProcessRequest.h" #include "model/GetMigrationProcessResult.h" +#include "model/GetMigrationSummaryRequest.h" +#include "model/GetMigrationSummaryResult.h" #include "model/GetNodeRequest.h" #include "model/GetNodeResult.h" #include "model/GetNodeChildrenRequest.h" @@ -302,6 +308,8 @@ #include "model/ListDIProjectConfigResult.h" #include "model/ListDISyncTasksRequest.h" #include "model/ListDISyncTasksResult.h" +#include "model/ListDagsRequest.h" +#include "model/ListDagsResult.h" #include "model/ListDataServiceApiAuthoritiesRequest.h" #include "model/ListDataServiceApiAuthoritiesResult.h" #include "model/ListDataServiceApisRequest.h" @@ -318,6 +326,8 @@ #include "model/ListDataServicePublishedApisResult.h" #include "model/ListDataSourcesRequest.h" #include "model/ListDataSourcesResult.h" +#include "model/ListDeploymentsRequest.h" +#include "model/ListDeploymentsResult.h" #include "model/ListFileTypeRequest.h" #include "model/ListFileTypeResult.h" #include "model/ListFileVersionsRequest.h" @@ -448,6 +458,8 @@ #include "model/UpdateFileResult.h" #include "model/UpdateFolderRequest.h" #include "model/UpdateFolderResult.h" +#include "model/UpdateIDEEventResultRequest.h" +#include "model/UpdateIDEEventResultResult.h" #include "model/UpdateMetaCategoryRequest.h" #include "model/UpdateMetaCategoryResult.h" #include "model/UpdateMetaTableRequest.h" @@ -545,6 +557,9 @@ namespace AlibabaCloud typedef Outcome CreateDataSourceOutcome; typedef std::future CreateDataSourceOutcomeCallable; typedef std::function&)> CreateDataSourceAsyncHandler; + typedef Outcome CreateExportMigrationOutcome; + typedef std::future CreateExportMigrationOutcomeCallable; + typedef std::function&)> CreateExportMigrationAsyncHandler; typedef Outcome CreateFileOutcome; typedef std::future CreateFileOutcomeCallable; typedef std::function&)> CreateFileAsyncHandler; @@ -746,6 +761,9 @@ namespace AlibabaCloud typedef Outcome GetFolderOutcome; typedef std::future GetFolderOutcomeCallable; typedef std::function&)> GetFolderAsyncHandler; + typedef Outcome GetIDEEventDetailOutcome; + typedef std::future GetIDEEventDetailOutcomeCallable; + typedef std::function&)> GetIDEEventDetailAsyncHandler; typedef Outcome GetInstanceOutcome; typedef std::future GetInstanceOutcomeCallable; typedef std::function&)> GetInstanceAsyncHandler; @@ -815,6 +833,9 @@ namespace AlibabaCloud typedef Outcome GetMigrationProcessOutcome; typedef std::future GetMigrationProcessOutcomeCallable; typedef std::function&)> GetMigrationProcessAsyncHandler; + typedef Outcome GetMigrationSummaryOutcome; + typedef std::future GetMigrationSummaryOutcomeCallable; + typedef std::function&)> GetMigrationSummaryAsyncHandler; typedef Outcome GetNodeOutcome; typedef std::future GetNodeOutcomeCallable; typedef std::function&)> GetNodeAsyncHandler; @@ -905,6 +926,9 @@ namespace AlibabaCloud typedef Outcome ListDISyncTasksOutcome; typedef std::future ListDISyncTasksOutcomeCallable; typedef std::function&)> ListDISyncTasksAsyncHandler; + typedef Outcome ListDagsOutcome; + typedef std::future ListDagsOutcomeCallable; + typedef std::function&)> ListDagsAsyncHandler; typedef Outcome ListDataServiceApiAuthoritiesOutcome; typedef std::future ListDataServiceApiAuthoritiesOutcomeCallable; typedef std::function&)> ListDataServiceApiAuthoritiesAsyncHandler; @@ -929,6 +953,9 @@ namespace AlibabaCloud typedef Outcome ListDataSourcesOutcome; typedef std::future ListDataSourcesOutcomeCallable; typedef std::function&)> ListDataSourcesAsyncHandler; + typedef Outcome ListDeploymentsOutcome; + typedef std::future ListDeploymentsOutcomeCallable; + typedef std::function&)> ListDeploymentsAsyncHandler; typedef Outcome ListFileTypeOutcome; typedef std::future ListFileTypeOutcomeCallable; typedef std::function&)> ListFileTypeAsyncHandler; @@ -1124,6 +1151,9 @@ namespace AlibabaCloud typedef Outcome UpdateFolderOutcome; typedef std::future UpdateFolderOutcomeCallable; typedef std::function&)> UpdateFolderAsyncHandler; + typedef Outcome UpdateIDEEventResultOutcome; + typedef std::future UpdateIDEEventResultOutcomeCallable; + typedef std::function&)> UpdateIDEEventResultAsyncHandler; typedef Outcome UpdateMetaCategoryOutcome; typedef std::future UpdateMetaCategoryOutcomeCallable; typedef std::function&)> UpdateMetaCategoryAsyncHandler; @@ -1231,6 +1261,9 @@ namespace AlibabaCloud CreateDataSourceOutcome createDataSource(const Model::CreateDataSourceRequest &request)const; void createDataSourceAsync(const Model::CreateDataSourceRequest& request, const CreateDataSourceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateDataSourceOutcomeCallable createDataSourceCallable(const Model::CreateDataSourceRequest& request) const; + CreateExportMigrationOutcome createExportMigration(const Model::CreateExportMigrationRequest &request)const; + void createExportMigrationAsync(const Model::CreateExportMigrationRequest& request, const CreateExportMigrationAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateExportMigrationOutcomeCallable createExportMigrationCallable(const Model::CreateExportMigrationRequest& request) const; CreateFileOutcome createFile(const Model::CreateFileRequest &request)const; void createFileAsync(const Model::CreateFileRequest& request, const CreateFileAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateFileOutcomeCallable createFileCallable(const Model::CreateFileRequest& request) const; @@ -1432,6 +1465,9 @@ namespace AlibabaCloud GetFolderOutcome getFolder(const Model::GetFolderRequest &request)const; void getFolderAsync(const Model::GetFolderRequest& request, const GetFolderAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetFolderOutcomeCallable getFolderCallable(const Model::GetFolderRequest& request) const; + GetIDEEventDetailOutcome getIDEEventDetail(const Model::GetIDEEventDetailRequest &request)const; + void getIDEEventDetailAsync(const Model::GetIDEEventDetailRequest& request, const GetIDEEventDetailAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetIDEEventDetailOutcomeCallable getIDEEventDetailCallable(const Model::GetIDEEventDetailRequest& request) const; GetInstanceOutcome getInstance(const Model::GetInstanceRequest &request)const; void getInstanceAsync(const Model::GetInstanceRequest& request, const GetInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetInstanceOutcomeCallable getInstanceCallable(const Model::GetInstanceRequest& request) const; @@ -1501,6 +1537,9 @@ namespace AlibabaCloud GetMigrationProcessOutcome getMigrationProcess(const Model::GetMigrationProcessRequest &request)const; void getMigrationProcessAsync(const Model::GetMigrationProcessRequest& request, const GetMigrationProcessAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetMigrationProcessOutcomeCallable getMigrationProcessCallable(const Model::GetMigrationProcessRequest& request) const; + GetMigrationSummaryOutcome getMigrationSummary(const Model::GetMigrationSummaryRequest &request)const; + void getMigrationSummaryAsync(const Model::GetMigrationSummaryRequest& request, const GetMigrationSummaryAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetMigrationSummaryOutcomeCallable getMigrationSummaryCallable(const Model::GetMigrationSummaryRequest& request) const; GetNodeOutcome getNode(const Model::GetNodeRequest &request)const; void getNodeAsync(const Model::GetNodeRequest& request, const GetNodeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetNodeOutcomeCallable getNodeCallable(const Model::GetNodeRequest& request) const; @@ -1591,6 +1630,9 @@ namespace AlibabaCloud ListDISyncTasksOutcome listDISyncTasks(const Model::ListDISyncTasksRequest &request)const; void listDISyncTasksAsync(const Model::ListDISyncTasksRequest& request, const ListDISyncTasksAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListDISyncTasksOutcomeCallable listDISyncTasksCallable(const Model::ListDISyncTasksRequest& request) const; + ListDagsOutcome listDags(const Model::ListDagsRequest &request)const; + void listDagsAsync(const Model::ListDagsRequest& request, const ListDagsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListDagsOutcomeCallable listDagsCallable(const Model::ListDagsRequest& request) const; ListDataServiceApiAuthoritiesOutcome listDataServiceApiAuthorities(const Model::ListDataServiceApiAuthoritiesRequest &request)const; void listDataServiceApiAuthoritiesAsync(const Model::ListDataServiceApiAuthoritiesRequest& request, const ListDataServiceApiAuthoritiesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListDataServiceApiAuthoritiesOutcomeCallable listDataServiceApiAuthoritiesCallable(const Model::ListDataServiceApiAuthoritiesRequest& request) const; @@ -1615,6 +1657,9 @@ namespace AlibabaCloud ListDataSourcesOutcome listDataSources(const Model::ListDataSourcesRequest &request)const; void listDataSourcesAsync(const Model::ListDataSourcesRequest& request, const ListDataSourcesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListDataSourcesOutcomeCallable listDataSourcesCallable(const Model::ListDataSourcesRequest& request) const; + ListDeploymentsOutcome listDeployments(const Model::ListDeploymentsRequest &request)const; + void listDeploymentsAsync(const Model::ListDeploymentsRequest& request, const ListDeploymentsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListDeploymentsOutcomeCallable listDeploymentsCallable(const Model::ListDeploymentsRequest& request) const; ListFileTypeOutcome listFileType(const Model::ListFileTypeRequest &request)const; void listFileTypeAsync(const Model::ListFileTypeRequest& request, const ListFileTypeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ListFileTypeOutcomeCallable listFileTypeCallable(const Model::ListFileTypeRequest& request) const; @@ -1810,6 +1855,9 @@ namespace AlibabaCloud UpdateFolderOutcome updateFolder(const Model::UpdateFolderRequest &request)const; void updateFolderAsync(const Model::UpdateFolderRequest& request, const UpdateFolderAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; UpdateFolderOutcomeCallable updateFolderCallable(const Model::UpdateFolderRequest& request) const; + UpdateIDEEventResultOutcome updateIDEEventResult(const Model::UpdateIDEEventResultRequest &request)const; + void updateIDEEventResultAsync(const Model::UpdateIDEEventResultRequest& request, const UpdateIDEEventResultAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateIDEEventResultOutcomeCallable updateIDEEventResultCallable(const Model::UpdateIDEEventResultRequest& request) const; UpdateMetaCategoryOutcome updateMetaCategory(const Model::UpdateMetaCategoryRequest &request)const; void updateMetaCategoryAsync(const Model::UpdateMetaCategoryRequest& request, const UpdateMetaCategoryAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; UpdateMetaCategoryOutcomeCallable updateMetaCategoryCallable(const Model::UpdateMetaCategoryRequest& request) const; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/CreateExportMigrationRequest.h b/dataworks-public/include/alibabacloud/dataworks-public/model/CreateExportMigrationRequest.h new file mode 100644 index 000000000..bb3e0f99a --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/CreateExportMigrationRequest.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_DATAWORKS_PUBLIC_MODEL_CREATEEXPORTMIGRATIONREQUEST_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEEXPORTMIGRATIONREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateExportMigrationRequest : public RpcServiceRequest + { + + public: + CreateExportMigrationRequest(); + ~CreateExportMigrationRequest(); + + std::string getExportObjectStatus()const; + void setExportObjectStatus(const std::string& exportObjectStatus); + std::string getExportMode()const; + void setExportMode(const std::string& exportMode); + long getIncrementalSince()const; + void setIncrementalSince(long incrementalSince); + std::string getName()const; + void setName(const std::string& name); + std::string getDescription()const; + void setDescription(const std::string& description); + long getProjectId()const; + void setProjectId(long projectId); + + private: + std::string exportObjectStatus_; + std::string exportMode_; + long incrementalSince_; + std::string name_; + std::string description_; + long projectId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEEXPORTMIGRATIONREQUEST_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/CreateExportMigrationResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/CreateExportMigrationResult.h new file mode 100644 index 000000000..a9b146cd7 --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/CreateExportMigrationResult.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_DATAWORKS_PUBLIC_MODEL_CREATEEXPORTMIGRATIONRESULT_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEEXPORTMIGRATIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateExportMigrationResult : public ServiceResult + { + public: + + + CreateExportMigrationResult(); + explicit CreateExportMigrationResult(const std::string &payload); + ~CreateExportMigrationResult(); + long getData()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + long data_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEEXPORTMIGRATIONRESULT_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetDagResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetDagResult.h index 10cbabf61..69fc33e29 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/GetDagResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetDagResult.h @@ -35,17 +35,18 @@ namespace AlibabaCloud struct Data { std::string status; - long gmtdate; long modifyTime; - std::string type; - long finishTime; long createTime; long projectId; long startTime; std::string createUser; long dagId; - std::string name; long bizdate; + std::string name; + long gmtdate; + std::string type; + long opSeq; + long finishTime; }; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetIDEEventDetailRequest.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetIDEEventDetailRequest.h new file mode 100644 index 000000000..a620aa957 --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetIDEEventDetailRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETIDEEVENTDETAILREQUEST_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETIDEEVENTDETAILREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT GetIDEEventDetailRequest : public RpcServiceRequest + { + + public: + GetIDEEventDetailRequest(); + ~GetIDEEventDetailRequest(); + + std::string getMessageId()const; + void setMessageId(const std::string& messageId); + long getProjectId()const; + void setProjectId(long projectId); + + private: + std::string messageId_; + long projectId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETIDEEVENTDETAILREQUEST_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetIDEEventDetailResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetIDEEventDetailResult.h new file mode 100644 index 000000000..f86f029b1 --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetIDEEventDetailResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETIDEEVENTDETAILRESULT_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETIDEEVENTDETAILRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT GetIDEEventDetailResult : public ServiceResult + { + public: + struct EventDetail + { + struct FileExecutionCommand + { + std::string dataSourceName; + long fileType; + std::string content; + long fileId; + }; + struct DeletedFile + { + long parentFileId; + std::string owner; + long fileType; + std::string dataSourceName; + std::string content; + long currentVersion; + std::string fileName; + std::string useType; + long nodeId; + long fileId; + std::string folderId; + long businessId; + }; + struct CommittedFile + { + struct FilePropertyContent + { + long parentFileId; + std::string owner; + std::string dataSourceName; + long currentVersion; + std::string folderId; + long businessId; + }; + struct NodeConfiguration + { + struct Input + { + std::string input; + std::string parseType; + }; + struct Output + { + std::string output; + std::string refTableName; + }; + std::string cycleType; + std::vector inputList; + std::string dependentNodeIdList; + long resourceGroupId; + long autoRerunIntervalMillis; + std::string dependentType; + long autoRerunTimes; + std::string rerunMode; + std::string schedulerType; + std::string paraValue; + std::string cronExpress; + std::vector outputList; + }; + std::string committor; + std::string comment; + long fileType; + std::string changeType; + std::string content; + FilePropertyContent filePropertyContent; + std::string fileName; + std::string useType; + long nodeId; + long fileId; + NodeConfiguration nodeConfiguration; + }; + struct TableModel + { + struct Column + { + std::string columnName; + std::string comment; + std::string columnType; + bool isPartitionColumn; + }; + long lifeCycle; + std::string tableName; + std::string comment; + std::string dataSourceName; + std::vector columns; + std::string env; + std::string location; + }; + CommittedFile committedFile; + DeletedFile deletedFile; + FileExecutionCommand fileExecutionCommand; + TableModel tableModel; + }; + + + GetIDEEventDetailResult(); + explicit GetIDEEventDetailResult(const std::string &payload); + ~GetIDEEventDetailResult(); + EventDetail getEventDetail()const; + + protected: + void parse(const std::string &payload); + private: + EventDetail eventDetail_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETIDEEVENTDETAILRESULT_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceResult.h index f62ae9ce2..0addd6625 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceResult.h @@ -40,11 +40,11 @@ namespace AlibabaCloud std::string nodeName; std::string paramValues; long dagId; - long bizdate; long beginRunningTime; + long bizdate; long finishTime; - std::string dqcDescription; std::string taskType; + std::string dqcDescription; long businessId; std::string status; int taskRerunTime; @@ -53,6 +53,7 @@ namespace AlibabaCloud int dqcType; long createTime; std::string connection; + std::string createUser; long relatedFlowId; long cycTime; long beginWaitTimeTime; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceStatusStatisticRequest.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceStatusStatisticRequest.h index 869012fce..712cd7f84 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceStatusStatisticRequest.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceStatusStatisticRequest.h @@ -37,14 +37,20 @@ namespace AlibabaCloud std::string getProjectEnv()const; void setProjectEnv(const std::string& projectEnv); + std::string getDagType()const; + void setDagType(const std::string& dagType); std::string getBizDate()const; void setBizDate(const std::string& bizDate); + std::string getSchedulerType()const; + void setSchedulerType(const std::string& schedulerType); long getProjectId()const; void setProjectId(long projectId); private: std::string projectEnv_; + std::string dagType_; std::string bizDate_; + std::string schedulerType_; long projectId_; }; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceStatusStatisticResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceStatusStatisticResult.h index a39c23aa2..1e8b3f0bc 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceStatusStatisticResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceStatusStatisticResult.h @@ -35,11 +35,11 @@ namespace AlibabaCloud struct StatusCount { int totalCount; - int runningCount; int failureCount; + int runningCount; int waitResCount; - int notRunCount; int successCount; + int notRunCount; int waitTimeCount; }; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesResult.h index 197e3be45..5e5a211ef 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesResult.h @@ -41,6 +41,7 @@ namespace AlibabaCloud std::string nodeName; long createTime; std::string paramValues; + std::string createUser; long cycTime; long beginWaitTimeTime; long dagId; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetMetaTableColumnResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetMetaTableColumnResult.h index 16a84a898..cbc9f0999 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/GetMetaTableColumnResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetMetaTableColumnResult.h @@ -43,6 +43,7 @@ namespace AlibabaCloud bool isPartitionColumn; int position; bool isForeignKey; + long relationCount; std::string caption; bool isPrimaryKey; }; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetMetaTableLineageResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetMetaTableLineageResult.h index 5742d3b3c..c7d9abf5a 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/GetMetaTableLineageResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetMetaTableLineageResult.h @@ -38,6 +38,7 @@ namespace AlibabaCloud { std::string tableName; std::string tableGuid; + long createTimestamp; }; std::vector dataEntityList; bool hasNext; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetMigrationSummaryRequest.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetMigrationSummaryRequest.h new file mode 100644 index 000000000..cad2498b0 --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetMigrationSummaryRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMIGRATIONSUMMARYREQUEST_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMIGRATIONSUMMARYREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT GetMigrationSummaryRequest : public RpcServiceRequest + { + + public: + GetMigrationSummaryRequest(); + ~GetMigrationSummaryRequest(); + + long getMigrationId()const; + void setMigrationId(long migrationId); + long getProjectId()const; + void setProjectId(long projectId); + + private: + long migrationId_; + long projectId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMIGRATIONSUMMARYREQUEST_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetMigrationSummaryResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetMigrationSummaryResult.h new file mode 100644 index 000000000..6c035c93b --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetMigrationSummaryResult.h @@ -0,0 +1,65 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMIGRATIONSUMMARYRESULT_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMIGRATIONSUMMARYRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT GetMigrationSummaryResult : public ServiceResult + { + public: + struct Data + { + std::string status; + long gmtCreate; + long gmtModified; + long projectId; + std::string createUser; + long migrationId; + std::string opUser; + std::string name; + std::string downloadUrl; + }; + + + GetMigrationSummaryResult(); + explicit GetMigrationSummaryResult(const std::string &payload); + ~GetMigrationSummaryResult(); + Data getData()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + Data data_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMIGRATIONSUMMARYRESULT_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetNodeChildrenResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetNodeChildrenResult.h index 06afd406a..73dfe3744 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/GetNodeChildrenResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetNodeChildrenResult.h @@ -41,8 +41,8 @@ namespace AlibabaCloud std::string ownerId; std::string nodeName; int priority; - long nodeId; long projectId; + long nodeId; std::string schedulerType; std::string programType; std::string cronExpress; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetNodeParentsResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetNodeParentsResult.h index 84a3b50a1..862efab52 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/GetNodeParentsResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetNodeParentsResult.h @@ -41,8 +41,8 @@ namespace AlibabaCloud std::string ownerId; std::string nodeName; int priority; - long nodeId; long projectId; + long nodeId; std::string schedulerType; std::string programType; std::string cronExpress; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetQualityRuleResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetQualityRuleResult.h index 4559c933e..60034726b 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/GetQualityRuleResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetQualityRuleResult.h @@ -50,13 +50,13 @@ namespace AlibabaCloud bool fixCheck; int blockType; std::string onDutyAccountName; - std::string templateName; int predictType; - long id; + std::string templateName; std::string methodName; + long id; std::string property; - int templateId; std::string ruleName; + int templateId; }; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/ListDagsRequest.h b/dataworks-public/include/alibabacloud/dataworks-public/model/ListDagsRequest.h new file mode 100644 index 000000000..40a474763 --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/ListDagsRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDAGSREQUEST_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDAGSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT ListDagsRequest : public RpcServiceRequest + { + + public: + ListDagsRequest(); + ~ListDagsRequest(); + + std::string getProjectEnv()const; + void setProjectEnv(const std::string& projectEnv); + long getOpSeq()const; + void setOpSeq(long opSeq); + + private: + std::string projectEnv_; + long opSeq_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDAGSREQUEST_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/ListDagsResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/ListDagsResult.h new file mode 100644 index 000000000..32eaed8e8 --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/ListDagsResult.h @@ -0,0 +1,79 @@ +/* + * 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_DATAWORKS_PUBLIC_MODEL_LISTDAGSRESULT_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDAGSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT ListDagsResult : public ServiceResult + { + public: + struct Data + { + struct Dag + { + std::string status; + long modifyTime; + long createTime; + long projectId; + long startTime; + std::string createUser; + long dagId; + long bizdate; + std::string name; + long gmtdate; + std::string type; + long opSeq; + long finishTime; + }; + std::vector dags; + }; + + + ListDagsResult(); + explicit ListDagsResult(const std::string &payload); + ~ListDagsResult(); + int getHttpStatusCode()const; + Data getData()const; + std::string getErrorCode()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + int httpStatusCode_; + Data data_; + std::string errorCode_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDAGSRESULT_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/ListDeploymentsRequest.h b/dataworks-public/include/alibabacloud/dataworks-public/model/ListDeploymentsRequest.h new file mode 100644 index 000000000..b7c355edf --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/ListDeploymentsRequest.h @@ -0,0 +1,75 @@ +/* + * 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_DATAWORKS_PUBLIC_MODEL_LISTDEPLOYMENTSREQUEST_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDEPLOYMENTSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT ListDeploymentsRequest : public RpcServiceRequest + { + + public: + ListDeploymentsRequest(); + ~ListDeploymentsRequest(); + + std::string getCreator()const; + void setCreator(const std::string& creator); + long getEndCreateTime()const; + void setEndCreateTime(long endCreateTime); + std::string getProjectIdentifier()const; + void setProjectIdentifier(const std::string& projectIdentifier); + int getPageNumber()const; + void setPageNumber(int pageNumber); + std::string getExecutor()const; + void setExecutor(const std::string& executor); + int getPageSize()const; + void setPageSize(int pageSize); + long getEndExecuteTime()const; + void setEndExecuteTime(long endExecuteTime); + std::string getKeyword()const; + void setKeyword(const std::string& keyword); + long getProjectId()const; + void setProjectId(long projectId); + int getStatus()const; + void setStatus(int status); + + private: + std::string creator_; + long endCreateTime_; + std::string projectIdentifier_; + int pageNumber_; + std::string executor_; + int pageSize_; + long endExecuteTime_; + std::string keyword_; + long projectId_; + int status_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDEPLOYMENTSREQUEST_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/ListDeploymentsResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/ListDeploymentsResult.h new file mode 100644 index 000000000..e4d3f157d --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/ListDeploymentsResult.h @@ -0,0 +1,69 @@ +/* + * 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_DATAWORKS_PUBLIC_MODEL_LISTDEPLOYMENTSRESULT_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDEPLOYMENTSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT ListDeploymentsResult : public ServiceResult + { + public: + struct Data + { + struct Deployment + { + int status; + std::string executor; + long executeTime; + long createTime; + std::string creator; + long id; + std::string errorMessage; + std::string name; + }; + long totalCount; + long pageSize; + long pageNumber; + std::vector deployments; + }; + + + ListDeploymentsResult(); + explicit ListDeploymentsResult(const std::string &payload); + ~ListDeploymentsResult(); + Data getData()const; + + protected: + void parse(const std::string &payload); + private: + Data data_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_LISTDEPLOYMENTSRESULT_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/ListInstancesResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/ListInstancesResult.h index 4a18c70b4..f9d247dec 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/ListInstancesResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/ListInstancesResult.h @@ -42,11 +42,11 @@ namespace AlibabaCloud std::string nodeName; std::string paramValues; long dagId; - long bizdate; long beginRunningTime; + long bizdate; long finishTime; - std::string dqcDescription; std::string taskType; + std::string dqcDescription; long businessId; std::string status; int taskRerunTime; @@ -55,6 +55,7 @@ namespace AlibabaCloud int dqcType; long createTime; std::string connection; + std::string createUser; long relatedFlowId; long cycTime; long beginWaitTimeTime; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/ListManualDagInstancesResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/ListManualDagInstancesResult.h index 65fc4564b..6c996a4a7 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/ListManualDagInstancesResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/ListManualDagInstancesResult.h @@ -41,6 +41,7 @@ namespace AlibabaCloud std::string nodeName; long createTime; std::string paramValues; + std::string createUser; long cycTime; long beginWaitTimeTime; long dagId; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/ListQualityResultsByEntityResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/ListQualityResultsByEntityResult.h index beae895ad..901c5c046 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/ListQualityResultsByEntityResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/ListQualityResultsByEntityResult.h @@ -40,44 +40,44 @@ namespace AlibabaCloud { int singleCheckResult; float value; - std::string bizDate; std::string discreteProperty; + std::string bizDate; float threshold; }; struct SampleValueItem { float value; - std::string bizDate; std::string discreteProperty; + std::string bizDate; }; std::string op; std::vector sampleValue; std::string taskId; - long endTime; - bool discreteCheck; std::string checkerName; - float expectValue; + bool discreteCheck; + long endTime; std::string projectName; + float expectValue; std::vector referenceValue; - int ruleId; float warningThreshold; - std::string whereCondition; + int ruleId; long beginTime; + std::string whereCondition; int checkResultStatus; std::string matchExpression; float upperValue; bool isPrediction; int checkResult; std::string templateName; - std::string timeCost; bool fixedCheck; + std::string timeCost; std::string methodName; std::string resultString; std::string property; std::string dateType; long bizDate; - int templateId; std::string ruleName; + int templateId; std::string comment; float criticalThreshold; std::string externalId; @@ -88,8 +88,8 @@ namespace AlibabaCloud int entityId; std::string tableName; int blockType; - int id; std::string actualExpression; + int id; float lowerValue; }; long totalCount; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/ListQualityResultsByRuleResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/ListQualityResultsByRuleResult.h index 8c9afdd69..3cbbe3361 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/ListQualityResultsByRuleResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/ListQualityResultsByRuleResult.h @@ -40,44 +40,44 @@ namespace AlibabaCloud { int singleCheckResult; float value; - std::string bizDate; std::string discreteProperty; + std::string bizDate; float threshold; }; struct SampleValueItem { float value; - std::string bizDate; std::string discreteProperty; + std::string bizDate; }; std::string op; std::vector sampleValue; std::string taskId; - long endTime; - bool discreteCheck; std::string checkerName; - float expectValue; + bool discreteCheck; + long endTime; std::string projectName; + float expectValue; std::vector referenceValue; - int ruleId; float warningThreshold; - std::string whereCondition; + int ruleId; long beginTime; + std::string whereCondition; int checkResultStatus; std::string matchExpression; float upperValue; bool isPrediction; int checkResult; std::string templateName; - std::string timeCost; bool fixedCheck; + std::string timeCost; std::string methodName; std::string resultString; std::string property; std::string dateType; long bizDate; - int templateId; std::string ruleName; + int templateId; std::string comment; float criticalThreshold; std::string externalId; @@ -88,8 +88,8 @@ namespace AlibabaCloud int entityId; std::string tableName; int blockType; - int id; std::string actualExpression; + int id; float lowerValue; }; long totalCount; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/ListQualityRulesResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/ListQualityRulesResult.h index 6ab8bb74f..41a6b494f 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/ListQualityRulesResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/ListQualityRulesResult.h @@ -49,6 +49,7 @@ namespace AlibabaCloud std::string methodName; std::string property; int templateId; + std::string ruleName; std::string comment; std::string criticalThreshold; std::string trend; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/UpdateIDEEventResultRequest.h b/dataworks-public/include/alibabacloud/dataworks-public/model/UpdateIDEEventResultRequest.h new file mode 100644 index 000000000..23adbf906 --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/UpdateIDEEventResultRequest.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_DATAWORKS_PUBLIC_MODEL_UPDATEIDEEVENTRESULTREQUEST_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATEIDEEVENTRESULTREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT UpdateIDEEventResultRequest : public RpcServiceRequest + { + + public: + UpdateIDEEventResultRequest(); + ~UpdateIDEEventResultRequest(); + + std::string getCheckResultTip()const; + void setCheckResultTip(const std::string& checkResultTip); + std::string getCheckResult()const; + void setCheckResult(const std::string& checkResult); + std::string getMessageId()const; + void setMessageId(const std::string& messageId); + std::string getExtensionCode()const; + void setExtensionCode(const std::string& extensionCode); + + private: + std::string checkResultTip_; + std::string checkResult_; + std::string messageId_; + std::string extensionCode_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATEIDEEVENTRESULTREQUEST_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/UpdateIDEEventResultResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/UpdateIDEEventResultResult.h new file mode 100644 index 000000000..82f79e9af --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/UpdateIDEEventResultResult.h @@ -0,0 +1,49 @@ +/* + * 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_DATAWORKS_PUBLIC_MODEL_UPDATEIDEEVENTRESULTRESULT_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATEIDEEVENTRESULTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT UpdateIDEEventResultResult : public ServiceResult + { + public: + + + UpdateIDEEventResultResult(); + explicit UpdateIDEEventResultResult(const std::string &payload); + ~UpdateIDEEventResultResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_UPDATEIDEEVENTRESULTRESULT_H_ \ No newline at end of file diff --git a/dataworks-public/src/Dataworks-publicClient.cc b/dataworks-public/src/Dataworks-publicClient.cc index 5e404e43c..556e3f66c 100644 --- a/dataworks-public/src/Dataworks-publicClient.cc +++ b/dataworks-public/src/Dataworks-publicClient.cc @@ -771,6 +771,42 @@ Dataworks_publicClient::CreateDataSourceOutcomeCallable Dataworks_publicClient:: return task->get_future(); } +Dataworks_publicClient::CreateExportMigrationOutcome Dataworks_publicClient::createExportMigration(const CreateExportMigrationRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateExportMigrationOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateExportMigrationOutcome(CreateExportMigrationResult(outcome.result())); + else + return CreateExportMigrationOutcome(outcome.error()); +} + +void Dataworks_publicClient::createExportMigrationAsync(const CreateExportMigrationRequest& request, const CreateExportMigrationAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createExportMigration(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Dataworks_publicClient::CreateExportMigrationOutcomeCallable Dataworks_publicClient::createExportMigrationCallable(const CreateExportMigrationRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createExportMigration(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Dataworks_publicClient::CreateFileOutcome Dataworks_publicClient::createFile(const CreateFileRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -3183,6 +3219,42 @@ Dataworks_publicClient::GetFolderOutcomeCallable Dataworks_publicClient::getFold return task->get_future(); } +Dataworks_publicClient::GetIDEEventDetailOutcome Dataworks_publicClient::getIDEEventDetail(const GetIDEEventDetailRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetIDEEventDetailOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetIDEEventDetailOutcome(GetIDEEventDetailResult(outcome.result())); + else + return GetIDEEventDetailOutcome(outcome.error()); +} + +void Dataworks_publicClient::getIDEEventDetailAsync(const GetIDEEventDetailRequest& request, const GetIDEEventDetailAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getIDEEventDetail(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Dataworks_publicClient::GetIDEEventDetailOutcomeCallable Dataworks_publicClient::getIDEEventDetailCallable(const GetIDEEventDetailRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getIDEEventDetail(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Dataworks_publicClient::GetInstanceOutcome Dataworks_publicClient::getInstance(const GetInstanceRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -4011,6 +4083,42 @@ Dataworks_publicClient::GetMigrationProcessOutcomeCallable Dataworks_publicClien return task->get_future(); } +Dataworks_publicClient::GetMigrationSummaryOutcome Dataworks_publicClient::getMigrationSummary(const GetMigrationSummaryRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetMigrationSummaryOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetMigrationSummaryOutcome(GetMigrationSummaryResult(outcome.result())); + else + return GetMigrationSummaryOutcome(outcome.error()); +} + +void Dataworks_publicClient::getMigrationSummaryAsync(const GetMigrationSummaryRequest& request, const GetMigrationSummaryAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getMigrationSummary(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Dataworks_publicClient::GetMigrationSummaryOutcomeCallable Dataworks_publicClient::getMigrationSummaryCallable(const GetMigrationSummaryRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getMigrationSummary(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Dataworks_publicClient::GetNodeOutcome Dataworks_publicClient::getNode(const GetNodeRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -5091,6 +5199,42 @@ Dataworks_publicClient::ListDISyncTasksOutcomeCallable Dataworks_publicClient::l return task->get_future(); } +Dataworks_publicClient::ListDagsOutcome Dataworks_publicClient::listDags(const ListDagsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListDagsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListDagsOutcome(ListDagsResult(outcome.result())); + else + return ListDagsOutcome(outcome.error()); +} + +void Dataworks_publicClient::listDagsAsync(const ListDagsRequest& request, const ListDagsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listDags(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Dataworks_publicClient::ListDagsOutcomeCallable Dataworks_publicClient::listDagsCallable(const ListDagsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listDags(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Dataworks_publicClient::ListDataServiceApiAuthoritiesOutcome Dataworks_publicClient::listDataServiceApiAuthorities(const ListDataServiceApiAuthoritiesRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -5379,6 +5523,42 @@ Dataworks_publicClient::ListDataSourcesOutcomeCallable Dataworks_publicClient::l return task->get_future(); } +Dataworks_publicClient::ListDeploymentsOutcome Dataworks_publicClient::listDeployments(const ListDeploymentsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListDeploymentsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListDeploymentsOutcome(ListDeploymentsResult(outcome.result())); + else + return ListDeploymentsOutcome(outcome.error()); +} + +void Dataworks_publicClient::listDeploymentsAsync(const ListDeploymentsRequest& request, const ListDeploymentsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listDeployments(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Dataworks_publicClient::ListDeploymentsOutcomeCallable Dataworks_publicClient::listDeploymentsCallable(const ListDeploymentsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listDeployments(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Dataworks_publicClient::ListFileTypeOutcome Dataworks_publicClient::listFileType(const ListFileTypeRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -7719,6 +7899,42 @@ Dataworks_publicClient::UpdateFolderOutcomeCallable Dataworks_publicClient::upda return task->get_future(); } +Dataworks_publicClient::UpdateIDEEventResultOutcome Dataworks_publicClient::updateIDEEventResult(const UpdateIDEEventResultRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateIDEEventResultOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateIDEEventResultOutcome(UpdateIDEEventResultResult(outcome.result())); + else + return UpdateIDEEventResultOutcome(outcome.error()); +} + +void Dataworks_publicClient::updateIDEEventResultAsync(const UpdateIDEEventResultRequest& request, const UpdateIDEEventResultAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateIDEEventResult(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Dataworks_publicClient::UpdateIDEEventResultOutcomeCallable Dataworks_publicClient::updateIDEEventResultCallable(const UpdateIDEEventResultRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateIDEEventResult(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Dataworks_publicClient::UpdateMetaCategoryOutcome Dataworks_publicClient::updateMetaCategory(const UpdateMetaCategoryRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/dataworks-public/src/model/CreateExportMigrationRequest.cc b/dataworks-public/src/model/CreateExportMigrationRequest.cc new file mode 100644 index 000000000..d12b02f48 --- /dev/null +++ b/dataworks-public/src/model/CreateExportMigrationRequest.cc @@ -0,0 +1,95 @@ +/* + * 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::Dataworks_public::Model::CreateExportMigrationRequest; + +CreateExportMigrationRequest::CreateExportMigrationRequest() : + RpcServiceRequest("dataworks-public", "2020-05-18", "CreateExportMigration") +{ + setMethod(HttpRequest::Method::Post); +} + +CreateExportMigrationRequest::~CreateExportMigrationRequest() +{} + +std::string CreateExportMigrationRequest::getExportObjectStatus()const +{ + return exportObjectStatus_; +} + +void CreateExportMigrationRequest::setExportObjectStatus(const std::string& exportObjectStatus) +{ + exportObjectStatus_ = exportObjectStatus; + setBodyParameter("ExportObjectStatus", exportObjectStatus); +} + +std::string CreateExportMigrationRequest::getExportMode()const +{ + return exportMode_; +} + +void CreateExportMigrationRequest::setExportMode(const std::string& exportMode) +{ + exportMode_ = exportMode; + setBodyParameter("ExportMode", exportMode); +} + +long CreateExportMigrationRequest::getIncrementalSince()const +{ + return incrementalSince_; +} + +void CreateExportMigrationRequest::setIncrementalSince(long incrementalSince) +{ + incrementalSince_ = incrementalSince; + setBodyParameter("IncrementalSince", std::to_string(incrementalSince)); +} + +std::string CreateExportMigrationRequest::getName()const +{ + return name_; +} + +void CreateExportMigrationRequest::setName(const std::string& name) +{ + name_ = name; + setBodyParameter("Name", name); +} + +std::string CreateExportMigrationRequest::getDescription()const +{ + return description_; +} + +void CreateExportMigrationRequest::setDescription(const std::string& description) +{ + description_ = description; + setBodyParameter("Description", description); +} + +long CreateExportMigrationRequest::getProjectId()const +{ + return projectId_; +} + +void CreateExportMigrationRequest::setProjectId(long projectId) +{ + projectId_ = projectId; + setBodyParameter("ProjectId", std::to_string(projectId)); +} + diff --git a/dataworks-public/src/model/CreateExportMigrationResult.cc b/dataworks-public/src/model/CreateExportMigrationResult.cc new file mode 100644 index 000000000..73523ef74 --- /dev/null +++ b/dataworks-public/src/model/CreateExportMigrationResult.cc @@ -0,0 +1,58 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Dataworks_public; +using namespace AlibabaCloud::Dataworks_public::Model; + +CreateExportMigrationResult::CreateExportMigrationResult() : + ServiceResult() +{} + +CreateExportMigrationResult::CreateExportMigrationResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateExportMigrationResult::~CreateExportMigrationResult() +{} + +void CreateExportMigrationResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Data"].isNull()) + data_ = std::stol(value["Data"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +long CreateExportMigrationResult::getData()const +{ + return data_; +} + +bool CreateExportMigrationResult::getSuccess()const +{ + return success_; +} + diff --git a/dataworks-public/src/model/CreateQualityEntityResult.cc b/dataworks-public/src/model/CreateQualityEntityResult.cc index 923fcc747..52efe46b1 100644 --- a/dataworks-public/src/model/CreateQualityEntityResult.cc +++ b/dataworks-public/src/model/CreateQualityEntityResult.cc @@ -39,16 +39,16 @@ void CreateQualityEntityResult::parse(const std::string &payload) Json::Value value; reader.parse(payload, value); setRequestId(value["RequestId"].asString()); - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; - if(!value["Data"].isNull()) - data_ = std::stoi(value["Data"].asString()); - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); - if(!value["ErrorMessage"].isNull()) - errorMessage_ = value["ErrorMessage"].asString(); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + if(!value["Data"].isNull()) + data_ = std::stoi(value["Data"].asString()); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); } diff --git a/dataworks-public/src/model/CreateQualityFollowerResult.cc b/dataworks-public/src/model/CreateQualityFollowerResult.cc index f238e3b39..69a371ec3 100644 --- a/dataworks-public/src/model/CreateQualityFollowerResult.cc +++ b/dataworks-public/src/model/CreateQualityFollowerResult.cc @@ -39,16 +39,16 @@ void CreateQualityFollowerResult::parse(const std::string &payload) Json::Value value; reader.parse(payload, value); setRequestId(value["RequestId"].asString()); - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); - if(!value["Data"].isNull()) - data_ = std::stoi(value["Data"].asString()); - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; - if(!value["ErrorMessage"].isNull()) - errorMessage_ = value["ErrorMessage"].asString(); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + if(!value["Data"].isNull()) + data_ = std::stoi(value["Data"].asString()); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; } diff --git a/dataworks-public/src/model/CreateQualityRelativeNodeResult.cc b/dataworks-public/src/model/CreateQualityRelativeNodeResult.cc index ba3b1afce..465cdce2f 100644 --- a/dataworks-public/src/model/CreateQualityRelativeNodeResult.cc +++ b/dataworks-public/src/model/CreateQualityRelativeNodeResult.cc @@ -39,16 +39,16 @@ void CreateQualityRelativeNodeResult::parse(const std::string &payload) Json::Value value; reader.parse(payload, value); setRequestId(value["RequestId"].asString()); - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); - if(!value["ErrorMessage"].isNull()) - errorMessage_ = value["ErrorMessage"].asString(); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); if(!value["Data"].isNull()) data_ = value["Data"].asString() == "true"; + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); } diff --git a/dataworks-public/src/model/CreateQualityRuleResult.cc b/dataworks-public/src/model/CreateQualityRuleResult.cc index b36e1932d..5dbfdac47 100644 --- a/dataworks-public/src/model/CreateQualityRuleResult.cc +++ b/dataworks-public/src/model/CreateQualityRuleResult.cc @@ -39,16 +39,16 @@ void CreateQualityRuleResult::parse(const std::string &payload) Json::Value value; reader.parse(payload, value); setRequestId(value["RequestId"].asString()); - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); - if(!value["Data"].isNull()) - data_ = value["Data"].asString(); - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; - if(!value["ErrorMessage"].isNull()) - errorMessage_ = value["ErrorMessage"].asString(); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + if(!value["Data"].isNull()) + data_ = value["Data"].asString(); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; } diff --git a/dataworks-public/src/model/CreateTableResult.cc b/dataworks-public/src/model/CreateTableResult.cc index a652bb35d..bf60e47c1 100644 --- a/dataworks-public/src/model/CreateTableResult.cc +++ b/dataworks-public/src/model/CreateTableResult.cc @@ -40,14 +40,14 @@ void CreateTableResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto taskInfoNode = value["TaskInfo"]; - if(!taskInfoNode["TaskId"].isNull()) - taskInfo_.taskId = taskInfoNode["TaskId"].asString(); - if(!taskInfoNode["Content"].isNull()) - taskInfo_.content = taskInfoNode["Content"].asString(); if(!taskInfoNode["Status"].isNull()) taskInfo_.status = taskInfoNode["Status"].asString(); if(!taskInfoNode["NextTaskId"].isNull()) taskInfo_.nextTaskId = taskInfoNode["NextTaskId"].asString(); + if(!taskInfoNode["TaskId"].isNull()) + taskInfo_.taskId = taskInfoNode["TaskId"].asString(); + if(!taskInfoNode["Content"].isNull()) + taskInfo_.content = taskInfoNode["Content"].asString(); } diff --git a/dataworks-public/src/model/DeleteQualityEntityResult.cc b/dataworks-public/src/model/DeleteQualityEntityResult.cc index 4fb61fb09..99684885c 100644 --- a/dataworks-public/src/model/DeleteQualityEntityResult.cc +++ b/dataworks-public/src/model/DeleteQualityEntityResult.cc @@ -39,16 +39,16 @@ void DeleteQualityEntityResult::parse(const std::string &payload) Json::Value value; reader.parse(payload, value); setRequestId(value["RequestId"].asString()); - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); - if(!value["ErrorMessage"].isNull()) - errorMessage_ = value["ErrorMessage"].asString(); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); if(!value["Data"].isNull()) data_ = value["Data"].asString() == "true"; + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); } diff --git a/dataworks-public/src/model/DeleteQualityRelativeNodeResult.cc b/dataworks-public/src/model/DeleteQualityRelativeNodeResult.cc index c7f27f1e1..bd5bef657 100644 --- a/dataworks-public/src/model/DeleteQualityRelativeNodeResult.cc +++ b/dataworks-public/src/model/DeleteQualityRelativeNodeResult.cc @@ -39,16 +39,16 @@ void DeleteQualityRelativeNodeResult::parse(const std::string &payload) Json::Value value; reader.parse(payload, value); setRequestId(value["RequestId"].asString()); - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); - if(!value["ErrorMessage"].isNull()) - errorMessage_ = value["ErrorMessage"].asString(); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); if(!value["Data"].isNull()) data_ = value["Data"].asString() == "true"; + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); } diff --git a/dataworks-public/src/model/GetDagResult.cc b/dataworks-public/src/model/GetDagResult.cc index 3600a214f..ea5bf38a5 100644 --- a/dataworks-public/src/model/GetDagResult.cc +++ b/dataworks-public/src/model/GetDagResult.cc @@ -40,38 +40,40 @@ void GetDagResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto dataNode = value["Data"]; - if(!dataNode["ProjectId"].isNull()) - data_.projectId = std::stol(dataNode["ProjectId"].asString()); - if(!dataNode["DagId"].isNull()) - data_.dagId = std::stol(dataNode["DagId"].asString()); - if(!dataNode["Name"].isNull()) - data_.name = dataNode["Name"].asString(); if(!dataNode["Type"].isNull()) data_.type = dataNode["Type"].asString(); if(!dataNode["Status"].isNull()) data_.status = dataNode["Status"].asString(); - if(!dataNode["Bizdate"].isNull()) - data_.bizdate = std::stol(dataNode["Bizdate"].asString()); - if(!dataNode["Gmtdate"].isNull()) - data_.gmtdate = std::stol(dataNode["Gmtdate"].asString()); - if(!dataNode["StartTime"].isNull()) - data_.startTime = std::stol(dataNode["StartTime"].asString()); if(!dataNode["FinishTime"].isNull()) data_.finishTime = std::stol(dataNode["FinishTime"].asString()); if(!dataNode["CreateTime"].isNull()) data_.createTime = std::stol(dataNode["CreateTime"].asString()); + if(!dataNode["ProjectId"].isNull()) + data_.projectId = std::stol(dataNode["ProjectId"].asString()); + if(!dataNode["DagId"].isNull()) + data_.dagId = std::stol(dataNode["DagId"].asString()); + if(!dataNode["Gmtdate"].isNull()) + data_.gmtdate = std::stol(dataNode["Gmtdate"].asString()); + if(!dataNode["StartTime"].isNull()) + data_.startTime = std::stol(dataNode["StartTime"].asString()); if(!dataNode["CreateUser"].isNull()) data_.createUser = dataNode["CreateUser"].asString(); + if(!dataNode["Bizdate"].isNull()) + data_.bizdate = std::stol(dataNode["Bizdate"].asString()); + if(!dataNode["Name"].isNull()) + data_.name = dataNode["Name"].asString(); if(!dataNode["ModifyTime"].isNull()) data_.modifyTime = std::stol(dataNode["ModifyTime"].asString()); - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; + if(!dataNode["OpSeq"].isNull()) + data_.opSeq = std::stol(dataNode["OpSeq"].asString()); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); if(!value["ErrorMessage"].isNull()) errorMessage_ = value["ErrorMessage"].asString(); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; } diff --git a/dataworks-public/src/model/GetIDEEventDetailRequest.cc b/dataworks-public/src/model/GetIDEEventDetailRequest.cc new file mode 100644 index 000000000..e5a805d4c --- /dev/null +++ b/dataworks-public/src/model/GetIDEEventDetailRequest.cc @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Dataworks_public::Model::GetIDEEventDetailRequest; + +GetIDEEventDetailRequest::GetIDEEventDetailRequest() : + RpcServiceRequest("dataworks-public", "2020-05-18", "GetIDEEventDetail") +{ + setMethod(HttpRequest::Method::Post); +} + +GetIDEEventDetailRequest::~GetIDEEventDetailRequest() +{} + +std::string GetIDEEventDetailRequest::getMessageId()const +{ + return messageId_; +} + +void GetIDEEventDetailRequest::setMessageId(const std::string& messageId) +{ + messageId_ = messageId; + setBodyParameter("MessageId", messageId); +} + +long GetIDEEventDetailRequest::getProjectId()const +{ + return projectId_; +} + +void GetIDEEventDetailRequest::setProjectId(long projectId) +{ + projectId_ = projectId; + setBodyParameter("ProjectId", std::to_string(projectId)); +} + diff --git a/dataworks-public/src/model/GetIDEEventDetailResult.cc b/dataworks-public/src/model/GetIDEEventDetailResult.cc new file mode 100644 index 000000000..ed4d95fae --- /dev/null +++ b/dataworks-public/src/model/GetIDEEventDetailResult.cc @@ -0,0 +1,184 @@ +/* + * 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::Dataworks_public; +using namespace AlibabaCloud::Dataworks_public::Model; + +GetIDEEventDetailResult::GetIDEEventDetailResult() : + ServiceResult() +{} + +GetIDEEventDetailResult::GetIDEEventDetailResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetIDEEventDetailResult::~GetIDEEventDetailResult() +{} + +void GetIDEEventDetailResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto eventDetailNode = value["EventDetail"]; + auto fileExecutionCommandNode = eventDetailNode["FileExecutionCommand"]; + if(!fileExecutionCommandNode["FileId"].isNull()) + eventDetail_.fileExecutionCommand.fileId = std::stol(fileExecutionCommandNode["FileId"].asString()); + if(!fileExecutionCommandNode["DataSourceName"].isNull()) + eventDetail_.fileExecutionCommand.dataSourceName = fileExecutionCommandNode["DataSourceName"].asString(); + if(!fileExecutionCommandNode["Content"].isNull()) + eventDetail_.fileExecutionCommand.content = fileExecutionCommandNode["Content"].asString(); + if(!fileExecutionCommandNode["FileType"].isNull()) + eventDetail_.fileExecutionCommand.fileType = std::stol(fileExecutionCommandNode["FileType"].asString()); + auto deletedFileNode = eventDetailNode["DeletedFile"]; + if(!deletedFileNode["Owner"].isNull()) + eventDetail_.deletedFile.owner = deletedFileNode["Owner"].asString(); + if(!deletedFileNode["FileType"].isNull()) + eventDetail_.deletedFile.fileType = std::stol(deletedFileNode["FileType"].asString()); + if(!deletedFileNode["CurrentVersion"].isNull()) + eventDetail_.deletedFile.currentVersion = std::stol(deletedFileNode["CurrentVersion"].asString()); + if(!deletedFileNode["BusinessId"].isNull()) + eventDetail_.deletedFile.businessId = std::stol(deletedFileNode["BusinessId"].asString()); + if(!deletedFileNode["FileName"].isNull()) + eventDetail_.deletedFile.fileName = deletedFileNode["FileName"].asString(); + if(!deletedFileNode["DataSourceName"].isNull()) + eventDetail_.deletedFile.dataSourceName = deletedFileNode["DataSourceName"].asString(); + if(!deletedFileNode["UseType"].isNull()) + eventDetail_.deletedFile.useType = deletedFileNode["UseType"].asString(); + if(!deletedFileNode["FolderId"].isNull()) + eventDetail_.deletedFile.folderId = deletedFileNode["FolderId"].asString(); + if(!deletedFileNode["ParentFileId"].isNull()) + eventDetail_.deletedFile.parentFileId = std::stol(deletedFileNode["ParentFileId"].asString()); + if(!deletedFileNode["Content"].isNull()) + eventDetail_.deletedFile.content = deletedFileNode["Content"].asString(); + if(!deletedFileNode["NodeId"].isNull()) + eventDetail_.deletedFile.nodeId = std::stol(deletedFileNode["NodeId"].asString()); + if(!deletedFileNode["FileId"].isNull()) + eventDetail_.deletedFile.fileId = std::stol(deletedFileNode["FileId"].asString()); + auto committedFileNode = eventDetailNode["CommittedFile"]; + if(!committedFileNode["FileId"].isNull()) + eventDetail_.committedFile.fileId = std::stol(committedFileNode["FileId"].asString()); + if(!committedFileNode["Content"].isNull()) + eventDetail_.committedFile.content = committedFileNode["Content"].asString(); + if(!committedFileNode["Committor"].isNull()) + eventDetail_.committedFile.committor = committedFileNode["Committor"].asString(); + if(!committedFileNode["FileType"].isNull()) + eventDetail_.committedFile.fileType = std::stol(committedFileNode["FileType"].asString()); + if(!committedFileNode["ChangeType"].isNull()) + eventDetail_.committedFile.changeType = committedFileNode["ChangeType"].asString(); + if(!committedFileNode["FileName"].isNull()) + eventDetail_.committedFile.fileName = committedFileNode["FileName"].asString(); + if(!committedFileNode["NodeId"].isNull()) + eventDetail_.committedFile.nodeId = std::stol(committedFileNode["NodeId"].asString()); + if(!committedFileNode["Comment"].isNull()) + eventDetail_.committedFile.comment = committedFileNode["Comment"].asString(); + if(!committedFileNode["UseType"].isNull()) + eventDetail_.committedFile.useType = committedFileNode["UseType"].asString(); + auto filePropertyContentNode = committedFileNode["FilePropertyContent"]; + if(!filePropertyContentNode["DataSourceName"].isNull()) + eventDetail_.committedFile.filePropertyContent.dataSourceName = filePropertyContentNode["DataSourceName"].asString(); + if(!filePropertyContentNode["ParentFileId"].isNull()) + eventDetail_.committedFile.filePropertyContent.parentFileId = std::stol(filePropertyContentNode["ParentFileId"].asString()); + if(!filePropertyContentNode["BusinessId"].isNull()) + eventDetail_.committedFile.filePropertyContent.businessId = std::stol(filePropertyContentNode["BusinessId"].asString()); + if(!filePropertyContentNode["CurrentVersion"].isNull()) + eventDetail_.committedFile.filePropertyContent.currentVersion = std::stol(filePropertyContentNode["CurrentVersion"].asString()); + if(!filePropertyContentNode["Owner"].isNull()) + eventDetail_.committedFile.filePropertyContent.owner = filePropertyContentNode["Owner"].asString(); + if(!filePropertyContentNode["FolderId"].isNull()) + eventDetail_.committedFile.filePropertyContent.folderId = filePropertyContentNode["FolderId"].asString(); + auto nodeConfigurationNode = committedFileNode["NodeConfiguration"]; + if(!nodeConfigurationNode["RerunMode"].isNull()) + eventDetail_.committedFile.nodeConfiguration.rerunMode = nodeConfigurationNode["RerunMode"].asString(); + if(!nodeConfigurationNode["SchedulerType"].isNull()) + eventDetail_.committedFile.nodeConfiguration.schedulerType = nodeConfigurationNode["SchedulerType"].asString(); + if(!nodeConfigurationNode["ParaValue"].isNull()) + eventDetail_.committedFile.nodeConfiguration.paraValue = nodeConfigurationNode["ParaValue"].asString(); + if(!nodeConfigurationNode["CycleType"].isNull()) + eventDetail_.committedFile.nodeConfiguration.cycleType = nodeConfigurationNode["CycleType"].asString(); + if(!nodeConfigurationNode["DependentNodeIdList"].isNull()) + eventDetail_.committedFile.nodeConfiguration.dependentNodeIdList = nodeConfigurationNode["DependentNodeIdList"].asString(); + if(!nodeConfigurationNode["ResourceGroupId"].isNull()) + eventDetail_.committedFile.nodeConfiguration.resourceGroupId = std::stol(nodeConfigurationNode["ResourceGroupId"].asString()); + if(!nodeConfigurationNode["AutoRerunTimes"].isNull()) + eventDetail_.committedFile.nodeConfiguration.autoRerunTimes = std::stol(nodeConfigurationNode["AutoRerunTimes"].asString()); + if(!nodeConfigurationNode["AutoRerunIntervalMillis"].isNull()) + eventDetail_.committedFile.nodeConfiguration.autoRerunIntervalMillis = std::stol(nodeConfigurationNode["AutoRerunIntervalMillis"].asString()); + if(!nodeConfigurationNode["CronExpress"].isNull()) + eventDetail_.committedFile.nodeConfiguration.cronExpress = nodeConfigurationNode["CronExpress"].asString(); + if(!nodeConfigurationNode["DependentType"].isNull()) + eventDetail_.committedFile.nodeConfiguration.dependentType = nodeConfigurationNode["DependentType"].asString(); + auto allInputListNode = nodeConfigurationNode["InputList"]["Input"]; + for (auto nodeConfigurationNodeInputListInput : allInputListNode) + { + EventDetail::CommittedFile::NodeConfiguration::Input inputObject; + if(!nodeConfigurationNodeInputListInput["Input"].isNull()) + inputObject.input = nodeConfigurationNodeInputListInput["Input"].asString(); + if(!nodeConfigurationNodeInputListInput["ParseType"].isNull()) + inputObject.parseType = nodeConfigurationNodeInputListInput["ParseType"].asString(); + eventDetail_.committedFile.nodeConfiguration.inputList.push_back(inputObject); + } + auto allOutputListNode = nodeConfigurationNode["OutputList"]["Output"]; + for (auto nodeConfigurationNodeOutputListOutput : allOutputListNode) + { + EventDetail::CommittedFile::NodeConfiguration::Output outputObject; + if(!nodeConfigurationNodeOutputListOutput["RefTableName"].isNull()) + outputObject.refTableName = nodeConfigurationNodeOutputListOutput["RefTableName"].asString(); + if(!nodeConfigurationNodeOutputListOutput["Output"].isNull()) + outputObject.output = nodeConfigurationNodeOutputListOutput["Output"].asString(); + eventDetail_.committedFile.nodeConfiguration.outputList.push_back(outputObject); + } + auto tableModelNode = eventDetailNode["TableModel"]; + if(!tableModelNode["Env"].isNull()) + eventDetail_.tableModel.env = tableModelNode["Env"].asString(); + if(!tableModelNode["LifeCycle"].isNull()) + eventDetail_.tableModel.lifeCycle = std::stol(tableModelNode["LifeCycle"].asString()); + if(!tableModelNode["TableName"].isNull()) + eventDetail_.tableModel.tableName = tableModelNode["TableName"].asString(); + if(!tableModelNode["DataSourceName"].isNull()) + eventDetail_.tableModel.dataSourceName = tableModelNode["DataSourceName"].asString(); + if(!tableModelNode["Comment"].isNull()) + eventDetail_.tableModel.comment = tableModelNode["Comment"].asString(); + if(!tableModelNode["Location"].isNull()) + eventDetail_.tableModel.location = tableModelNode["Location"].asString(); + auto allColumnsNode = tableModelNode["Columns"]["Column"]; + for (auto tableModelNodeColumnsColumn : allColumnsNode) + { + EventDetail::TableModel::Column columnObject; + if(!tableModelNodeColumnsColumn["ColumnName"].isNull()) + columnObject.columnName = tableModelNodeColumnsColumn["ColumnName"].asString(); + if(!tableModelNodeColumnsColumn["ColumnType"].isNull()) + columnObject.columnType = tableModelNodeColumnsColumn["ColumnType"].asString(); + if(!tableModelNodeColumnsColumn["IsPartitionColumn"].isNull()) + columnObject.isPartitionColumn = tableModelNodeColumnsColumn["IsPartitionColumn"].asString() == "true"; + if(!tableModelNodeColumnsColumn["Comment"].isNull()) + columnObject.comment = tableModelNodeColumnsColumn["Comment"].asString(); + eventDetail_.tableModel.columns.push_back(columnObject); + } + +} + +GetIDEEventDetailResult::EventDetail GetIDEEventDetailResult::getEventDetail()const +{ + return eventDetail_; +} + diff --git a/dataworks-public/src/model/GetInstanceResult.cc b/dataworks-public/src/model/GetInstanceResult.cc index 0c703b1c3..fc5d865fb 100644 --- a/dataworks-public/src/model/GetInstanceResult.cc +++ b/dataworks-public/src/model/GetInstanceResult.cc @@ -40,68 +40,70 @@ void GetInstanceResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto dataNode = value["Data"]; - if(!dataNode["NodeId"].isNull()) - data_.nodeId = std::stol(dataNode["NodeId"].asString()); - if(!dataNode["InstanceId"].isNull()) - data_.instanceId = std::stol(dataNode["InstanceId"].asString()); - if(!dataNode["DagId"].isNull()) - data_.dagId = std::stol(dataNode["DagId"].asString()); - if(!dataNode["DagType"].isNull()) - data_.dagType = dataNode["DagType"].asString(); if(!dataNode["Status"].isNull()) data_.status = dataNode["Status"].asString(); - if(!dataNode["Bizdate"].isNull()) - data_.bizdate = std::stol(dataNode["Bizdate"].asString()); - if(!dataNode["ParamValues"].isNull()) - data_.paramValues = dataNode["ParamValues"].asString(); if(!dataNode["CycTime"].isNull()) data_.cycTime = std::stol(dataNode["CycTime"].asString()); - if(!dataNode["FinishTime"].isNull()) - data_.finishTime = std::stol(dataNode["FinishTime"].asString()); - if(!dataNode["BeginWaitTimeTime"].isNull()) - data_.beginWaitTimeTime = std::stol(dataNode["BeginWaitTimeTime"].asString()); - if(!dataNode["BeginWaitResTime"].isNull()) - data_.beginWaitResTime = std::stol(dataNode["BeginWaitResTime"].asString()); if(!dataNode["BeginRunningTime"].isNull()) data_.beginRunningTime = std::stol(dataNode["BeginRunningTime"].asString()); + if(!dataNode["FinishTime"].isNull()) + data_.finishTime = std::stol(dataNode["FinishTime"].asString()); + if(!dataNode["ErrorMessage"].isNull()) + data_.errorMessage = dataNode["ErrorMessage"].asString(); if(!dataNode["CreateTime"].isNull()) data_.createTime = std::stol(dataNode["CreateTime"].asString()); - if(!dataNode["ModifyTime"].isNull()) - data_.modifyTime = std::stol(dataNode["ModifyTime"].asString()); - if(!dataNode["NodeName"].isNull()) - data_.nodeName = dataNode["NodeName"].asString(); + if(!dataNode["DagId"].isNull()) + data_.dagId = std::stol(dataNode["DagId"].asString()); if(!dataNode["Priority"].isNull()) data_.priority = std::stoi(dataNode["Priority"].asString()); + if(!dataNode["TaskType"].isNull()) + data_.taskType = dataNode["TaskType"].asString(); + if(!dataNode["ParamValues"].isNull()) + data_.paramValues = dataNode["ParamValues"].asString(); + if(!dataNode["Connection"].isNull()) + data_.connection = dataNode["Connection"].asString(); if(!dataNode["BaselineId"].isNull()) data_.baselineId = std::stol(dataNode["BaselineId"].asString()); + if(!dataNode["DqcType"].isNull()) + data_.dqcType = std::stoi(dataNode["DqcType"].asString()); + if(!dataNode["DagType"].isNull()) + data_.dagType = dataNode["DagType"].asString(); + if(!dataNode["BusinessId"].isNull()) + data_.businessId = std::stol(dataNode["BusinessId"].asString()); + if(!dataNode["TaskRerunTime"].isNull()) + data_.taskRerunTime = std::stoi(dataNode["TaskRerunTime"].asString()); + if(!dataNode["ModifyTime"].isNull()) + data_.modifyTime = std::stol(dataNode["ModifyTime"].asString()); if(!dataNode["Repeatability"].isNull()) data_.repeatability = dataNode["Repeatability"].asString() == "true"; if(!dataNode["RepeatInterval"].isNull()) data_.repeatInterval = std::stol(dataNode["RepeatInterval"].asString()); - if(!dataNode["Connection"].isNull()) - data_.connection = dataNode["Connection"].asString(); - if(!dataNode["DqcType"].isNull()) - data_.dqcType = std::stoi(dataNode["DqcType"].asString()); - if(!dataNode["DqcDescription"].isNull()) - data_.dqcDescription = dataNode["DqcDescription"].asString(); - if(!dataNode["ErrorMessage"].isNull()) - data_.errorMessage = dataNode["ErrorMessage"].asString(); + if(!dataNode["InstanceId"].isNull()) + data_.instanceId = std::stol(dataNode["InstanceId"].asString()); + if(!dataNode["BeginWaitResTime"].isNull()) + data_.beginWaitResTime = std::stol(dataNode["BeginWaitResTime"].asString()); if(!dataNode["RelatedFlowId"].isNull()) data_.relatedFlowId = std::stol(dataNode["RelatedFlowId"].asString()); - if(!dataNode["TaskType"].isNull()) - data_.taskType = dataNode["TaskType"].asString(); - if(!dataNode["TaskRerunTime"].isNull()) - data_.taskRerunTime = std::stoi(dataNode["TaskRerunTime"].asString()); - if(!dataNode["BusinessId"].isNull()) - data_.businessId = std::stol(dataNode["BusinessId"].asString()); - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); - if(!value["ErrorMessage"].isNull()) - errorMessage_ = value["ErrorMessage"].asString(); + if(!dataNode["Bizdate"].isNull()) + data_.bizdate = std::stol(dataNode["Bizdate"].asString()); + if(!dataNode["NodeName"].isNull()) + data_.nodeName = dataNode["NodeName"].asString(); + if(!dataNode["BeginWaitTimeTime"].isNull()) + data_.beginWaitTimeTime = std::stol(dataNode["BeginWaitTimeTime"].asString()); + if(!dataNode["DqcDescription"].isNull()) + data_.dqcDescription = dataNode["DqcDescription"].asString(); + if(!dataNode["NodeId"].isNull()) + data_.nodeId = std::stol(dataNode["NodeId"].asString()); + if(!dataNode["CreateUser"].isNull()) + data_.createUser = dataNode["CreateUser"].asString(); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); if(!value["Success"].isNull()) success_ = value["Success"].asString() == "true"; + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); } diff --git a/dataworks-public/src/model/GetInstanceStatusStatisticRequest.cc b/dataworks-public/src/model/GetInstanceStatusStatisticRequest.cc index 548de8f9d..d331319d8 100644 --- a/dataworks-public/src/model/GetInstanceStatusStatisticRequest.cc +++ b/dataworks-public/src/model/GetInstanceStatusStatisticRequest.cc @@ -38,6 +38,17 @@ void GetInstanceStatusStatisticRequest::setProjectEnv(const std::string& project setBodyParameter("ProjectEnv", projectEnv); } +std::string GetInstanceStatusStatisticRequest::getDagType()const +{ + return dagType_; +} + +void GetInstanceStatusStatisticRequest::setDagType(const std::string& dagType) +{ + dagType_ = dagType; + setBodyParameter("DagType", dagType); +} + std::string GetInstanceStatusStatisticRequest::getBizDate()const { return bizDate_; @@ -49,6 +60,17 @@ void GetInstanceStatusStatisticRequest::setBizDate(const std::string& bizDate) setBodyParameter("BizDate", bizDate); } +std::string GetInstanceStatusStatisticRequest::getSchedulerType()const +{ + return schedulerType_; +} + +void GetInstanceStatusStatisticRequest::setSchedulerType(const std::string& schedulerType) +{ + schedulerType_ = schedulerType; + setBodyParameter("SchedulerType", schedulerType); +} + long GetInstanceStatusStatisticRequest::getProjectId()const { return projectId_; diff --git a/dataworks-public/src/model/GetInstanceStatusStatisticResult.cc b/dataworks-public/src/model/GetInstanceStatusStatisticResult.cc index 488f570f9..4c44e96e3 100644 --- a/dataworks-public/src/model/GetInstanceStatusStatisticResult.cc +++ b/dataworks-public/src/model/GetInstanceStatusStatisticResult.cc @@ -40,20 +40,20 @@ void GetInstanceStatusStatisticResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto statusCountNode = value["StatusCount"]; + if(!statusCountNode["FailureCount"].isNull()) + statusCount_.failureCount = std::stoi(statusCountNode["FailureCount"].asString()); + if(!statusCountNode["WaitTimeCount"].isNull()) + statusCount_.waitTimeCount = std::stoi(statusCountNode["WaitTimeCount"].asString()); + if(!statusCountNode["RunningCount"].isNull()) + statusCount_.runningCount = std::stoi(statusCountNode["RunningCount"].asString()); + if(!statusCountNode["SuccessCount"].isNull()) + statusCount_.successCount = std::stoi(statusCountNode["SuccessCount"].asString()); if(!statusCountNode["TotalCount"].isNull()) statusCount_.totalCount = std::stoi(statusCountNode["TotalCount"].asString()); if(!statusCountNode["NotRunCount"].isNull()) statusCount_.notRunCount = std::stoi(statusCountNode["NotRunCount"].asString()); - if(!statusCountNode["WaitTimeCount"].isNull()) - statusCount_.waitTimeCount = std::stoi(statusCountNode["WaitTimeCount"].asString()); if(!statusCountNode["WaitResCount"].isNull()) statusCount_.waitResCount = std::stoi(statusCountNode["WaitResCount"].asString()); - if(!statusCountNode["RunningCount"].isNull()) - statusCount_.runningCount = std::stoi(statusCountNode["RunningCount"].asString()); - if(!statusCountNode["FailureCount"].isNull()) - statusCount_.failureCount = std::stoi(statusCountNode["FailureCount"].asString()); - if(!statusCountNode["SuccessCount"].isNull()) - statusCount_.successCount = std::stoi(statusCountNode["SuccessCount"].asString()); } diff --git a/dataworks-public/src/model/GetManualDagInstancesResult.cc b/dataworks-public/src/model/GetManualDagInstancesResult.cc index 54dfccbff..1a096ea38 100644 --- a/dataworks-public/src/model/GetManualDagInstancesResult.cc +++ b/dataworks-public/src/model/GetManualDagInstancesResult.cc @@ -43,38 +43,40 @@ void GetManualDagInstancesResult::parse(const std::string &payload) for (auto valueInstancesInstancesItem : allInstancesNode) { InstancesItem instancesObject; - if(!valueInstancesInstancesItem["NodeId"].isNull()) - instancesObject.nodeId = std::stol(valueInstancesInstancesItem["NodeId"].asString()); - if(!valueInstancesInstancesItem["InstanceId"].isNull()) - instancesObject.instanceId = std::stol(valueInstancesInstancesItem["InstanceId"].asString()); - if(!valueInstancesInstancesItem["DagId"].isNull()) - instancesObject.dagId = std::stol(valueInstancesInstancesItem["DagId"].asString()); - if(!valueInstancesInstancesItem["DagType"].isNull()) - instancesObject.dagType = valueInstancesInstancesItem["DagType"].asString(); if(!valueInstancesInstancesItem["Status"].isNull()) instancesObject.status = valueInstancesInstancesItem["Status"].asString(); + if(!valueInstancesInstancesItem["BeginRunningTime"].isNull()) + instancesObject.beginRunningTime = std::stol(valueInstancesInstancesItem["BeginRunningTime"].asString()); if(!valueInstancesInstancesItem["BizDate"].isNull()) instancesObject.bizDate = std::stol(valueInstancesInstancesItem["BizDate"].asString()); if(!valueInstancesInstancesItem["CycTime"].isNull()) instancesObject.cycTime = std::stol(valueInstancesInstancesItem["CycTime"].asString()); + if(!valueInstancesInstancesItem["FinishTime"].isNull()) + instancesObject.finishTime = std::stol(valueInstancesInstancesItem["FinishTime"].asString()); if(!valueInstancesInstancesItem["CreateTime"].isNull()) instancesObject.createTime = std::stol(valueInstancesInstancesItem["CreateTime"].asString()); - if(!valueInstancesInstancesItem["ModifyTime"].isNull()) - instancesObject.modifyTime = std::stol(valueInstancesInstancesItem["ModifyTime"].asString()); + if(!valueInstancesInstancesItem["DagId"].isNull()) + instancesObject.dagId = std::stol(valueInstancesInstancesItem["DagId"].asString()); + if(!valueInstancesInstancesItem["InstanceId"].isNull()) + instancesObject.instanceId = std::stol(valueInstancesInstancesItem["InstanceId"].asString()); + if(!valueInstancesInstancesItem["BeginWaitResTime"].isNull()) + instancesObject.beginWaitResTime = std::stol(valueInstancesInstancesItem["BeginWaitResTime"].asString()); + if(!valueInstancesInstancesItem["TaskType"].isNull()) + instancesObject.taskType = valueInstancesInstancesItem["TaskType"].asString(); + if(!valueInstancesInstancesItem["ParamValues"].isNull()) + instancesObject.paramValues = valueInstancesInstancesItem["ParamValues"].asString(); + if(!valueInstancesInstancesItem["DagType"].isNull()) + instancesObject.dagType = valueInstancesInstancesItem["DagType"].asString(); if(!valueInstancesInstancesItem["NodeName"].isNull()) instancesObject.nodeName = valueInstancesInstancesItem["NodeName"].asString(); if(!valueInstancesInstancesItem["BeginWaitTimeTime"].isNull()) instancesObject.beginWaitTimeTime = std::stol(valueInstancesInstancesItem["BeginWaitTimeTime"].asString()); - if(!valueInstancesInstancesItem["BeginWaitResTime"].isNull()) - instancesObject.beginWaitResTime = std::stol(valueInstancesInstancesItem["BeginWaitResTime"].asString()); - if(!valueInstancesInstancesItem["BeginRunningTime"].isNull()) - instancesObject.beginRunningTime = std::stol(valueInstancesInstancesItem["BeginRunningTime"].asString()); - if(!valueInstancesInstancesItem["ParamValues"].isNull()) - instancesObject.paramValues = valueInstancesInstancesItem["ParamValues"].asString(); - if(!valueInstancesInstancesItem["FinishTime"].isNull()) - instancesObject.finishTime = std::stol(valueInstancesInstancesItem["FinishTime"].asString()); - if(!valueInstancesInstancesItem["TaskType"].isNull()) - instancesObject.taskType = valueInstancesInstancesItem["TaskType"].asString(); + if(!valueInstancesInstancesItem["NodeId"].isNull()) + instancesObject.nodeId = std::stol(valueInstancesInstancesItem["NodeId"].asString()); + if(!valueInstancesInstancesItem["ModifyTime"].isNull()) + instancesObject.modifyTime = std::stol(valueInstancesInstancesItem["ModifyTime"].asString()); + if(!valueInstancesInstancesItem["CreateUser"].isNull()) + instancesObject.createUser = valueInstancesInstancesItem["CreateUser"].asString(); instances_.push_back(instancesObject); } diff --git a/dataworks-public/src/model/GetMetaTableColumnResult.cc b/dataworks-public/src/model/GetMetaTableColumnResult.cc index 6a761b7a0..565c47a88 100644 --- a/dataworks-public/src/model/GetMetaTableColumnResult.cc +++ b/dataworks-public/src/model/GetMetaTableColumnResult.cc @@ -40,44 +40,46 @@ void GetMetaTableColumnResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto dataNode = value["Data"]; - if(!dataNode["TotalCount"].isNull()) - data_.totalCount = std::stol(dataNode["TotalCount"].asString()); if(!dataNode["PageNum"].isNull()) data_.pageNum = std::stoi(dataNode["PageNum"].asString()); if(!dataNode["PageSize"].isNull()) data_.pageSize = std::stoi(dataNode["PageSize"].asString()); + if(!dataNode["TotalCount"].isNull()) + data_.totalCount = std::stol(dataNode["TotalCount"].asString()); auto allColumnListNode = dataNode["ColumnList"]["ColumnListItem"]; for (auto dataNodeColumnListColumnListItem : allColumnListNode) { Data::ColumnListItem columnListItemObject; - if(!dataNodeColumnListColumnListItem["ColumnName"].isNull()) - columnListItemObject.columnName = dataNodeColumnListColumnListItem["ColumnName"].asString(); if(!dataNodeColumnListColumnListItem["ColumnGuid"].isNull()) columnListItemObject.columnGuid = dataNodeColumnListColumnListItem["ColumnGuid"].asString(); - if(!dataNodeColumnListColumnListItem["Comment"].isNull()) - columnListItemObject.comment = dataNodeColumnListColumnListItem["Comment"].asString(); - if(!dataNodeColumnListColumnListItem["IsPrimaryKey"].isNull()) - columnListItemObject.isPrimaryKey = dataNodeColumnListColumnListItem["IsPrimaryKey"].asString() == "true"; - if(!dataNodeColumnListColumnListItem["ColumnType"].isNull()) - columnListItemObject.columnType = dataNodeColumnListColumnListItem["ColumnType"].asString(); + if(!dataNodeColumnListColumnListItem["ColumnName"].isNull()) + columnListItemObject.columnName = dataNodeColumnListColumnListItem["ColumnName"].asString(); if(!dataNodeColumnListColumnListItem["IsPartitionColumn"].isNull()) columnListItemObject.isPartitionColumn = dataNodeColumnListColumnListItem["IsPartitionColumn"].asString() == "true"; - if(!dataNodeColumnListColumnListItem["IsForeignKey"].isNull()) - columnListItemObject.isForeignKey = dataNodeColumnListColumnListItem["IsForeignKey"].asString() == "true"; - if(!dataNodeColumnListColumnListItem["Caption"].isNull()) - columnListItemObject.caption = dataNodeColumnListColumnListItem["Caption"].asString(); + if(!dataNodeColumnListColumnListItem["Comment"].isNull()) + columnListItemObject.comment = dataNodeColumnListColumnListItem["Comment"].asString(); + if(!dataNodeColumnListColumnListItem["ColumnType"].isNull()) + columnListItemObject.columnType = dataNodeColumnListColumnListItem["ColumnType"].asString(); + if(!dataNodeColumnListColumnListItem["IsPrimaryKey"].isNull()) + columnListItemObject.isPrimaryKey = dataNodeColumnListColumnListItem["IsPrimaryKey"].asString() == "true"; if(!dataNodeColumnListColumnListItem["Position"].isNull()) columnListItemObject.position = std::stoi(dataNodeColumnListColumnListItem["Position"].asString()); + if(!dataNodeColumnListColumnListItem["Caption"].isNull()) + columnListItemObject.caption = dataNodeColumnListColumnListItem["Caption"].asString(); + if(!dataNodeColumnListColumnListItem["IsForeignKey"].isNull()) + columnListItemObject.isForeignKey = dataNodeColumnListColumnListItem["IsForeignKey"].asString() == "true"; + if(!dataNodeColumnListColumnListItem["RelationCount"].isNull()) + columnListItemObject.relationCount = std::stol(dataNodeColumnListColumnListItem["RelationCount"].asString()); data_.columnList.push_back(columnListItemObject); } - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); - if(!value["ErrorMessage"].isNull()) - errorMessage_ = value["ErrorMessage"].asString(); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); if(!value["Success"].isNull()) success_ = value["Success"].asString() == "true"; + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); } diff --git a/dataworks-public/src/model/GetMetaTableLineageResult.cc b/dataworks-public/src/model/GetMetaTableLineageResult.cc index 3159c693f..9f7997fa1 100644 --- a/dataworks-public/src/model/GetMetaTableLineageResult.cc +++ b/dataworks-public/src/model/GetMetaTableLineageResult.cc @@ -40,10 +40,10 @@ void GetMetaTableLineageResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto dataNode = value["Data"]; - if(!dataNode["HasNext"].isNull()) - data_.hasNext = dataNode["HasNext"].asString() == "true"; if(!dataNode["NextPrimaryKey"].isNull()) data_.nextPrimaryKey = dataNode["NextPrimaryKey"].asString(); + if(!dataNode["HasNext"].isNull()) + data_.hasNext = dataNode["HasNext"].asString() == "true"; auto allDataEntityListNode = dataNode["DataEntityList"]["DataEntityListItem"]; for (auto dataNodeDataEntityListDataEntityListItem : allDataEntityListNode) { @@ -52,16 +52,18 @@ void GetMetaTableLineageResult::parse(const std::string &payload) dataEntityListItemObject.tableName = dataNodeDataEntityListDataEntityListItem["TableName"].asString(); if(!dataNodeDataEntityListDataEntityListItem["TableGuid"].isNull()) dataEntityListItemObject.tableGuid = dataNodeDataEntityListDataEntityListItem["TableGuid"].asString(); + if(!dataNodeDataEntityListDataEntityListItem["CreateTimestamp"].isNull()) + dataEntityListItemObject.createTimestamp = std::stol(dataNodeDataEntityListDataEntityListItem["CreateTimestamp"].asString()); data_.dataEntityList.push_back(dataEntityListItemObject); } - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); - if(!value["ErrorMessage"].isNull()) - errorMessage_ = value["ErrorMessage"].asString(); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); if(!value["Success"].isNull()) success_ = value["Success"].asString() == "true"; + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); } diff --git a/dataworks-public/src/model/GetMigrationSummaryRequest.cc b/dataworks-public/src/model/GetMigrationSummaryRequest.cc new file mode 100644 index 000000000..f16b9a231 --- /dev/null +++ b/dataworks-public/src/model/GetMigrationSummaryRequest.cc @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Dataworks_public::Model::GetMigrationSummaryRequest; + +GetMigrationSummaryRequest::GetMigrationSummaryRequest() : + RpcServiceRequest("dataworks-public", "2020-05-18", "GetMigrationSummary") +{ + setMethod(HttpRequest::Method::Post); +} + +GetMigrationSummaryRequest::~GetMigrationSummaryRequest() +{} + +long GetMigrationSummaryRequest::getMigrationId()const +{ + return migrationId_; +} + +void GetMigrationSummaryRequest::setMigrationId(long migrationId) +{ + migrationId_ = migrationId; + setBodyParameter("MigrationId", std::to_string(migrationId)); +} + +long GetMigrationSummaryRequest::getProjectId()const +{ + return projectId_; +} + +void GetMigrationSummaryRequest::setProjectId(long projectId) +{ + projectId_ = projectId; + setBodyParameter("ProjectId", std::to_string(projectId)); +} + diff --git a/dataworks-public/src/model/GetMigrationSummaryResult.cc b/dataworks-public/src/model/GetMigrationSummaryResult.cc new file mode 100644 index 000000000..02a72a1da --- /dev/null +++ b/dataworks-public/src/model/GetMigrationSummaryResult.cc @@ -0,0 +1,75 @@ +/* + * 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::Dataworks_public; +using namespace AlibabaCloud::Dataworks_public::Model; + +GetMigrationSummaryResult::GetMigrationSummaryResult() : + ServiceResult() +{} + +GetMigrationSummaryResult::GetMigrationSummaryResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetMigrationSummaryResult::~GetMigrationSummaryResult() +{} + +void GetMigrationSummaryResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["MigrationId"].isNull()) + data_.migrationId = std::stol(dataNode["MigrationId"].asString()); + if(!dataNode["Name"].isNull()) + data_.name = dataNode["Name"].asString(); + if(!dataNode["GmtCreate"].isNull()) + data_.gmtCreate = std::stol(dataNode["GmtCreate"].asString()); + if(!dataNode["GmtModified"].isNull()) + data_.gmtModified = std::stol(dataNode["GmtModified"].asString()); + if(!dataNode["CreateUser"].isNull()) + data_.createUser = dataNode["CreateUser"].asString(); + if(!dataNode["OpUser"].isNull()) + data_.opUser = dataNode["OpUser"].asString(); + if(!dataNode["Status"].isNull()) + data_.status = dataNode["Status"].asString(); + if(!dataNode["ProjectId"].isNull()) + data_.projectId = std::stol(dataNode["ProjectId"].asString()); + if(!dataNode["DownloadUrl"].isNull()) + data_.downloadUrl = dataNode["DownloadUrl"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +GetMigrationSummaryResult::Data GetMigrationSummaryResult::getData()const +{ + return data_; +} + +bool GetMigrationSummaryResult::getSuccess()const +{ + return success_; +} + diff --git a/dataworks-public/src/model/GetNodeChildrenResult.cc b/dataworks-public/src/model/GetNodeChildrenResult.cc index b4cdbbe1d..65878c1dc 100644 --- a/dataworks-public/src/model/GetNodeChildrenResult.cc +++ b/dataworks-public/src/model/GetNodeChildrenResult.cc @@ -44,36 +44,36 @@ void GetNodeChildrenResult::parse(const std::string &payload) for (auto dataNodeNodesNodesItem : allNodesNode) { Data::NodesItem nodesItemObject; - if(!dataNodeNodesNodesItem["NodeId"].isNull()) - nodesItemObject.nodeId = std::stol(dataNodeNodesNodesItem["NodeId"].asString()); - if(!dataNodeNodesNodesItem["NodeName"].isNull()) - nodesItemObject.nodeName = dataNodeNodesNodesItem["NodeName"].asString(); - if(!dataNodeNodesNodesItem["CronExpress"].isNull()) - nodesItemObject.cronExpress = dataNodeNodesNodesItem["CronExpress"].asString(); if(!dataNodeNodesNodesItem["SchedulerType"].isNull()) nodesItemObject.schedulerType = dataNodeNodesNodesItem["SchedulerType"].asString(); - if(!dataNodeNodesNodesItem["ProgramType"].isNull()) - nodesItemObject.programType = dataNodeNodesNodesItem["ProgramType"].asString(); - if(!dataNodeNodesNodesItem["OwnerId"].isNull()) - nodesItemObject.ownerId = dataNodeNodesNodesItem["OwnerId"].asString(); - if(!dataNodeNodesNodesItem["ProjectId"].isNull()) - nodesItemObject.projectId = std::stol(dataNodeNodesNodesItem["ProjectId"].asString()); - if(!dataNodeNodesNodesItem["Repeatability"].isNull()) - nodesItemObject.repeatability = dataNodeNodesNodesItem["Repeatability"].asString() == "true"; - if(!dataNodeNodesNodesItem["Priority"].isNull()) - nodesItemObject.priority = std::stoi(dataNodeNodesNodesItem["Priority"].asString()); if(!dataNodeNodesNodesItem["BaselineId"].isNull()) nodesItemObject.baselineId = std::stol(dataNodeNodesNodesItem["BaselineId"].asString()); + if(!dataNodeNodesNodesItem["Repeatability"].isNull()) + nodesItemObject.repeatability = dataNodeNodesNodesItem["Repeatability"].asString() == "true"; + if(!dataNodeNodesNodesItem["NodeName"].isNull()) + nodesItemObject.nodeName = dataNodeNodesNodesItem["NodeName"].asString(); + if(!dataNodeNodesNodesItem["ProjectId"].isNull()) + nodesItemObject.projectId = std::stol(dataNodeNodesNodesItem["ProjectId"].asString()); + if(!dataNodeNodesNodesItem["ProgramType"].isNull()) + nodesItemObject.programType = dataNodeNodesNodesItem["ProgramType"].asString(); + if(!dataNodeNodesNodesItem["Priority"].isNull()) + nodesItemObject.priority = std::stoi(dataNodeNodesNodesItem["Priority"].asString()); + if(!dataNodeNodesNodesItem["OwnerId"].isNull()) + nodesItemObject.ownerId = dataNodeNodesNodesItem["OwnerId"].asString(); + if(!dataNodeNodesNodesItem["CronExpress"].isNull()) + nodesItemObject.cronExpress = dataNodeNodesNodesItem["CronExpress"].asString(); + if(!dataNodeNodesNodesItem["NodeId"].isNull()) + nodesItemObject.nodeId = std::stol(dataNodeNodesNodesItem["NodeId"].asString()); data_.nodes.push_back(nodesItemObject); } - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); if(!value["ErrorMessage"].isNull()) errorMessage_ = value["ErrorMessage"].asString(); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; } diff --git a/dataworks-public/src/model/GetNodeParentsResult.cc b/dataworks-public/src/model/GetNodeParentsResult.cc index 23d2c47ea..778300907 100644 --- a/dataworks-public/src/model/GetNodeParentsResult.cc +++ b/dataworks-public/src/model/GetNodeParentsResult.cc @@ -44,36 +44,36 @@ void GetNodeParentsResult::parse(const std::string &payload) for (auto dataNodeNodesNodesItem : allNodesNode) { Data::NodesItem nodesItemObject; - if(!dataNodeNodesNodesItem["NodeId"].isNull()) - nodesItemObject.nodeId = std::stol(dataNodeNodesNodesItem["NodeId"].asString()); - if(!dataNodeNodesNodesItem["NodeName"].isNull()) - nodesItemObject.nodeName = dataNodeNodesNodesItem["NodeName"].asString(); - if(!dataNodeNodesNodesItem["CronExpress"].isNull()) - nodesItemObject.cronExpress = dataNodeNodesNodesItem["CronExpress"].asString(); if(!dataNodeNodesNodesItem["SchedulerType"].isNull()) nodesItemObject.schedulerType = dataNodeNodesNodesItem["SchedulerType"].asString(); - if(!dataNodeNodesNodesItem["ProgramType"].isNull()) - nodesItemObject.programType = dataNodeNodesNodesItem["ProgramType"].asString(); - if(!dataNodeNodesNodesItem["OwnerId"].isNull()) - nodesItemObject.ownerId = dataNodeNodesNodesItem["OwnerId"].asString(); - if(!dataNodeNodesNodesItem["ProjectId"].isNull()) - nodesItemObject.projectId = std::stol(dataNodeNodesNodesItem["ProjectId"].asString()); - if(!dataNodeNodesNodesItem["Repeatability"].isNull()) - nodesItemObject.repeatability = dataNodeNodesNodesItem["Repeatability"].asString() == "true"; - if(!dataNodeNodesNodesItem["Priority"].isNull()) - nodesItemObject.priority = std::stoi(dataNodeNodesNodesItem["Priority"].asString()); if(!dataNodeNodesNodesItem["BaselineId"].isNull()) nodesItemObject.baselineId = std::stol(dataNodeNodesNodesItem["BaselineId"].asString()); + if(!dataNodeNodesNodesItem["Repeatability"].isNull()) + nodesItemObject.repeatability = dataNodeNodesNodesItem["Repeatability"].asString() == "true"; + if(!dataNodeNodesNodesItem["NodeName"].isNull()) + nodesItemObject.nodeName = dataNodeNodesNodesItem["NodeName"].asString(); + if(!dataNodeNodesNodesItem["ProjectId"].isNull()) + nodesItemObject.projectId = std::stol(dataNodeNodesNodesItem["ProjectId"].asString()); + if(!dataNodeNodesNodesItem["ProgramType"].isNull()) + nodesItemObject.programType = dataNodeNodesNodesItem["ProgramType"].asString(); + if(!dataNodeNodesNodesItem["Priority"].isNull()) + nodesItemObject.priority = std::stoi(dataNodeNodesNodesItem["Priority"].asString()); + if(!dataNodeNodesNodesItem["OwnerId"].isNull()) + nodesItemObject.ownerId = dataNodeNodesNodesItem["OwnerId"].asString(); + if(!dataNodeNodesNodesItem["CronExpress"].isNull()) + nodesItemObject.cronExpress = dataNodeNodesNodesItem["CronExpress"].asString(); + if(!dataNodeNodesNodesItem["NodeId"].isNull()) + nodesItemObject.nodeId = std::stol(dataNodeNodesNodesItem["NodeId"].asString()); data_.nodes.push_back(nodesItemObject); } - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); if(!value["ErrorMessage"].isNull()) errorMessage_ = value["ErrorMessage"].asString(); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; } diff --git a/dataworks-public/src/model/GetQualityEntityResult.cc b/dataworks-public/src/model/GetQualityEntityResult.cc index f923ad490..716587be5 100644 --- a/dataworks-public/src/model/GetQualityEntityResult.cc +++ b/dataworks-public/src/model/GetQualityEntityResult.cc @@ -43,48 +43,48 @@ void GetQualityEntityResult::parse(const std::string &payload) for (auto valueDataEntityDto : allDataNode) { EntityDto dataObject; - if(!valueDataEntityDto["Id"].isNull()) - dataObject.id = std::stol(valueDataEntityDto["Id"].asString()); - if(!valueDataEntityDto["ProjectName"].isNull()) - dataObject.projectName = valueDataEntityDto["ProjectName"].asString(); - if(!valueDataEntityDto["TableName"].isNull()) - dataObject.tableName = valueDataEntityDto["TableName"].asString(); - if(!valueDataEntityDto["EnvType"].isNull()) - dataObject.envType = valueDataEntityDto["EnvType"].asString(); - if(!valueDataEntityDto["MatchExpression"].isNull()) - dataObject.matchExpression = valueDataEntityDto["MatchExpression"].asString(); - if(!valueDataEntityDto["EntityLevel"].isNull()) - dataObject.entityLevel = std::stoi(valueDataEntityDto["EntityLevel"].asString()); - if(!valueDataEntityDto["OnDuty"].isNull()) - dataObject.onDuty = valueDataEntityDto["OnDuty"].asString(); - if(!valueDataEntityDto["ModifyUser"].isNull()) - dataObject.modifyUser = valueDataEntityDto["ModifyUser"].asString(); - if(!valueDataEntityDto["CreateTime"].isNull()) - dataObject.createTime = std::stol(valueDataEntityDto["CreateTime"].asString()); - if(!valueDataEntityDto["ModifyTime"].isNull()) - dataObject.modifyTime = std::stol(valueDataEntityDto["ModifyTime"].asString()); - if(!valueDataEntityDto["Sql"].isNull()) - dataObject.sql = std::stoi(valueDataEntityDto["Sql"].asString()); - if(!valueDataEntityDto["Task"].isNull()) - dataObject.task = std::stoi(valueDataEntityDto["Task"].asString()); - if(!valueDataEntityDto["Followers"].isNull()) - dataObject.followers = valueDataEntityDto["Followers"].asString(); - if(!valueDataEntityDto["HasRelativeNode"].isNull()) - dataObject.hasRelativeNode = valueDataEntityDto["HasRelativeNode"].asString() == "true"; if(!valueDataEntityDto["RelativeNode"].isNull()) dataObject.relativeNode = valueDataEntityDto["RelativeNode"].asString(); if(!valueDataEntityDto["OnDutyAccountName"].isNull()) dataObject.onDutyAccountName = valueDataEntityDto["OnDutyAccountName"].asString(); + if(!valueDataEntityDto["Task"].isNull()) + dataObject.task = std::stoi(valueDataEntityDto["Task"].asString()); + if(!valueDataEntityDto["TableName"].isNull()) + dataObject.tableName = valueDataEntityDto["TableName"].asString(); + if(!valueDataEntityDto["Followers"].isNull()) + dataObject.followers = valueDataEntityDto["Followers"].asString(); + if(!valueDataEntityDto["OnDuty"].isNull()) + dataObject.onDuty = valueDataEntityDto["OnDuty"].asString(); + if(!valueDataEntityDto["MatchExpression"].isNull()) + dataObject.matchExpression = valueDataEntityDto["MatchExpression"].asString(); + if(!valueDataEntityDto["CreateTime"].isNull()) + dataObject.createTime = std::stol(valueDataEntityDto["CreateTime"].asString()); + if(!valueDataEntityDto["ProjectName"].isNull()) + dataObject.projectName = valueDataEntityDto["ProjectName"].asString(); + if(!valueDataEntityDto["HasRelativeNode"].isNull()) + dataObject.hasRelativeNode = valueDataEntityDto["HasRelativeNode"].asString() == "true"; + if(!valueDataEntityDto["EnvType"].isNull()) + dataObject.envType = valueDataEntityDto["EnvType"].asString(); + if(!valueDataEntityDto["EntityLevel"].isNull()) + dataObject.entityLevel = std::stoi(valueDataEntityDto["EntityLevel"].asString()); + if(!valueDataEntityDto["ModifyUser"].isNull()) + dataObject.modifyUser = valueDataEntityDto["ModifyUser"].asString(); + if(!valueDataEntityDto["Sql"].isNull()) + dataObject.sql = std::stoi(valueDataEntityDto["Sql"].asString()); + if(!valueDataEntityDto["Id"].isNull()) + dataObject.id = std::stol(valueDataEntityDto["Id"].asString()); + if(!valueDataEntityDto["ModifyTime"].isNull()) + dataObject.modifyTime = std::stol(valueDataEntityDto["ModifyTime"].asString()); data_.push_back(dataObject); } - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); - if(!value["ErrorMessage"].isNull()) - errorMessage_ = value["ErrorMessage"].asString(); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; } diff --git a/dataworks-public/src/model/GetQualityRuleResult.cc b/dataworks-public/src/model/GetQualityRuleResult.cc index 45d18ec28..06e537bcb 100644 --- a/dataworks-public/src/model/GetQualityRuleResult.cc +++ b/dataworks-public/src/model/GetQualityRuleResult.cc @@ -40,60 +40,60 @@ void GetQualityRuleResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto dataNode = value["Data"]; - if(!dataNode["Id"].isNull()) - data_.id = std::stol(dataNode["Id"].asString()); - if(!dataNode["EntityId"].isNull()) - data_.entityId = std::stol(dataNode["EntityId"].asString()); - if(!dataNode["Property"].isNull()) - data_.property = dataNode["Property"].asString(); - if(!dataNode["MethodId"].isNull()) - data_.methodId = std::stoi(dataNode["MethodId"].asString()); - if(!dataNode["MethodName"].isNull()) - data_.methodName = dataNode["MethodName"].asString(); - if(!dataNode["WhereCondition"].isNull()) - data_.whereCondition = dataNode["WhereCondition"].asString(); - if(!dataNode["OnDuty"].isNull()) - data_.onDuty = dataNode["OnDuty"].asString(); - if(!dataNode["RuleType"].isNull()) - data_.ruleType = std::stoi(dataNode["RuleType"].asString()); if(!dataNode["BlockType"].isNull()) data_.blockType = std::stoi(dataNode["BlockType"].asString()); - if(!dataNode["TemplateId"].isNull()) - data_.templateId = std::stoi(dataNode["TemplateId"].asString()); - if(!dataNode["TemplateName"].isNull()) - data_.templateName = dataNode["TemplateName"].asString(); - if(!dataNode["Comment"].isNull()) - data_.comment = dataNode["Comment"].asString(); - if(!dataNode["RuleName"].isNull()) - data_.ruleName = dataNode["RuleName"].asString(); - if(!dataNode["PredictType"].isNull()) - data_.predictType = std::stoi(dataNode["PredictType"].asString()); + if(!dataNode["OnDutyAccountName"].isNull()) + data_.onDutyAccountName = dataNode["OnDutyAccountName"].asString(); if(!dataNode["WarningThreshold"].isNull()) data_.warningThreshold = dataNode["WarningThreshold"].asString(); + if(!dataNode["Property"].isNull()) + data_.property = dataNode["Property"].asString(); + if(!dataNode["RuleType"].isNull()) + data_.ruleType = std::stoi(dataNode["RuleType"].asString()); + if(!dataNode["Comment"].isNull()) + data_.comment = dataNode["Comment"].asString(); + if(!dataNode["OnDuty"].isNull()) + data_.onDuty = dataNode["OnDuty"].asString(); + if(!dataNode["Checker"].isNull()) + data_.checker = std::stoi(dataNode["Checker"].asString()); + if(!dataNode["FixCheck"].isNull()) + data_.fixCheck = dataNode["FixCheck"].asString() == "true"; + if(!dataNode["MethodId"].isNull()) + data_.methodId = std::stoi(dataNode["MethodId"].asString()); if(!dataNode["CriticalThreshold"].isNull()) data_.criticalThreshold = dataNode["CriticalThreshold"].asString(); + if(!dataNode["PredictType"].isNull()) + data_.predictType = std::stoi(dataNode["PredictType"].asString()); + if(!dataNode["TemplateName"].isNull()) + data_.templateName = dataNode["TemplateName"].asString(); + if(!dataNode["CheckerName"].isNull()) + data_.checkerName = dataNode["CheckerName"].asString(); + if(!dataNode["RuleName"].isNull()) + data_.ruleName = dataNode["RuleName"].asString(); + if(!dataNode["MethodName"].isNull()) + data_.methodName = dataNode["MethodName"].asString(); + if(!dataNode["EntityId"].isNull()) + data_.entityId = std::stol(dataNode["EntityId"].asString()); + if(!dataNode["WhereCondition"].isNull()) + data_.whereCondition = dataNode["WhereCondition"].asString(); if(!dataNode["Operator"].isNull()) data_._operator = dataNode["Operator"].asString(); if(!dataNode["ExpectValue"].isNull()) data_.expectValue = dataNode["ExpectValue"].asString(); if(!dataNode["Trend"].isNull()) data_.trend = dataNode["Trend"].asString(); - if(!dataNode["CheckerName"].isNull()) - data_.checkerName = dataNode["CheckerName"].asString(); - if(!dataNode["Checker"].isNull()) - data_.checker = std::stoi(dataNode["Checker"].asString()); - if(!dataNode["FixCheck"].isNull()) - data_.fixCheck = dataNode["FixCheck"].asString() == "true"; - if(!dataNode["OnDutyAccountName"].isNull()) - data_.onDutyAccountName = dataNode["OnDutyAccountName"].asString(); - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); - if(!value["ErrorMessage"].isNull()) - errorMessage_ = value["ErrorMessage"].asString(); + if(!dataNode["TemplateId"].isNull()) + data_.templateId = std::stoi(dataNode["TemplateId"].asString()); + if(!dataNode["Id"].isNull()) + data_.id = std::stol(dataNode["Id"].asString()); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; } diff --git a/dataworks-public/src/model/ListDagsRequest.cc b/dataworks-public/src/model/ListDagsRequest.cc new file mode 100644 index 000000000..89789922d --- /dev/null +++ b/dataworks-public/src/model/ListDagsRequest.cc @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Dataworks_public::Model::ListDagsRequest; + +ListDagsRequest::ListDagsRequest() : + RpcServiceRequest("dataworks-public", "2020-05-18", "ListDags") +{ + setMethod(HttpRequest::Method::Post); +} + +ListDagsRequest::~ListDagsRequest() +{} + +std::string ListDagsRequest::getProjectEnv()const +{ + return projectEnv_; +} + +void ListDagsRequest::setProjectEnv(const std::string& projectEnv) +{ + projectEnv_ = projectEnv; + setBodyParameter("ProjectEnv", projectEnv); +} + +long ListDagsRequest::getOpSeq()const +{ + return opSeq_; +} + +void ListDagsRequest::setOpSeq(long opSeq) +{ + opSeq_ = opSeq; + setBodyParameter("OpSeq", std::to_string(opSeq)); +} + diff --git a/dataworks-public/src/model/ListDagsResult.cc b/dataworks-public/src/model/ListDagsResult.cc new file mode 100644 index 000000000..82cb89aa5 --- /dev/null +++ b/dataworks-public/src/model/ListDagsResult.cc @@ -0,0 +1,110 @@ +/* + * 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::Dataworks_public; +using namespace AlibabaCloud::Dataworks_public::Model; + +ListDagsResult::ListDagsResult() : + ServiceResult() +{} + +ListDagsResult::ListDagsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListDagsResult::~ListDagsResult() +{} + +void ListDagsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + auto allDagsNode = dataNode["Dags"]["Dag"]; + for (auto dataNodeDagsDag : allDagsNode) + { + Data::Dag dagObject; + if(!dataNodeDagsDag["Type"].isNull()) + dagObject.type = dataNodeDagsDag["Type"].asString(); + if(!dataNodeDagsDag["Status"].isNull()) + dagObject.status = dataNodeDagsDag["Status"].asString(); + if(!dataNodeDagsDag["FinishTime"].isNull()) + dagObject.finishTime = std::stol(dataNodeDagsDag["FinishTime"].asString()); + if(!dataNodeDagsDag["CreateTime"].isNull()) + dagObject.createTime = std::stol(dataNodeDagsDag["CreateTime"].asString()); + if(!dataNodeDagsDag["ProjectId"].isNull()) + dagObject.projectId = std::stol(dataNodeDagsDag["ProjectId"].asString()); + if(!dataNodeDagsDag["DagId"].isNull()) + dagObject.dagId = std::stol(dataNodeDagsDag["DagId"].asString()); + if(!dataNodeDagsDag["Gmtdate"].isNull()) + dagObject.gmtdate = std::stol(dataNodeDagsDag["Gmtdate"].asString()); + if(!dataNodeDagsDag["StartTime"].isNull()) + dagObject.startTime = std::stol(dataNodeDagsDag["StartTime"].asString()); + if(!dataNodeDagsDag["CreateUser"].isNull()) + dagObject.createUser = dataNodeDagsDag["CreateUser"].asString(); + if(!dataNodeDagsDag["Bizdate"].isNull()) + dagObject.bizdate = std::stol(dataNodeDagsDag["Bizdate"].asString()); + if(!dataNodeDagsDag["Name"].isNull()) + dagObject.name = dataNodeDagsDag["Name"].asString(); + if(!dataNodeDagsDag["ModifyTime"].isNull()) + dagObject.modifyTime = std::stol(dataNodeDagsDag["ModifyTime"].asString()); + if(!dataNodeDagsDag["OpSeq"].isNull()) + dagObject.opSeq = std::stol(dataNodeDagsDag["OpSeq"].asString()); + data_.dags.push_back(dagObject); + } + if(!value["HttpStatusCode"].isNull()) + httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +int ListDagsResult::getHttpStatusCode()const +{ + return httpStatusCode_; +} + +ListDagsResult::Data ListDagsResult::getData()const +{ + return data_; +} + +std::string ListDagsResult::getErrorCode()const +{ + return errorCode_; +} + +std::string ListDagsResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool ListDagsResult::getSuccess()const +{ + return success_; +} + diff --git a/dataworks-public/src/model/ListDeploymentsRequest.cc b/dataworks-public/src/model/ListDeploymentsRequest.cc new file mode 100644 index 000000000..722c028bb --- /dev/null +++ b/dataworks-public/src/model/ListDeploymentsRequest.cc @@ -0,0 +1,139 @@ +/* + * 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::Dataworks_public::Model::ListDeploymentsRequest; + +ListDeploymentsRequest::ListDeploymentsRequest() : + RpcServiceRequest("dataworks-public", "2020-05-18", "ListDeployments") +{ + setMethod(HttpRequest::Method::Post); +} + +ListDeploymentsRequest::~ListDeploymentsRequest() +{} + +std::string ListDeploymentsRequest::getCreator()const +{ + return creator_; +} + +void ListDeploymentsRequest::setCreator(const std::string& creator) +{ + creator_ = creator; + setBodyParameter("Creator", creator); +} + +long ListDeploymentsRequest::getEndCreateTime()const +{ + return endCreateTime_; +} + +void ListDeploymentsRequest::setEndCreateTime(long endCreateTime) +{ + endCreateTime_ = endCreateTime; + setBodyParameter("EndCreateTime", std::to_string(endCreateTime)); +} + +std::string ListDeploymentsRequest::getProjectIdentifier()const +{ + return projectIdentifier_; +} + +void ListDeploymentsRequest::setProjectIdentifier(const std::string& projectIdentifier) +{ + projectIdentifier_ = projectIdentifier; + setBodyParameter("ProjectIdentifier", projectIdentifier); +} + +int ListDeploymentsRequest::getPageNumber()const +{ + return pageNumber_; +} + +void ListDeploymentsRequest::setPageNumber(int pageNumber) +{ + pageNumber_ = pageNumber; + setBodyParameter("PageNumber", std::to_string(pageNumber)); +} + +std::string ListDeploymentsRequest::getExecutor()const +{ + return executor_; +} + +void ListDeploymentsRequest::setExecutor(const std::string& executor) +{ + executor_ = executor; + setBodyParameter("Executor", executor); +} + +int ListDeploymentsRequest::getPageSize()const +{ + return pageSize_; +} + +void ListDeploymentsRequest::setPageSize(int pageSize) +{ + pageSize_ = pageSize; + setBodyParameter("PageSize", std::to_string(pageSize)); +} + +long ListDeploymentsRequest::getEndExecuteTime()const +{ + return endExecuteTime_; +} + +void ListDeploymentsRequest::setEndExecuteTime(long endExecuteTime) +{ + endExecuteTime_ = endExecuteTime; + setBodyParameter("EndExecuteTime", std::to_string(endExecuteTime)); +} + +std::string ListDeploymentsRequest::getKeyword()const +{ + return keyword_; +} + +void ListDeploymentsRequest::setKeyword(const std::string& keyword) +{ + keyword_ = keyword; + setBodyParameter("Keyword", keyword); +} + +long ListDeploymentsRequest::getProjectId()const +{ + return projectId_; +} + +void ListDeploymentsRequest::setProjectId(long projectId) +{ + projectId_ = projectId; + setBodyParameter("ProjectId", std::to_string(projectId)); +} + +int ListDeploymentsRequest::getStatus()const +{ + return status_; +} + +void ListDeploymentsRequest::setStatus(int status) +{ + status_ = status; + setBodyParameter("Status", std::to_string(status)); +} + diff --git a/dataworks-public/src/model/ListDeploymentsResult.cc b/dataworks-public/src/model/ListDeploymentsResult.cc new file mode 100644 index 000000000..9fe373d86 --- /dev/null +++ b/dataworks-public/src/model/ListDeploymentsResult.cc @@ -0,0 +1,78 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Dataworks_public; +using namespace AlibabaCloud::Dataworks_public::Model; + +ListDeploymentsResult::ListDeploymentsResult() : + ServiceResult() +{} + +ListDeploymentsResult::ListDeploymentsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListDeploymentsResult::~ListDeploymentsResult() +{} + +void ListDeploymentsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["PageNumber"].isNull()) + data_.pageNumber = std::stol(dataNode["PageNumber"].asString()); + if(!dataNode["PageSize"].isNull()) + data_.pageSize = std::stol(dataNode["PageSize"].asString()); + if(!dataNode["TotalCount"].isNull()) + data_.totalCount = std::stol(dataNode["TotalCount"].asString()); + auto allDeploymentsNode = dataNode["Deployments"]["Deployment"]; + for (auto dataNodeDeploymentsDeployment : allDeploymentsNode) + { + Data::Deployment deploymentObject; + if(!dataNodeDeploymentsDeployment["Status"].isNull()) + deploymentObject.status = std::stoi(dataNodeDeploymentsDeployment["Status"].asString()); + if(!dataNodeDeploymentsDeployment["ErrorMessage"].isNull()) + deploymentObject.errorMessage = dataNodeDeploymentsDeployment["ErrorMessage"].asString(); + if(!dataNodeDeploymentsDeployment["CreateTime"].isNull()) + deploymentObject.createTime = std::stol(dataNodeDeploymentsDeployment["CreateTime"].asString()); + if(!dataNodeDeploymentsDeployment["Executor"].isNull()) + deploymentObject.executor = dataNodeDeploymentsDeployment["Executor"].asString(); + if(!dataNodeDeploymentsDeployment["Creator"].isNull()) + deploymentObject.creator = dataNodeDeploymentsDeployment["Creator"].asString(); + if(!dataNodeDeploymentsDeployment["ExecuteTime"].isNull()) + deploymentObject.executeTime = std::stol(dataNodeDeploymentsDeployment["ExecuteTime"].asString()); + if(!dataNodeDeploymentsDeployment["Name"].isNull()) + deploymentObject.name = dataNodeDeploymentsDeployment["Name"].asString(); + if(!dataNodeDeploymentsDeployment["Id"].isNull()) + deploymentObject.id = std::stol(dataNodeDeploymentsDeployment["Id"].asString()); + data_.deployments.push_back(deploymentObject); + } + +} + +ListDeploymentsResult::Data ListDeploymentsResult::getData()const +{ + return data_; +} + diff --git a/dataworks-public/src/model/ListInstancesResult.cc b/dataworks-public/src/model/ListInstancesResult.cc index 4a0508224..173e5996e 100644 --- a/dataworks-public/src/model/ListInstancesResult.cc +++ b/dataworks-public/src/model/ListInstancesResult.cc @@ -50,70 +50,72 @@ void ListInstancesResult::parse(const std::string &payload) for (auto dataNodeInstancesInstance : allInstancesNode) { Data::Instance instanceObject; - if(!dataNodeInstancesInstance["NodeId"].isNull()) - instanceObject.nodeId = std::stol(dataNodeInstancesInstance["NodeId"].asString()); - if(!dataNodeInstancesInstance["InstanceId"].isNull()) - instanceObject.instanceId = std::stol(dataNodeInstancesInstance["InstanceId"].asString()); - if(!dataNodeInstancesInstance["DagId"].isNull()) - instanceObject.dagId = std::stol(dataNodeInstancesInstance["DagId"].asString()); - if(!dataNodeInstancesInstance["DagType"].isNull()) - instanceObject.dagType = dataNodeInstancesInstance["DagType"].asString(); if(!dataNodeInstancesInstance["Status"].isNull()) instanceObject.status = dataNodeInstancesInstance["Status"].asString(); - if(!dataNodeInstancesInstance["Bizdate"].isNull()) - instanceObject.bizdate = std::stol(dataNodeInstancesInstance["Bizdate"].asString()); if(!dataNodeInstancesInstance["CycTime"].isNull()) instanceObject.cycTime = std::stol(dataNodeInstancesInstance["CycTime"].asString()); - if(!dataNodeInstancesInstance["CreateTime"].isNull()) - instanceObject.createTime = std::stol(dataNodeInstancesInstance["CreateTime"].asString()); - if(!dataNodeInstancesInstance["ModifyTime"].isNull()) - instanceObject.modifyTime = std::stol(dataNodeInstancesInstance["ModifyTime"].asString()); - if(!dataNodeInstancesInstance["NodeName"].isNull()) - instanceObject.nodeName = dataNodeInstancesInstance["NodeName"].asString(); - if(!dataNodeInstancesInstance["BeginWaitTimeTime"].isNull()) - instanceObject.beginWaitTimeTime = std::stol(dataNodeInstancesInstance["BeginWaitTimeTime"].asString()); - if(!dataNodeInstancesInstance["BeginWaitResTime"].isNull()) - instanceObject.beginWaitResTime = std::stol(dataNodeInstancesInstance["BeginWaitResTime"].asString()); if(!dataNodeInstancesInstance["BeginRunningTime"].isNull()) instanceObject.beginRunningTime = std::stol(dataNodeInstancesInstance["BeginRunningTime"].asString()); - if(!dataNodeInstancesInstance["ParamValues"].isNull()) - instanceObject.paramValues = dataNodeInstancesInstance["ParamValues"].asString(); if(!dataNodeInstancesInstance["FinishTime"].isNull()) instanceObject.finishTime = std::stol(dataNodeInstancesInstance["FinishTime"].asString()); + if(!dataNodeInstancesInstance["ErrorMessage"].isNull()) + instanceObject.errorMessage = dataNodeInstancesInstance["ErrorMessage"].asString(); + if(!dataNodeInstancesInstance["CreateTime"].isNull()) + instanceObject.createTime = std::stol(dataNodeInstancesInstance["CreateTime"].asString()); + if(!dataNodeInstancesInstance["DagId"].isNull()) + instanceObject.dagId = std::stol(dataNodeInstancesInstance["DagId"].asString()); if(!dataNodeInstancesInstance["Priority"].isNull()) instanceObject.priority = std::stoi(dataNodeInstancesInstance["Priority"].asString()); + if(!dataNodeInstancesInstance["TaskType"].isNull()) + instanceObject.taskType = dataNodeInstancesInstance["TaskType"].asString(); + if(!dataNodeInstancesInstance["ParamValues"].isNull()) + instanceObject.paramValues = dataNodeInstancesInstance["ParamValues"].asString(); + if(!dataNodeInstancesInstance["Connection"].isNull()) + instanceObject.connection = dataNodeInstancesInstance["Connection"].asString(); if(!dataNodeInstancesInstance["BaselineId"].isNull()) instanceObject.baselineId = std::stol(dataNodeInstancesInstance["BaselineId"].asString()); + if(!dataNodeInstancesInstance["DqcType"].isNull()) + instanceObject.dqcType = std::stoi(dataNodeInstancesInstance["DqcType"].asString()); + if(!dataNodeInstancesInstance["DagType"].isNull()) + instanceObject.dagType = dataNodeInstancesInstance["DagType"].asString(); + if(!dataNodeInstancesInstance["BusinessId"].isNull()) + instanceObject.businessId = std::stol(dataNodeInstancesInstance["BusinessId"].asString()); + if(!dataNodeInstancesInstance["TaskRerunTime"].isNull()) + instanceObject.taskRerunTime = std::stoi(dataNodeInstancesInstance["TaskRerunTime"].asString()); + if(!dataNodeInstancesInstance["ModifyTime"].isNull()) + instanceObject.modifyTime = std::stol(dataNodeInstancesInstance["ModifyTime"].asString()); if(!dataNodeInstancesInstance["Repeatability"].isNull()) instanceObject.repeatability = dataNodeInstancesInstance["Repeatability"].asString() == "true"; if(!dataNodeInstancesInstance["RepeatInterval"].isNull()) instanceObject.repeatInterval = std::stol(dataNodeInstancesInstance["RepeatInterval"].asString()); - if(!dataNodeInstancesInstance["Connection"].isNull()) - instanceObject.connection = dataNodeInstancesInstance["Connection"].asString(); - if(!dataNodeInstancesInstance["DqcType"].isNull()) - instanceObject.dqcType = std::stoi(dataNodeInstancesInstance["DqcType"].asString()); - if(!dataNodeInstancesInstance["DqcDescription"].isNull()) - instanceObject.dqcDescription = dataNodeInstancesInstance["DqcDescription"].asString(); - if(!dataNodeInstancesInstance["ErrorMessage"].isNull()) - instanceObject.errorMessage = dataNodeInstancesInstance["ErrorMessage"].asString(); + if(!dataNodeInstancesInstance["InstanceId"].isNull()) + instanceObject.instanceId = std::stol(dataNodeInstancesInstance["InstanceId"].asString()); + if(!dataNodeInstancesInstance["BeginWaitResTime"].isNull()) + instanceObject.beginWaitResTime = std::stol(dataNodeInstancesInstance["BeginWaitResTime"].asString()); if(!dataNodeInstancesInstance["RelatedFlowId"].isNull()) instanceObject.relatedFlowId = std::stol(dataNodeInstancesInstance["RelatedFlowId"].asString()); - if(!dataNodeInstancesInstance["TaskType"].isNull()) - instanceObject.taskType = dataNodeInstancesInstance["TaskType"].asString(); - if(!dataNodeInstancesInstance["TaskRerunTime"].isNull()) - instanceObject.taskRerunTime = std::stoi(dataNodeInstancesInstance["TaskRerunTime"].asString()); - if(!dataNodeInstancesInstance["BusinessId"].isNull()) - instanceObject.businessId = std::stol(dataNodeInstancesInstance["BusinessId"].asString()); + if(!dataNodeInstancesInstance["Bizdate"].isNull()) + instanceObject.bizdate = std::stol(dataNodeInstancesInstance["Bizdate"].asString()); + if(!dataNodeInstancesInstance["NodeName"].isNull()) + instanceObject.nodeName = dataNodeInstancesInstance["NodeName"].asString(); + if(!dataNodeInstancesInstance["BeginWaitTimeTime"].isNull()) + instanceObject.beginWaitTimeTime = std::stol(dataNodeInstancesInstance["BeginWaitTimeTime"].asString()); + if(!dataNodeInstancesInstance["DqcDescription"].isNull()) + instanceObject.dqcDescription = dataNodeInstancesInstance["DqcDescription"].asString(); + if(!dataNodeInstancesInstance["NodeId"].isNull()) + instanceObject.nodeId = std::stol(dataNodeInstancesInstance["NodeId"].asString()); + if(!dataNodeInstancesInstance["CreateUser"].isNull()) + instanceObject.createUser = dataNodeInstancesInstance["CreateUser"].asString(); data_.instances.push_back(instanceObject); } - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); if(!value["ErrorMessage"].isNull()) errorMessage_ = value["ErrorMessage"].asString(); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; } diff --git a/dataworks-public/src/model/ListManualDagInstancesResult.cc b/dataworks-public/src/model/ListManualDagInstancesResult.cc index 5454421f0..e3b0e99ab 100644 --- a/dataworks-public/src/model/ListManualDagInstancesResult.cc +++ b/dataworks-public/src/model/ListManualDagInstancesResult.cc @@ -43,38 +43,40 @@ void ListManualDagInstancesResult::parse(const std::string &payload) for (auto valueInstancesInstancesItem : allInstancesNode) { InstancesItem instancesObject; - if(!valueInstancesInstancesItem["NodeId"].isNull()) - instancesObject.nodeId = std::stol(valueInstancesInstancesItem["NodeId"].asString()); - if(!valueInstancesInstancesItem["InstanceId"].isNull()) - instancesObject.instanceId = std::stol(valueInstancesInstancesItem["InstanceId"].asString()); - if(!valueInstancesInstancesItem["DagId"].isNull()) - instancesObject.dagId = std::stol(valueInstancesInstancesItem["DagId"].asString()); - if(!valueInstancesInstancesItem["DagType"].isNull()) - instancesObject.dagType = valueInstancesInstancesItem["DagType"].asString(); if(!valueInstancesInstancesItem["Status"].isNull()) instancesObject.status = valueInstancesInstancesItem["Status"].asString(); + if(!valueInstancesInstancesItem["BeginRunningTime"].isNull()) + instancesObject.beginRunningTime = std::stol(valueInstancesInstancesItem["BeginRunningTime"].asString()); if(!valueInstancesInstancesItem["BizDate"].isNull()) instancesObject.bizDate = std::stol(valueInstancesInstancesItem["BizDate"].asString()); if(!valueInstancesInstancesItem["CycTime"].isNull()) instancesObject.cycTime = std::stol(valueInstancesInstancesItem["CycTime"].asString()); + if(!valueInstancesInstancesItem["FinishTime"].isNull()) + instancesObject.finishTime = std::stol(valueInstancesInstancesItem["FinishTime"].asString()); if(!valueInstancesInstancesItem["CreateTime"].isNull()) instancesObject.createTime = std::stol(valueInstancesInstancesItem["CreateTime"].asString()); - if(!valueInstancesInstancesItem["ModifyTime"].isNull()) - instancesObject.modifyTime = std::stol(valueInstancesInstancesItem["ModifyTime"].asString()); + if(!valueInstancesInstancesItem["DagId"].isNull()) + instancesObject.dagId = std::stol(valueInstancesInstancesItem["DagId"].asString()); + if(!valueInstancesInstancesItem["InstanceId"].isNull()) + instancesObject.instanceId = std::stol(valueInstancesInstancesItem["InstanceId"].asString()); + if(!valueInstancesInstancesItem["BeginWaitResTime"].isNull()) + instancesObject.beginWaitResTime = std::stol(valueInstancesInstancesItem["BeginWaitResTime"].asString()); + if(!valueInstancesInstancesItem["TaskType"].isNull()) + instancesObject.taskType = valueInstancesInstancesItem["TaskType"].asString(); + if(!valueInstancesInstancesItem["ParamValues"].isNull()) + instancesObject.paramValues = valueInstancesInstancesItem["ParamValues"].asString(); + if(!valueInstancesInstancesItem["DagType"].isNull()) + instancesObject.dagType = valueInstancesInstancesItem["DagType"].asString(); if(!valueInstancesInstancesItem["NodeName"].isNull()) instancesObject.nodeName = valueInstancesInstancesItem["NodeName"].asString(); if(!valueInstancesInstancesItem["BeginWaitTimeTime"].isNull()) instancesObject.beginWaitTimeTime = std::stol(valueInstancesInstancesItem["BeginWaitTimeTime"].asString()); - if(!valueInstancesInstancesItem["BeginWaitResTime"].isNull()) - instancesObject.beginWaitResTime = std::stol(valueInstancesInstancesItem["BeginWaitResTime"].asString()); - if(!valueInstancesInstancesItem["BeginRunningTime"].isNull()) - instancesObject.beginRunningTime = std::stol(valueInstancesInstancesItem["BeginRunningTime"].asString()); - if(!valueInstancesInstancesItem["ParamValues"].isNull()) - instancesObject.paramValues = valueInstancesInstancesItem["ParamValues"].asString(); - if(!valueInstancesInstancesItem["FinishTime"].isNull()) - instancesObject.finishTime = std::stol(valueInstancesInstancesItem["FinishTime"].asString()); - if(!valueInstancesInstancesItem["TaskType"].isNull()) - instancesObject.taskType = valueInstancesInstancesItem["TaskType"].asString(); + if(!valueInstancesInstancesItem["NodeId"].isNull()) + instancesObject.nodeId = std::stol(valueInstancesInstancesItem["NodeId"].asString()); + if(!valueInstancesInstancesItem["ModifyTime"].isNull()) + instancesObject.modifyTime = std::stol(valueInstancesInstancesItem["ModifyTime"].asString()); + if(!valueInstancesInstancesItem["CreateUser"].isNull()) + instancesObject.createUser = valueInstancesInstancesItem["CreateUser"].asString(); instances_.push_back(instancesObject); } diff --git a/dataworks-public/src/model/ListQualityResultsByEntityResult.cc b/dataworks-public/src/model/ListQualityResultsByEntityResult.cc index 1165b478b..13d7afdff 100644 --- a/dataworks-public/src/model/ListQualityResultsByEntityResult.cc +++ b/dataworks-public/src/model/ListQualityResultsByEntityResult.cc @@ -40,118 +40,118 @@ void ListQualityResultsByEntityResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto dataNode = value["Data"]; - if(!dataNode["TotalCount"].isNull()) - data_.totalCount = std::stol(dataNode["TotalCount"].asString()); if(!dataNode["PageNumber"].isNull()) data_.pageNumber = std::stoi(dataNode["PageNumber"].asString()); if(!dataNode["PageSize"].isNull()) data_.pageSize = std::stoi(dataNode["PageSize"].asString()); + if(!dataNode["TotalCount"].isNull()) + data_.totalCount = std::stol(dataNode["TotalCount"].asString()); auto allRuleChecksNode = dataNode["RuleChecks"]["RuleChecksItem"]; for (auto dataNodeRuleChecksRuleChecksItem : allRuleChecksNode) { Data::RuleChecksItem ruleChecksItemObject; - if(!dataNodeRuleChecksRuleChecksItem["Id"].isNull()) - ruleChecksItemObject.id = std::stoi(dataNodeRuleChecksRuleChecksItem["Id"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["TaskId"].isNull()) - ruleChecksItemObject.taskId = dataNodeRuleChecksRuleChecksItem["TaskId"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["EntityId"].isNull()) - ruleChecksItemObject.entityId = std::stoi(dataNodeRuleChecksRuleChecksItem["EntityId"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["RuleId"].isNull()) - ruleChecksItemObject.ruleId = std::stoi(dataNodeRuleChecksRuleChecksItem["RuleId"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["Property"].isNull()) - ruleChecksItemObject.property = dataNodeRuleChecksRuleChecksItem["Property"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["BizDate"].isNull()) - ruleChecksItemObject.bizDate = std::stol(dataNodeRuleChecksRuleChecksItem["BizDate"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["DateType"].isNull()) - ruleChecksItemObject.dateType = dataNodeRuleChecksRuleChecksItem["DateType"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["ActualExpression"].isNull()) - ruleChecksItemObject.actualExpression = dataNodeRuleChecksRuleChecksItem["ActualExpression"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["MatchExpression"].isNull()) - ruleChecksItemObject.matchExpression = dataNodeRuleChecksRuleChecksItem["MatchExpression"].asString(); if(!dataNodeRuleChecksRuleChecksItem["BlockType"].isNull()) ruleChecksItemObject.blockType = std::stoi(dataNodeRuleChecksRuleChecksItem["BlockType"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["CheckResult"].isNull()) - ruleChecksItemObject.checkResult = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResult"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].isNull()) - ruleChecksItemObject.checkResultStatus = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["MethodName"].isNull()) - ruleChecksItemObject.methodName = dataNodeRuleChecksRuleChecksItem["MethodName"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["Comment"].isNull()) - ruleChecksItemObject.comment = dataNodeRuleChecksRuleChecksItem["Comment"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["WhereCondition"].isNull()) - ruleChecksItemObject.whereCondition = dataNodeRuleChecksRuleChecksItem["WhereCondition"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["BeginTime"].isNull()) - ruleChecksItemObject.beginTime = std::stol(dataNodeRuleChecksRuleChecksItem["BeginTime"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["EndTime"].isNull()) - ruleChecksItemObject.endTime = std::stol(dataNodeRuleChecksRuleChecksItem["EndTime"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["TimeCost"].isNull()) - ruleChecksItemObject.timeCost = dataNodeRuleChecksRuleChecksItem["TimeCost"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["ExternalType"].isNull()) - ruleChecksItemObject.externalType = dataNodeRuleChecksRuleChecksItem["ExternalType"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["ExternalId"].isNull()) - ruleChecksItemObject.externalId = dataNodeRuleChecksRuleChecksItem["ExternalId"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].isNull()) - ruleChecksItemObject.discreteCheck = dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].asString() == "true"; - if(!dataNodeRuleChecksRuleChecksItem["FixedCheck"].isNull()) - ruleChecksItemObject.fixedCheck = dataNodeRuleChecksRuleChecksItem["FixedCheck"].asString() == "true"; - if(!dataNodeRuleChecksRuleChecksItem["Trend"].isNull()) - ruleChecksItemObject.trend = dataNodeRuleChecksRuleChecksItem["Trend"].asString(); if(!dataNodeRuleChecksRuleChecksItem["WarningThreshold"].isNull()) ruleChecksItemObject.warningThreshold = std::stof(dataNodeRuleChecksRuleChecksItem["WarningThreshold"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].isNull()) - ruleChecksItemObject.criticalThreshold = std::stof(dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["ExpectValue"].isNull()) - ruleChecksItemObject.expectValue = std::stof(dataNodeRuleChecksRuleChecksItem["ExpectValue"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["Op"].isNull()) - ruleChecksItemObject.op = dataNodeRuleChecksRuleChecksItem["Op"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["ProjectName"].isNull()) - ruleChecksItemObject.projectName = dataNodeRuleChecksRuleChecksItem["ProjectName"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["Property"].isNull()) + ruleChecksItemObject.property = dataNodeRuleChecksRuleChecksItem["Property"].asString(); if(!dataNodeRuleChecksRuleChecksItem["TableName"].isNull()) ruleChecksItemObject.tableName = dataNodeRuleChecksRuleChecksItem["TableName"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["TemplateId"].isNull()) - ruleChecksItemObject.templateId = std::stoi(dataNodeRuleChecksRuleChecksItem["TemplateId"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["Comment"].isNull()) + ruleChecksItemObject.comment = dataNodeRuleChecksRuleChecksItem["Comment"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].isNull()) + ruleChecksItemObject.checkResultStatus = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].asString()); if(!dataNodeRuleChecksRuleChecksItem["TemplateName"].isNull()) ruleChecksItemObject.templateName = dataNodeRuleChecksRuleChecksItem["TemplateName"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["ResultString"].isNull()) - ruleChecksItemObject.resultString = dataNodeRuleChecksRuleChecksItem["ResultString"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["CheckerId"].isNull()) - ruleChecksItemObject.checkerId = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerId"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["CheckerType"].isNull()) - ruleChecksItemObject.checkerType = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerType"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["RuleName"].isNull()) - ruleChecksItemObject.ruleName = dataNodeRuleChecksRuleChecksItem["RuleName"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["IsPrediction"].isNull()) - ruleChecksItemObject.isPrediction = dataNodeRuleChecksRuleChecksItem["IsPrediction"].asString() == "true"; - if(!dataNodeRuleChecksRuleChecksItem["UpperValue"].isNull()) - ruleChecksItemObject.upperValue = std::stof(dataNodeRuleChecksRuleChecksItem["UpperValue"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["LowerValue"].isNull()) - ruleChecksItemObject.lowerValue = std::stof(dataNodeRuleChecksRuleChecksItem["LowerValue"].asString()); if(!dataNodeRuleChecksRuleChecksItem["CheckerName"].isNull()) ruleChecksItemObject.checkerName = dataNodeRuleChecksRuleChecksItem["CheckerName"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["RuleId"].isNull()) + ruleChecksItemObject.ruleId = std::stoi(dataNodeRuleChecksRuleChecksItem["RuleId"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["FixedCheck"].isNull()) + ruleChecksItemObject.fixedCheck = dataNodeRuleChecksRuleChecksItem["FixedCheck"].asString() == "true"; + if(!dataNodeRuleChecksRuleChecksItem["Op"].isNull()) + ruleChecksItemObject.op = dataNodeRuleChecksRuleChecksItem["Op"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["UpperValue"].isNull()) + ruleChecksItemObject.upperValue = std::stof(dataNodeRuleChecksRuleChecksItem["UpperValue"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["ActualExpression"].isNull()) + ruleChecksItemObject.actualExpression = dataNodeRuleChecksRuleChecksItem["ActualExpression"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["ExternalId"].isNull()) + ruleChecksItemObject.externalId = dataNodeRuleChecksRuleChecksItem["ExternalId"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["TimeCost"].isNull()) + ruleChecksItemObject.timeCost = dataNodeRuleChecksRuleChecksItem["TimeCost"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["Trend"].isNull()) + ruleChecksItemObject.trend = dataNodeRuleChecksRuleChecksItem["Trend"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["ExternalType"].isNull()) + ruleChecksItemObject.externalType = dataNodeRuleChecksRuleChecksItem["ExternalType"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["BizDate"].isNull()) + ruleChecksItemObject.bizDate = std::stol(dataNodeRuleChecksRuleChecksItem["BizDate"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["CheckResult"].isNull()) + ruleChecksItemObject.checkResult = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResult"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["ResultString"].isNull()) + ruleChecksItemObject.resultString = dataNodeRuleChecksRuleChecksItem["ResultString"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["MatchExpression"].isNull()) + ruleChecksItemObject.matchExpression = dataNodeRuleChecksRuleChecksItem["MatchExpression"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["CheckerType"].isNull()) + ruleChecksItemObject.checkerType = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerType"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["ProjectName"].isNull()) + ruleChecksItemObject.projectName = dataNodeRuleChecksRuleChecksItem["ProjectName"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["BeginTime"].isNull()) + ruleChecksItemObject.beginTime = std::stol(dataNodeRuleChecksRuleChecksItem["BeginTime"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["DateType"].isNull()) + ruleChecksItemObject.dateType = dataNodeRuleChecksRuleChecksItem["DateType"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].isNull()) + ruleChecksItemObject.criticalThreshold = std::stof(dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["IsPrediction"].isNull()) + ruleChecksItemObject.isPrediction = dataNodeRuleChecksRuleChecksItem["IsPrediction"].asString() == "true"; + if(!dataNodeRuleChecksRuleChecksItem["RuleName"].isNull()) + ruleChecksItemObject.ruleName = dataNodeRuleChecksRuleChecksItem["RuleName"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["CheckerId"].isNull()) + ruleChecksItemObject.checkerId = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerId"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].isNull()) + ruleChecksItemObject.discreteCheck = dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].asString() == "true"; + if(!dataNodeRuleChecksRuleChecksItem["EndTime"].isNull()) + ruleChecksItemObject.endTime = std::stol(dataNodeRuleChecksRuleChecksItem["EndTime"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["MethodName"].isNull()) + ruleChecksItemObject.methodName = dataNodeRuleChecksRuleChecksItem["MethodName"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["LowerValue"].isNull()) + ruleChecksItemObject.lowerValue = std::stof(dataNodeRuleChecksRuleChecksItem["LowerValue"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["EntityId"].isNull()) + ruleChecksItemObject.entityId = std::stoi(dataNodeRuleChecksRuleChecksItem["EntityId"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["WhereCondition"].isNull()) + ruleChecksItemObject.whereCondition = dataNodeRuleChecksRuleChecksItem["WhereCondition"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["ExpectValue"].isNull()) + ruleChecksItemObject.expectValue = std::stof(dataNodeRuleChecksRuleChecksItem["ExpectValue"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["TemplateId"].isNull()) + ruleChecksItemObject.templateId = std::stoi(dataNodeRuleChecksRuleChecksItem["TemplateId"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["TaskId"].isNull()) + ruleChecksItemObject.taskId = dataNodeRuleChecksRuleChecksItem["TaskId"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["Id"].isNull()) + ruleChecksItemObject.id = std::stoi(dataNodeRuleChecksRuleChecksItem["Id"].asString()); auto allReferenceValueNode = dataNodeRuleChecksRuleChecksItem["ReferenceValue"]["ReferenceValueItem"]; for (auto dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem : allReferenceValueNode) { Data::RuleChecksItem::ReferenceValueItem referenceValueObject; - if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].isNull()) - referenceValueObject.bizDate = dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].asString(); if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].isNull()) referenceValueObject.discreteProperty = dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].asString(); if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].isNull()) referenceValueObject.value = std::stof(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].asString()); - if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].isNull()) - referenceValueObject.threshold = std::stof(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].asString()); + if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].isNull()) + referenceValueObject.bizDate = dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].asString(); if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].isNull()) referenceValueObject.singleCheckResult = std::stoi(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].asString()); + if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].isNull()) + referenceValueObject.threshold = std::stof(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].asString()); ruleChecksItemObject.referenceValue.push_back(referenceValueObject); } auto allSampleValueNode = dataNodeRuleChecksRuleChecksItem["SampleValue"]["SampleValueItem"]; for (auto dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem : allSampleValueNode) { Data::RuleChecksItem::SampleValueItem sampleValueObject; - if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].isNull()) - sampleValueObject.bizDate = dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].asString(); if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].isNull()) sampleValueObject.discreteProperty = dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].asString(); + if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].isNull()) + sampleValueObject.bizDate = dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].asString(); if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].isNull()) sampleValueObject.value = std::stof(dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].asString()); ruleChecksItemObject.sampleValue.push_back(sampleValueObject); @@ -162,10 +162,10 @@ void ListQualityResultsByEntityResult::parse(const std::string &payload) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); if(!value["ErrorMessage"].isNull()) errorMessage_ = value["ErrorMessage"].asString(); - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); if(!value["Success"].isNull()) success_ = value["Success"].asString() == "true"; + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); } diff --git a/dataworks-public/src/model/ListQualityResultsByRuleResult.cc b/dataworks-public/src/model/ListQualityResultsByRuleResult.cc index cd6b9a1b8..760e9ab4e 100644 --- a/dataworks-public/src/model/ListQualityResultsByRuleResult.cc +++ b/dataworks-public/src/model/ListQualityResultsByRuleResult.cc @@ -40,132 +40,132 @@ void ListQualityResultsByRuleResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto dataNode = value["Data"]; - if(!dataNode["TotalCount"].isNull()) - data_.totalCount = std::stol(dataNode["TotalCount"].asString()); if(!dataNode["PageNumber"].isNull()) data_.pageNumber = std::stoi(dataNode["PageNumber"].asString()); if(!dataNode["PageSize"].isNull()) data_.pageSize = std::stoi(dataNode["PageSize"].asString()); + if(!dataNode["TotalCount"].isNull()) + data_.totalCount = std::stol(dataNode["TotalCount"].asString()); auto allRuleChecksNode = dataNode["RuleChecks"]["RuleChecksItem"]; for (auto dataNodeRuleChecksRuleChecksItem : allRuleChecksNode) { Data::RuleChecksItem ruleChecksItemObject; - if(!dataNodeRuleChecksRuleChecksItem["Id"].isNull()) - ruleChecksItemObject.id = std::stoi(dataNodeRuleChecksRuleChecksItem["Id"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["TaskId"].isNull()) - ruleChecksItemObject.taskId = dataNodeRuleChecksRuleChecksItem["TaskId"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["EntityId"].isNull()) - ruleChecksItemObject.entityId = std::stoi(dataNodeRuleChecksRuleChecksItem["EntityId"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["RuleId"].isNull()) - ruleChecksItemObject.ruleId = std::stoi(dataNodeRuleChecksRuleChecksItem["RuleId"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["Property"].isNull()) - ruleChecksItemObject.property = dataNodeRuleChecksRuleChecksItem["Property"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["BizDate"].isNull()) - ruleChecksItemObject.bizDate = std::stol(dataNodeRuleChecksRuleChecksItem["BizDate"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["DateType"].isNull()) - ruleChecksItemObject.dateType = dataNodeRuleChecksRuleChecksItem["DateType"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["ActualExpression"].isNull()) - ruleChecksItemObject.actualExpression = dataNodeRuleChecksRuleChecksItem["ActualExpression"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["MatchExpression"].isNull()) - ruleChecksItemObject.matchExpression = dataNodeRuleChecksRuleChecksItem["MatchExpression"].asString(); if(!dataNodeRuleChecksRuleChecksItem["BlockType"].isNull()) ruleChecksItemObject.blockType = std::stoi(dataNodeRuleChecksRuleChecksItem["BlockType"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["CheckResult"].isNull()) - ruleChecksItemObject.checkResult = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResult"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].isNull()) - ruleChecksItemObject.checkResultStatus = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["MethodName"].isNull()) - ruleChecksItemObject.methodName = dataNodeRuleChecksRuleChecksItem["MethodName"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["Comment"].isNull()) - ruleChecksItemObject.comment = dataNodeRuleChecksRuleChecksItem["Comment"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["WhereCondition"].isNull()) - ruleChecksItemObject.whereCondition = dataNodeRuleChecksRuleChecksItem["WhereCondition"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["BeginTime"].isNull()) - ruleChecksItemObject.beginTime = std::stol(dataNodeRuleChecksRuleChecksItem["BeginTime"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["EndTime"].isNull()) - ruleChecksItemObject.endTime = std::stol(dataNodeRuleChecksRuleChecksItem["EndTime"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["TimeCost"].isNull()) - ruleChecksItemObject.timeCost = dataNodeRuleChecksRuleChecksItem["TimeCost"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["ExternalType"].isNull()) - ruleChecksItemObject.externalType = dataNodeRuleChecksRuleChecksItem["ExternalType"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["ExternalId"].isNull()) - ruleChecksItemObject.externalId = dataNodeRuleChecksRuleChecksItem["ExternalId"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].isNull()) - ruleChecksItemObject.discreteCheck = dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].asString() == "true"; - if(!dataNodeRuleChecksRuleChecksItem["FixedCheck"].isNull()) - ruleChecksItemObject.fixedCheck = dataNodeRuleChecksRuleChecksItem["FixedCheck"].asString() == "true"; - if(!dataNodeRuleChecksRuleChecksItem["Trend"].isNull()) - ruleChecksItemObject.trend = dataNodeRuleChecksRuleChecksItem["Trend"].asString(); if(!dataNodeRuleChecksRuleChecksItem["WarningThreshold"].isNull()) ruleChecksItemObject.warningThreshold = std::stof(dataNodeRuleChecksRuleChecksItem["WarningThreshold"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].isNull()) - ruleChecksItemObject.criticalThreshold = std::stof(dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["ExpectValue"].isNull()) - ruleChecksItemObject.expectValue = std::stof(dataNodeRuleChecksRuleChecksItem["ExpectValue"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["Op"].isNull()) - ruleChecksItemObject.op = dataNodeRuleChecksRuleChecksItem["Op"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["ProjectName"].isNull()) - ruleChecksItemObject.projectName = dataNodeRuleChecksRuleChecksItem["ProjectName"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["Property"].isNull()) + ruleChecksItemObject.property = dataNodeRuleChecksRuleChecksItem["Property"].asString(); if(!dataNodeRuleChecksRuleChecksItem["TableName"].isNull()) ruleChecksItemObject.tableName = dataNodeRuleChecksRuleChecksItem["TableName"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["TemplateId"].isNull()) - ruleChecksItemObject.templateId = std::stoi(dataNodeRuleChecksRuleChecksItem["TemplateId"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["Comment"].isNull()) + ruleChecksItemObject.comment = dataNodeRuleChecksRuleChecksItem["Comment"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].isNull()) + ruleChecksItemObject.checkResultStatus = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResultStatus"].asString()); if(!dataNodeRuleChecksRuleChecksItem["TemplateName"].isNull()) ruleChecksItemObject.templateName = dataNodeRuleChecksRuleChecksItem["TemplateName"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["ResultString"].isNull()) - ruleChecksItemObject.resultString = dataNodeRuleChecksRuleChecksItem["ResultString"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["CheckerId"].isNull()) - ruleChecksItemObject.checkerId = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerId"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["CheckerType"].isNull()) - ruleChecksItemObject.checkerType = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerType"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["RuleName"].isNull()) - ruleChecksItemObject.ruleName = dataNodeRuleChecksRuleChecksItem["RuleName"].asString(); - if(!dataNodeRuleChecksRuleChecksItem["IsPrediction"].isNull()) - ruleChecksItemObject.isPrediction = dataNodeRuleChecksRuleChecksItem["IsPrediction"].asString() == "true"; - if(!dataNodeRuleChecksRuleChecksItem["UpperValue"].isNull()) - ruleChecksItemObject.upperValue = std::stof(dataNodeRuleChecksRuleChecksItem["UpperValue"].asString()); - if(!dataNodeRuleChecksRuleChecksItem["LowerValue"].isNull()) - ruleChecksItemObject.lowerValue = std::stof(dataNodeRuleChecksRuleChecksItem["LowerValue"].asString()); if(!dataNodeRuleChecksRuleChecksItem["CheckerName"].isNull()) ruleChecksItemObject.checkerName = dataNodeRuleChecksRuleChecksItem["CheckerName"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["RuleId"].isNull()) + ruleChecksItemObject.ruleId = std::stoi(dataNodeRuleChecksRuleChecksItem["RuleId"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["FixedCheck"].isNull()) + ruleChecksItemObject.fixedCheck = dataNodeRuleChecksRuleChecksItem["FixedCheck"].asString() == "true"; + if(!dataNodeRuleChecksRuleChecksItem["Op"].isNull()) + ruleChecksItemObject.op = dataNodeRuleChecksRuleChecksItem["Op"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["UpperValue"].isNull()) + ruleChecksItemObject.upperValue = std::stof(dataNodeRuleChecksRuleChecksItem["UpperValue"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["ActualExpression"].isNull()) + ruleChecksItemObject.actualExpression = dataNodeRuleChecksRuleChecksItem["ActualExpression"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["ExternalId"].isNull()) + ruleChecksItemObject.externalId = dataNodeRuleChecksRuleChecksItem["ExternalId"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["TimeCost"].isNull()) + ruleChecksItemObject.timeCost = dataNodeRuleChecksRuleChecksItem["TimeCost"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["Trend"].isNull()) + ruleChecksItemObject.trend = dataNodeRuleChecksRuleChecksItem["Trend"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["ExternalType"].isNull()) + ruleChecksItemObject.externalType = dataNodeRuleChecksRuleChecksItem["ExternalType"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["BizDate"].isNull()) + ruleChecksItemObject.bizDate = std::stol(dataNodeRuleChecksRuleChecksItem["BizDate"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["CheckResult"].isNull()) + ruleChecksItemObject.checkResult = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckResult"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["ResultString"].isNull()) + ruleChecksItemObject.resultString = dataNodeRuleChecksRuleChecksItem["ResultString"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["MatchExpression"].isNull()) + ruleChecksItemObject.matchExpression = dataNodeRuleChecksRuleChecksItem["MatchExpression"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["CheckerType"].isNull()) + ruleChecksItemObject.checkerType = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerType"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["ProjectName"].isNull()) + ruleChecksItemObject.projectName = dataNodeRuleChecksRuleChecksItem["ProjectName"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["BeginTime"].isNull()) + ruleChecksItemObject.beginTime = std::stol(dataNodeRuleChecksRuleChecksItem["BeginTime"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["DateType"].isNull()) + ruleChecksItemObject.dateType = dataNodeRuleChecksRuleChecksItem["DateType"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].isNull()) + ruleChecksItemObject.criticalThreshold = std::stof(dataNodeRuleChecksRuleChecksItem["CriticalThreshold"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["IsPrediction"].isNull()) + ruleChecksItemObject.isPrediction = dataNodeRuleChecksRuleChecksItem["IsPrediction"].asString() == "true"; + if(!dataNodeRuleChecksRuleChecksItem["RuleName"].isNull()) + ruleChecksItemObject.ruleName = dataNodeRuleChecksRuleChecksItem["RuleName"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["CheckerId"].isNull()) + ruleChecksItemObject.checkerId = std::stoi(dataNodeRuleChecksRuleChecksItem["CheckerId"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].isNull()) + ruleChecksItemObject.discreteCheck = dataNodeRuleChecksRuleChecksItem["DiscreteCheck"].asString() == "true"; + if(!dataNodeRuleChecksRuleChecksItem["EndTime"].isNull()) + ruleChecksItemObject.endTime = std::stol(dataNodeRuleChecksRuleChecksItem["EndTime"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["MethodName"].isNull()) + ruleChecksItemObject.methodName = dataNodeRuleChecksRuleChecksItem["MethodName"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["LowerValue"].isNull()) + ruleChecksItemObject.lowerValue = std::stof(dataNodeRuleChecksRuleChecksItem["LowerValue"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["EntityId"].isNull()) + ruleChecksItemObject.entityId = std::stoi(dataNodeRuleChecksRuleChecksItem["EntityId"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["WhereCondition"].isNull()) + ruleChecksItemObject.whereCondition = dataNodeRuleChecksRuleChecksItem["WhereCondition"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["ExpectValue"].isNull()) + ruleChecksItemObject.expectValue = std::stof(dataNodeRuleChecksRuleChecksItem["ExpectValue"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["TemplateId"].isNull()) + ruleChecksItemObject.templateId = std::stoi(dataNodeRuleChecksRuleChecksItem["TemplateId"].asString()); + if(!dataNodeRuleChecksRuleChecksItem["TaskId"].isNull()) + ruleChecksItemObject.taskId = dataNodeRuleChecksRuleChecksItem["TaskId"].asString(); + if(!dataNodeRuleChecksRuleChecksItem["Id"].isNull()) + ruleChecksItemObject.id = std::stoi(dataNodeRuleChecksRuleChecksItem["Id"].asString()); auto allReferenceValueNode = dataNodeRuleChecksRuleChecksItem["ReferenceValue"]["ReferenceValueItem"]; for (auto dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem : allReferenceValueNode) { Data::RuleChecksItem::ReferenceValueItem referenceValueObject; - if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].isNull()) - referenceValueObject.bizDate = dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].asString(); if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].isNull()) referenceValueObject.discreteProperty = dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].asString(); if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].isNull()) referenceValueObject.value = std::stof(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].asString()); - if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].isNull()) - referenceValueObject.threshold = std::stof(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].asString()); + if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].isNull()) + referenceValueObject.bizDate = dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].asString(); if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].isNull()) referenceValueObject.singleCheckResult = std::stoi(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].asString()); + if(!dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].isNull()) + referenceValueObject.threshold = std::stof(dataNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].asString()); ruleChecksItemObject.referenceValue.push_back(referenceValueObject); } auto allSampleValueNode = dataNodeRuleChecksRuleChecksItem["SampleValue"]["SampleValueItem"]; for (auto dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem : allSampleValueNode) { Data::RuleChecksItem::SampleValueItem sampleValueObject; - if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].isNull()) - sampleValueObject.bizDate = dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].asString(); if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].isNull()) sampleValueObject.discreteProperty = dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].asString(); + if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].isNull()) + sampleValueObject.bizDate = dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].asString(); if(!dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].isNull()) sampleValueObject.value = std::stof(dataNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].asString()); ruleChecksItemObject.sampleValue.push_back(sampleValueObject); } data_.ruleChecks.push_back(ruleChecksItemObject); } - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); - if(!value["ErrorMessage"].isNull()) - errorMessage_ = value["ErrorMessage"].asString(); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; } diff --git a/dataworks-public/src/model/ListQualityRulesResult.cc b/dataworks-public/src/model/ListQualityRulesResult.cc index d3607c054..93ac1d6cf 100644 --- a/dataworks-public/src/model/ListQualityRulesResult.cc +++ b/dataworks-public/src/model/ListQualityRulesResult.cc @@ -40,76 +40,78 @@ void ListQualityRulesResult::parse(const std::string &payload) reader.parse(payload, value); setRequestId(value["RequestId"].asString()); auto dataNode = value["Data"]; - if(!dataNode["TotalCount"].isNull()) - data_.totalCount = std::stol(dataNode["TotalCount"].asString()); if(!dataNode["PageNumber"].isNull()) data_.pageNumber = std::stoi(dataNode["PageNumber"].asString()); if(!dataNode["PageSize"].isNull()) data_.pageSize = std::stoi(dataNode["PageSize"].asString()); + if(!dataNode["TotalCount"].isNull()) + data_.totalCount = std::stol(dataNode["TotalCount"].asString()); auto allRulesNode = dataNode["Rules"]["RulesItem"]; for (auto dataNodeRulesRulesItem : allRulesNode) { Data::RulesItem rulesItemObject; - if(!dataNodeRulesRulesItem["ProjectName"].isNull()) - rulesItemObject.projectName = dataNodeRulesRulesItem["ProjectName"].asString(); - if(!dataNodeRulesRulesItem["TableName"].isNull()) - rulesItemObject.tableName = dataNodeRulesRulesItem["TableName"].asString(); - if(!dataNodeRulesRulesItem["Id"].isNull()) - rulesItemObject.id = std::stoi(dataNodeRulesRulesItem["Id"].asString()); - if(!dataNodeRulesRulesItem["EntityId"].isNull()) - rulesItemObject.entityId = std::stoi(dataNodeRulesRulesItem["EntityId"].asString()); - if(!dataNodeRulesRulesItem["Property"].isNull()) - rulesItemObject.property = dataNodeRulesRulesItem["Property"].asString(); - if(!dataNodeRulesRulesItem["MethodId"].isNull()) - rulesItemObject.methodId = std::stoi(dataNodeRulesRulesItem["MethodId"].asString()); - if(!dataNodeRulesRulesItem["MethodName"].isNull()) - rulesItemObject.methodName = dataNodeRulesRulesItem["MethodName"].asString(); - if(!dataNodeRulesRulesItem["OnDuty"].isNull()) - rulesItemObject.onDuty = dataNodeRulesRulesItem["OnDuty"].asString(); - if(!dataNodeRulesRulesItem["RuleType"].isNull()) - rulesItemObject.ruleType = std::stoi(dataNodeRulesRulesItem["RuleType"].asString()); if(!dataNodeRulesRulesItem["BlockType"].isNull()) rulesItemObject.blockType = std::stoi(dataNodeRulesRulesItem["BlockType"].asString()); - if(!dataNodeRulesRulesItem["TemplateId"].isNull()) - rulesItemObject.templateId = std::stoi(dataNodeRulesRulesItem["TemplateId"].asString()); - if(!dataNodeRulesRulesItem["TemplateName"].isNull()) - rulesItemObject.templateName = dataNodeRulesRulesItem["TemplateName"].asString(); - if(!dataNodeRulesRulesItem["RuleCheckerRelationId"].isNull()) - rulesItemObject.ruleCheckerRelationId = std::stoi(dataNodeRulesRulesItem["RuleCheckerRelationId"].asString()); - if(!dataNodeRulesRulesItem["CheckerId"].isNull()) - rulesItemObject.checkerId = std::stoi(dataNodeRulesRulesItem["CheckerId"].asString()); - if(!dataNodeRulesRulesItem["FixCheck"].isNull()) - rulesItemObject.fixCheck = dataNodeRulesRulesItem["FixCheck"].asString() == "true"; - if(!dataNodeRulesRulesItem["Trend"].isNull()) - rulesItemObject.trend = dataNodeRulesRulesItem["Trend"].asString(); - if(!dataNodeRulesRulesItem["WarningThreshold"].isNull()) - rulesItemObject.warningThreshold = dataNodeRulesRulesItem["WarningThreshold"].asString(); - if(!dataNodeRulesRulesItem["CriticalThreshold"].isNull()) - rulesItemObject.criticalThreshold = dataNodeRulesRulesItem["CriticalThreshold"].asString(); - if(!dataNodeRulesRulesItem["HistoryWarningThreshold"].isNull()) - rulesItemObject.historyWarningThreshold = dataNodeRulesRulesItem["HistoryWarningThreshold"].asString(); - if(!dataNodeRulesRulesItem["HistoryCriticalThreshold"].isNull()) - rulesItemObject.historyCriticalThreshold = dataNodeRulesRulesItem["HistoryCriticalThreshold"].asString(); - if(!dataNodeRulesRulesItem["PropertyKey"].isNull()) - rulesItemObject.propertyKey = dataNodeRulesRulesItem["PropertyKey"].asString(); - if(!dataNodeRulesRulesItem["MatchExpression"].isNull()) - rulesItemObject.matchExpression = dataNodeRulesRulesItem["MatchExpression"].asString(); - if(!dataNodeRulesRulesItem["Comment"].isNull()) - rulesItemObject.comment = dataNodeRulesRulesItem["Comment"].asString(); - if(!dataNodeRulesRulesItem["ExpectValue"].isNull()) - rulesItemObject.expectValue = dataNodeRulesRulesItem["ExpectValue"].asString(); if(!dataNodeRulesRulesItem["OnDutyAccountName"].isNull()) rulesItemObject.onDutyAccountName = dataNodeRulesRulesItem["OnDutyAccountName"].asString(); + if(!dataNodeRulesRulesItem["Property"].isNull()) + rulesItemObject.property = dataNodeRulesRulesItem["Property"].asString(); + if(!dataNodeRulesRulesItem["WarningThreshold"].isNull()) + rulesItemObject.warningThreshold = dataNodeRulesRulesItem["WarningThreshold"].asString(); + if(!dataNodeRulesRulesItem["TableName"].isNull()) + rulesItemObject.tableName = dataNodeRulesRulesItem["TableName"].asString(); + if(!dataNodeRulesRulesItem["OnDuty"].isNull()) + rulesItemObject.onDuty = dataNodeRulesRulesItem["OnDuty"].asString(); + if(!dataNodeRulesRulesItem["Comment"].isNull()) + rulesItemObject.comment = dataNodeRulesRulesItem["Comment"].asString(); + if(!dataNodeRulesRulesItem["RuleCheckerRelationId"].isNull()) + rulesItemObject.ruleCheckerRelationId = std::stoi(dataNodeRulesRulesItem["RuleCheckerRelationId"].asString()); + if(!dataNodeRulesRulesItem["FixCheck"].isNull()) + rulesItemObject.fixCheck = dataNodeRulesRulesItem["FixCheck"].asString() == "true"; + if(!dataNodeRulesRulesItem["MethodId"].isNull()) + rulesItemObject.methodId = std::stoi(dataNodeRulesRulesItem["MethodId"].asString()); + if(!dataNodeRulesRulesItem["TemplateName"].isNull()) + rulesItemObject.templateName = dataNodeRulesRulesItem["TemplateName"].asString(); + if(!dataNodeRulesRulesItem["Trend"].isNull()) + rulesItemObject.trend = dataNodeRulesRulesItem["Trend"].asString(); + if(!dataNodeRulesRulesItem["HistoryWarningThreshold"].isNull()) + rulesItemObject.historyWarningThreshold = dataNodeRulesRulesItem["HistoryWarningThreshold"].asString(); + if(!dataNodeRulesRulesItem["RuleType"].isNull()) + rulesItemObject.ruleType = std::stoi(dataNodeRulesRulesItem["RuleType"].asString()); + if(!dataNodeRulesRulesItem["MatchExpression"].isNull()) + rulesItemObject.matchExpression = dataNodeRulesRulesItem["MatchExpression"].asString(); + if(!dataNodeRulesRulesItem["ProjectName"].isNull()) + rulesItemObject.projectName = dataNodeRulesRulesItem["ProjectName"].asString(); + if(!dataNodeRulesRulesItem["PropertyKey"].isNull()) + rulesItemObject.propertyKey = dataNodeRulesRulesItem["PropertyKey"].asString(); + if(!dataNodeRulesRulesItem["CriticalThreshold"].isNull()) + rulesItemObject.criticalThreshold = dataNodeRulesRulesItem["CriticalThreshold"].asString(); + if(!dataNodeRulesRulesItem["HistoryCriticalThreshold"].isNull()) + rulesItemObject.historyCriticalThreshold = dataNodeRulesRulesItem["HistoryCriticalThreshold"].asString(); + if(!dataNodeRulesRulesItem["MethodName"].isNull()) + rulesItemObject.methodName = dataNodeRulesRulesItem["MethodName"].asString(); + if(!dataNodeRulesRulesItem["CheckerId"].isNull()) + rulesItemObject.checkerId = std::stoi(dataNodeRulesRulesItem["CheckerId"].asString()); + if(!dataNodeRulesRulesItem["EntityId"].isNull()) + rulesItemObject.entityId = std::stoi(dataNodeRulesRulesItem["EntityId"].asString()); + if(!dataNodeRulesRulesItem["ExpectValue"].isNull()) + rulesItemObject.expectValue = dataNodeRulesRulesItem["ExpectValue"].asString(); + if(!dataNodeRulesRulesItem["TemplateId"].isNull()) + rulesItemObject.templateId = std::stoi(dataNodeRulesRulesItem["TemplateId"].asString()); + if(!dataNodeRulesRulesItem["Id"].isNull()) + rulesItemObject.id = std::stoi(dataNodeRulesRulesItem["Id"].asString()); + if(!dataNodeRulesRulesItem["RuleName"].isNull()) + rulesItemObject.ruleName = dataNodeRulesRulesItem["RuleName"].asString(); data_.rules.push_back(rulesItemObject); } - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; - if(!value["ErrorMessage"].isNull()) - errorMessage_ = value["ErrorMessage"].asString(); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); } diff --git a/dataworks-public/src/model/UpdateIDEEventResultRequest.cc b/dataworks-public/src/model/UpdateIDEEventResultRequest.cc new file mode 100644 index 000000000..69f83e32c --- /dev/null +++ b/dataworks-public/src/model/UpdateIDEEventResultRequest.cc @@ -0,0 +1,73 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Dataworks_public::Model::UpdateIDEEventResultRequest; + +UpdateIDEEventResultRequest::UpdateIDEEventResultRequest() : + RpcServiceRequest("dataworks-public", "2020-05-18", "UpdateIDEEventResult") +{ + setMethod(HttpRequest::Method::Post); +} + +UpdateIDEEventResultRequest::~UpdateIDEEventResultRequest() +{} + +std::string UpdateIDEEventResultRequest::getCheckResultTip()const +{ + return checkResultTip_; +} + +void UpdateIDEEventResultRequest::setCheckResultTip(const std::string& checkResultTip) +{ + checkResultTip_ = checkResultTip; + setBodyParameter("CheckResultTip", checkResultTip); +} + +std::string UpdateIDEEventResultRequest::getCheckResult()const +{ + return checkResult_; +} + +void UpdateIDEEventResultRequest::setCheckResult(const std::string& checkResult) +{ + checkResult_ = checkResult; + setBodyParameter("CheckResult", checkResult); +} + +std::string UpdateIDEEventResultRequest::getMessageId()const +{ + return messageId_; +} + +void UpdateIDEEventResultRequest::setMessageId(const std::string& messageId) +{ + messageId_ = messageId; + setBodyParameter("MessageId", messageId); +} + +std::string UpdateIDEEventResultRequest::getExtensionCode()const +{ + return extensionCode_; +} + +void UpdateIDEEventResultRequest::setExtensionCode(const std::string& extensionCode) +{ + extensionCode_ = extensionCode; + setBodyParameter("ExtensionCode", extensionCode); +} + diff --git a/dataworks-public/src/model/UpdateIDEEventResultResult.cc b/dataworks-public/src/model/UpdateIDEEventResultResult.cc new file mode 100644 index 000000000..266e3f706 --- /dev/null +++ b/dataworks-public/src/model/UpdateIDEEventResultResult.cc @@ -0,0 +1,44 @@ +/* + * 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::Dataworks_public; +using namespace AlibabaCloud::Dataworks_public::Model; + +UpdateIDEEventResultResult::UpdateIDEEventResultResult() : + ServiceResult() +{} + +UpdateIDEEventResultResult::UpdateIDEEventResultResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateIDEEventResultResult::~UpdateIDEEventResultResult() +{} + +void UpdateIDEEventResultResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/dataworks-public/src/model/UpdateQualityFollowerResult.cc b/dataworks-public/src/model/UpdateQualityFollowerResult.cc index 98c135d2c..7aba6810f 100644 --- a/dataworks-public/src/model/UpdateQualityFollowerResult.cc +++ b/dataworks-public/src/model/UpdateQualityFollowerResult.cc @@ -39,16 +39,16 @@ void UpdateQualityFollowerResult::parse(const std::string &payload) Json::Value value; reader.parse(payload, value); setRequestId(value["RequestId"].asString()); - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); - if(!value["Data"].isNull()) - data_ = value["Data"].asString() == "true"; - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; - if(!value["ErrorMessage"].isNull()) - errorMessage_ = value["ErrorMessage"].asString(); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + if(!value["Data"].isNull()) + data_ = value["Data"].asString() == "true"; + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; } diff --git a/dataworks-public/src/model/UpdateQualityRuleResult.cc b/dataworks-public/src/model/UpdateQualityRuleResult.cc index a630733e5..8277ebfee 100644 --- a/dataworks-public/src/model/UpdateQualityRuleResult.cc +++ b/dataworks-public/src/model/UpdateQualityRuleResult.cc @@ -39,16 +39,16 @@ void UpdateQualityRuleResult::parse(const std::string &payload) Json::Value value; reader.parse(payload, value); setRequestId(value["RequestId"].asString()); - if(!value["ErrorCode"].isNull()) - errorCode_ = value["ErrorCode"].asString(); - if(!value["Data"].isNull()) - data_ = value["Data"].asString() == "true"; - if(!value["Success"].isNull()) - success_ = value["Success"].asString() == "true"; - if(!value["ErrorMessage"].isNull()) - errorMessage_ = value["ErrorMessage"].asString(); if(!value["HttpStatusCode"].isNull()) httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString()); + if(!value["Data"].isNull()) + data_ = value["Data"].asString() == "true"; + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; }