From 2acf4250c608b40cad98053bd873e57e47a576aa Mon Sep 17 00:00:00 2001 From: sdk-team Date: Thu, 3 Dec 2020 07:29:53 +0000 Subject: [PATCH] Generated 2020-05-18 for dataworks-public. --- CHANGELOG | 3 + dataworks-public/CMakeLists.txt | 20 ++ .../dataworks-public/Dataworks_publicClient.h | 40 ++++ .../model/CreateManualDagRequest.h | 63 ++++++ .../model/CreateManualDagResult.h | 51 +++++ .../model/CreateTableRequest.h | 3 + .../dataworks-public/model/GetDagRequest.h | 51 +++++ .../dataworks-public/model/GetDagResult.h | 74 +++++++ .../model/GetInstanceResult.h | 9 + .../model/GetManualDagInstancesRequest.h | 54 ++++++ .../model/GetManualDagInstancesResult.h | 69 +++++++ .../dataworks-public/model/GetNodeResult.h | 15 +- .../model/ListInstancesRequest.h | 3 + .../model/ListInstancesResult.h | 9 + .../dataworks-public/model/ListNodeIOResult.h | 1 + .../dataworks-public/model/ListNodesResult.h | 15 +- .../model/RunTriggerNodeRequest.h | 57 ++++++ .../model/RunTriggerNodeResult.h | 51 +++++ .../model/SearchNodesByOutputRequest.h | 51 +++++ .../model/SearchNodesByOutputResult.h | 59 ++++++ .../src/Dataworks-publicClient.cc | 180 ++++++++++++++++++ .../src/model/CreateManualDagRequest.cc | 95 +++++++++ .../src/model/CreateManualDagResult.cc | 51 +++++ .../src/model/CreateTableRequest.cc | 11 ++ .../src/model/GetBaselineKeyPathResult.cc | 88 ++++----- dataworks-public/src/model/GetDagRequest.cc | 51 +++++ dataworks-public/src/model/GetDagResult.cc | 102 ++++++++++ .../src/model/GetInstanceResult.cc | 18 ++ .../src/model/GetManualDagInstancesRequest.cc | 62 ++++++ .../src/model/GetManualDagInstancesResult.cc | 85 +++++++++ dataworks-public/src/model/GetNodeResult.cc | 14 ++ .../src/model/ListAlertMessagesResult.cc | 72 +++---- .../ListDataServiceApiAuthoritiesResult.cc | 20 +- .../src/model/ListInstancesRequest.cc | 11 ++ .../src/model/ListInstancesResult.cc | 18 ++ .../src/model/ListNodeIOResult.cc | 2 + dataworks-public/src/model/ListNodesResult.cc | 14 ++ .../src/model/ListProjectMembersResult.cc | 20 +- .../model/ListQualityResultsByEntityResult.cc | 40 ++-- .../model/ListQualityResultsByRuleResult.cc | 40 ++-- .../src/model/RunTriggerNodeRequest.cc | 73 +++++++ .../src/model/RunTriggerNodeResult.cc | 51 +++++ .../src/model/SearchNodesByOutputRequest.cc | 51 +++++ .../src/model/SearchNodesByOutputResult.cc | 79 ++++++++ 44 files changed, 1798 insertions(+), 148 deletions(-) create mode 100644 dataworks-public/include/alibabacloud/dataworks-public/model/CreateManualDagRequest.h create mode 100644 dataworks-public/include/alibabacloud/dataworks-public/model/CreateManualDagResult.h create mode 100644 dataworks-public/include/alibabacloud/dataworks-public/model/GetDagRequest.h create mode 100644 dataworks-public/include/alibabacloud/dataworks-public/model/GetDagResult.h create mode 100644 dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesRequest.h create mode 100644 dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesResult.h create mode 100644 dataworks-public/include/alibabacloud/dataworks-public/model/RunTriggerNodeRequest.h create mode 100644 dataworks-public/include/alibabacloud/dataworks-public/model/RunTriggerNodeResult.h create mode 100644 dataworks-public/include/alibabacloud/dataworks-public/model/SearchNodesByOutputRequest.h create mode 100644 dataworks-public/include/alibabacloud/dataworks-public/model/SearchNodesByOutputResult.h create mode 100644 dataworks-public/src/model/CreateManualDagRequest.cc create mode 100644 dataworks-public/src/model/CreateManualDagResult.cc create mode 100644 dataworks-public/src/model/GetDagRequest.cc create mode 100644 dataworks-public/src/model/GetDagResult.cc create mode 100644 dataworks-public/src/model/GetManualDagInstancesRequest.cc create mode 100644 dataworks-public/src/model/GetManualDagInstancesResult.cc create mode 100644 dataworks-public/src/model/RunTriggerNodeRequest.cc create mode 100644 dataworks-public/src/model/RunTriggerNodeResult.cc create mode 100644 dataworks-public/src/model/SearchNodesByOutputRequest.cc create mode 100644 dataworks-public/src/model/SearchNodesByOutputResult.cc diff --git a/CHANGELOG b/CHANGELOG index e1736f4d4..feee6d3ac 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,6 @@ +2020-12-03 Version: patch +- Generated 2020-05-18 for `dataworks-public`. + 2020-12-03 Version: patch - Add new api. diff --git a/dataworks-public/CMakeLists.txt b/dataworks-public/CMakeLists.txt index 0ec43b27d..b4df6c823 100644 --- a/dataworks-public/CMakeLists.txt +++ b/dataworks-public/CMakeLists.txt @@ -49,6 +49,8 @@ set(dataworks-public_public_header_model include/alibabacloud/dataworks-public/model/CreateFileResult.h include/alibabacloud/dataworks-public/model/CreateFolderRequest.h include/alibabacloud/dataworks-public/model/CreateFolderResult.h + include/alibabacloud/dataworks-public/model/CreateManualDagRequest.h + include/alibabacloud/dataworks-public/model/CreateManualDagResult.h include/alibabacloud/dataworks-public/model/CreateMetaCategoryRequest.h include/alibabacloud/dataworks-public/model/CreateMetaCategoryResult.h include/alibabacloud/dataworks-public/model/CreateProjectMemberRequest.h @@ -119,6 +121,8 @@ set(dataworks-public_public_header_model include/alibabacloud/dataworks-public/model/GetBusinessResult.h include/alibabacloud/dataworks-public/model/GetDDLJobStatusRequest.h include/alibabacloud/dataworks-public/model/GetDDLJobStatusResult.h + include/alibabacloud/dataworks-public/model/GetDagRequest.h + include/alibabacloud/dataworks-public/model/GetDagResult.h include/alibabacloud/dataworks-public/model/GetDataServiceApiRequest.h include/alibabacloud/dataworks-public/model/GetDataServiceApiResult.h include/alibabacloud/dataworks-public/model/GetDataServiceApplicationRequest.h @@ -149,6 +153,8 @@ set(dataworks-public_public_header_model include/alibabacloud/dataworks-public/model/GetInstanceLogResult.h include/alibabacloud/dataworks-public/model/GetInstanceStatusCountRequest.h include/alibabacloud/dataworks-public/model/GetInstanceStatusCountResult.h + include/alibabacloud/dataworks-public/model/GetManualDagInstancesRequest.h + include/alibabacloud/dataworks-public/model/GetManualDagInstancesResult.h include/alibabacloud/dataworks-public/model/GetMetaCategoryRequest.h include/alibabacloud/dataworks-public/model/GetMetaCategoryResult.h include/alibabacloud/dataworks-public/model/GetMetaColumnLineageRequest.h @@ -271,8 +277,12 @@ set(dataworks-public_public_header_model include/alibabacloud/dataworks-public/model/RestartInstanceResult.h include/alibabacloud/dataworks-public/model/ResumeInstanceRequest.h include/alibabacloud/dataworks-public/model/ResumeInstanceResult.h + include/alibabacloud/dataworks-public/model/RunTriggerNodeRequest.h + include/alibabacloud/dataworks-public/model/RunTriggerNodeResult.h include/alibabacloud/dataworks-public/model/SearchMetaTablesRequest.h include/alibabacloud/dataworks-public/model/SearchMetaTablesResult.h + include/alibabacloud/dataworks-public/model/SearchNodesByOutputRequest.h + include/alibabacloud/dataworks-public/model/SearchNodesByOutputResult.h include/alibabacloud/dataworks-public/model/SetSuccessInstanceRequest.h include/alibabacloud/dataworks-public/model/SetSuccessInstanceResult.h include/alibabacloud/dataworks-public/model/StopInstanceRequest.h @@ -344,6 +354,8 @@ set(dataworks-public_src src/model/CreateFileResult.cc src/model/CreateFolderRequest.cc src/model/CreateFolderResult.cc + src/model/CreateManualDagRequest.cc + src/model/CreateManualDagResult.cc src/model/CreateMetaCategoryRequest.cc src/model/CreateMetaCategoryResult.cc src/model/CreateProjectMemberRequest.cc @@ -414,6 +426,8 @@ set(dataworks-public_src src/model/GetBusinessResult.cc src/model/GetDDLJobStatusRequest.cc src/model/GetDDLJobStatusResult.cc + src/model/GetDagRequest.cc + src/model/GetDagResult.cc src/model/GetDataServiceApiRequest.cc src/model/GetDataServiceApiResult.cc src/model/GetDataServiceApplicationRequest.cc @@ -444,6 +458,8 @@ set(dataworks-public_src src/model/GetInstanceLogResult.cc src/model/GetInstanceStatusCountRequest.cc src/model/GetInstanceStatusCountResult.cc + src/model/GetManualDagInstancesRequest.cc + src/model/GetManualDagInstancesResult.cc src/model/GetMetaCategoryRequest.cc src/model/GetMetaCategoryResult.cc src/model/GetMetaColumnLineageRequest.cc @@ -566,8 +582,12 @@ set(dataworks-public_src src/model/RestartInstanceResult.cc src/model/ResumeInstanceRequest.cc src/model/ResumeInstanceResult.cc + src/model/RunTriggerNodeRequest.cc + src/model/RunTriggerNodeResult.cc src/model/SearchMetaTablesRequest.cc src/model/SearchMetaTablesResult.cc + src/model/SearchNodesByOutputRequest.cc + src/model/SearchNodesByOutputResult.cc src/model/SetSuccessInstanceRequest.cc src/model/SetSuccessInstanceResult.cc src/model/StopInstanceRequest.cc diff --git a/dataworks-public/include/alibabacloud/dataworks-public/Dataworks_publicClient.h b/dataworks-public/include/alibabacloud/dataworks-public/Dataworks_publicClient.h index f9677f15c..af536f9d0 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/Dataworks_publicClient.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/Dataworks_publicClient.h @@ -50,6 +50,8 @@ #include "model/CreateFileResult.h" #include "model/CreateFolderRequest.h" #include "model/CreateFolderResult.h" +#include "model/CreateManualDagRequest.h" +#include "model/CreateManualDagResult.h" #include "model/CreateMetaCategoryRequest.h" #include "model/CreateMetaCategoryResult.h" #include "model/CreateProjectMemberRequest.h" @@ -120,6 +122,8 @@ #include "model/GetBusinessResult.h" #include "model/GetDDLJobStatusRequest.h" #include "model/GetDDLJobStatusResult.h" +#include "model/GetDagRequest.h" +#include "model/GetDagResult.h" #include "model/GetDataServiceApiRequest.h" #include "model/GetDataServiceApiResult.h" #include "model/GetDataServiceApplicationRequest.h" @@ -150,6 +154,8 @@ #include "model/GetInstanceLogResult.h" #include "model/GetInstanceStatusCountRequest.h" #include "model/GetInstanceStatusCountResult.h" +#include "model/GetManualDagInstancesRequest.h" +#include "model/GetManualDagInstancesResult.h" #include "model/GetMetaCategoryRequest.h" #include "model/GetMetaCategoryResult.h" #include "model/GetMetaColumnLineageRequest.h" @@ -272,8 +278,12 @@ #include "model/RestartInstanceResult.h" #include "model/ResumeInstanceRequest.h" #include "model/ResumeInstanceResult.h" +#include "model/RunTriggerNodeRequest.h" +#include "model/RunTriggerNodeResult.h" #include "model/SearchMetaTablesRequest.h" #include "model/SearchMetaTablesResult.h" +#include "model/SearchNodesByOutputRequest.h" +#include "model/SearchNodesByOutputResult.h" #include "model/SetSuccessInstanceRequest.h" #include "model/SetSuccessInstanceResult.h" #include "model/StopInstanceRequest.h" @@ -365,6 +375,9 @@ namespace AlibabaCloud typedef Outcome CreateFolderOutcome; typedef std::future CreateFolderOutcomeCallable; typedef std::function&)> CreateFolderAsyncHandler; + typedef Outcome CreateManualDagOutcome; + typedef std::future CreateManualDagOutcomeCallable; + typedef std::function&)> CreateManualDagAsyncHandler; typedef Outcome CreateMetaCategoryOutcome; typedef std::future CreateMetaCategoryOutcomeCallable; typedef std::function&)> CreateMetaCategoryAsyncHandler; @@ -470,6 +483,9 @@ namespace AlibabaCloud typedef Outcome GetDDLJobStatusOutcome; typedef std::future GetDDLJobStatusOutcomeCallable; typedef std::function&)> GetDDLJobStatusAsyncHandler; + typedef Outcome GetDagOutcome; + typedef std::future GetDagOutcomeCallable; + typedef std::function&)> GetDagAsyncHandler; typedef Outcome GetDataServiceApiOutcome; typedef std::future GetDataServiceApiOutcomeCallable; typedef std::function&)> GetDataServiceApiAsyncHandler; @@ -515,6 +531,9 @@ namespace AlibabaCloud typedef Outcome GetInstanceStatusCountOutcome; typedef std::future GetInstanceStatusCountOutcomeCallable; typedef std::function&)> GetInstanceStatusCountAsyncHandler; + typedef Outcome GetManualDagInstancesOutcome; + typedef std::future GetManualDagInstancesOutcomeCallable; + typedef std::function&)> GetManualDagInstancesAsyncHandler; typedef Outcome GetMetaCategoryOutcome; typedef std::future GetMetaCategoryOutcomeCallable; typedef std::function&)> GetMetaCategoryAsyncHandler; @@ -698,9 +717,15 @@ namespace AlibabaCloud typedef Outcome ResumeInstanceOutcome; typedef std::future ResumeInstanceOutcomeCallable; typedef std::function&)> ResumeInstanceAsyncHandler; + typedef Outcome RunTriggerNodeOutcome; + typedef std::future RunTriggerNodeOutcomeCallable; + typedef std::function&)> RunTriggerNodeAsyncHandler; typedef Outcome SearchMetaTablesOutcome; typedef std::future SearchMetaTablesOutcomeCallable; typedef std::function&)> SearchMetaTablesAsyncHandler; + typedef Outcome SearchNodesByOutputOutcome; + typedef std::future SearchNodesByOutputOutcomeCallable; + typedef std::function&)> SearchNodesByOutputAsyncHandler; typedef Outcome SetSuccessInstanceOutcome; typedef std::future SetSuccessInstanceOutcomeCallable; typedef std::function&)> SetSuccessInstanceAsyncHandler; @@ -808,6 +833,9 @@ namespace AlibabaCloud CreateFolderOutcome createFolder(const Model::CreateFolderRequest &request)const; void createFolderAsync(const Model::CreateFolderRequest& request, const CreateFolderAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateFolderOutcomeCallable createFolderCallable(const Model::CreateFolderRequest& request) const; + CreateManualDagOutcome createManualDag(const Model::CreateManualDagRequest &request)const; + void createManualDagAsync(const Model::CreateManualDagRequest& request, const CreateManualDagAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateManualDagOutcomeCallable createManualDagCallable(const Model::CreateManualDagRequest& request) const; CreateMetaCategoryOutcome createMetaCategory(const Model::CreateMetaCategoryRequest &request)const; void createMetaCategoryAsync(const Model::CreateMetaCategoryRequest& request, const CreateMetaCategoryAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateMetaCategoryOutcomeCallable createMetaCategoryCallable(const Model::CreateMetaCategoryRequest& request) const; @@ -913,6 +941,9 @@ namespace AlibabaCloud GetDDLJobStatusOutcome getDDLJobStatus(const Model::GetDDLJobStatusRequest &request)const; void getDDLJobStatusAsync(const Model::GetDDLJobStatusRequest& request, const GetDDLJobStatusAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetDDLJobStatusOutcomeCallable getDDLJobStatusCallable(const Model::GetDDLJobStatusRequest& request) const; + GetDagOutcome getDag(const Model::GetDagRequest &request)const; + void getDagAsync(const Model::GetDagRequest& request, const GetDagAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetDagOutcomeCallable getDagCallable(const Model::GetDagRequest& request) const; GetDataServiceApiOutcome getDataServiceApi(const Model::GetDataServiceApiRequest &request)const; void getDataServiceApiAsync(const Model::GetDataServiceApiRequest& request, const GetDataServiceApiAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetDataServiceApiOutcomeCallable getDataServiceApiCallable(const Model::GetDataServiceApiRequest& request) const; @@ -958,6 +989,9 @@ namespace AlibabaCloud GetInstanceStatusCountOutcome getInstanceStatusCount(const Model::GetInstanceStatusCountRequest &request)const; void getInstanceStatusCountAsync(const Model::GetInstanceStatusCountRequest& request, const GetInstanceStatusCountAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetInstanceStatusCountOutcomeCallable getInstanceStatusCountCallable(const Model::GetInstanceStatusCountRequest& request) const; + GetManualDagInstancesOutcome getManualDagInstances(const Model::GetManualDagInstancesRequest &request)const; + void getManualDagInstancesAsync(const Model::GetManualDagInstancesRequest& request, const GetManualDagInstancesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetManualDagInstancesOutcomeCallable getManualDagInstancesCallable(const Model::GetManualDagInstancesRequest& request) const; GetMetaCategoryOutcome getMetaCategory(const Model::GetMetaCategoryRequest &request)const; void getMetaCategoryAsync(const Model::GetMetaCategoryRequest& request, const GetMetaCategoryAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetMetaCategoryOutcomeCallable getMetaCategoryCallable(const Model::GetMetaCategoryRequest& request) const; @@ -1141,9 +1175,15 @@ namespace AlibabaCloud ResumeInstanceOutcome resumeInstance(const Model::ResumeInstanceRequest &request)const; void resumeInstanceAsync(const Model::ResumeInstanceRequest& request, const ResumeInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ResumeInstanceOutcomeCallable resumeInstanceCallable(const Model::ResumeInstanceRequest& request) const; + RunTriggerNodeOutcome runTriggerNode(const Model::RunTriggerNodeRequest &request)const; + void runTriggerNodeAsync(const Model::RunTriggerNodeRequest& request, const RunTriggerNodeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + RunTriggerNodeOutcomeCallable runTriggerNodeCallable(const Model::RunTriggerNodeRequest& request) const; SearchMetaTablesOutcome searchMetaTables(const Model::SearchMetaTablesRequest &request)const; void searchMetaTablesAsync(const Model::SearchMetaTablesRequest& request, const SearchMetaTablesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; SearchMetaTablesOutcomeCallable searchMetaTablesCallable(const Model::SearchMetaTablesRequest& request) const; + SearchNodesByOutputOutcome searchNodesByOutput(const Model::SearchNodesByOutputRequest &request)const; + void searchNodesByOutputAsync(const Model::SearchNodesByOutputRequest& request, const SearchNodesByOutputAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + SearchNodesByOutputOutcomeCallable searchNodesByOutputCallable(const Model::SearchNodesByOutputRequest& request) const; SetSuccessInstanceOutcome setSuccessInstance(const Model::SetSuccessInstanceRequest &request)const; void setSuccessInstanceAsync(const Model::SetSuccessInstanceRequest& request, const SetSuccessInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; SetSuccessInstanceOutcomeCallable setSuccessInstanceCallable(const Model::SetSuccessInstanceRequest& request) const; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/CreateManualDagRequest.h b/dataworks-public/include/alibabacloud/dataworks-public/model/CreateManualDagRequest.h new file mode 100644 index 000000000..840bc7d3a --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/CreateManualDagRequest.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_CREATEMANUALDAGREQUEST_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEMANUALDAGREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateManualDagRequest : public RpcServiceRequest + { + + public: + CreateManualDagRequest(); + ~CreateManualDagRequest(); + + std::string getProjectEnv()const; + void setProjectEnv(const std::string& projectEnv); + std::string getProjectName()const; + void setProjectName(const std::string& projectName); + std::string getBizDate()const; + void setBizDate(const std::string& bizDate); + std::string getFlowName()const; + void setFlowName(const std::string& flowName); + std::string getDagParameters()const; + void setDagParameters(const std::string& dagParameters); + std::string getNodeParameters()const; + void setNodeParameters(const std::string& nodeParameters); + + private: + std::string projectEnv_; + std::string projectName_; + std::string bizDate_; + std::string flowName_; + std::string dagParameters_; + std::string nodeParameters_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEMANUALDAGREQUEST_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/CreateManualDagResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/CreateManualDagResult.h new file mode 100644 index 000000000..54983cd12 --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/CreateManualDagResult.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_CREATEMANUALDAGRESULT_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEMANUALDAGRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT CreateManualDagResult : public ServiceResult + { + public: + + + CreateManualDagResult(); + explicit CreateManualDagResult(const std::string &payload); + ~CreateManualDagResult(); + long getDagId()const; + + protected: + void parse(const std::string &payload); + private: + long dagId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEMANUALDAGRESULT_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/CreateTableRequest.h b/dataworks-public/include/alibabacloud/dataworks-public/model/CreateTableRequest.h index 693cd7974..a473925f6 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/CreateTableRequest.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/CreateTableRequest.h @@ -79,6 +79,8 @@ namespace AlibabaCloud void setHasPart(int hasPart); std::string getLocation()const; void setLocation(const std::string& location); + std::string getComment()const; + void setComment(const std::string& comment); std::string getTableName()const; void setTableName(const std::string& tableName); std::string getAppGuid()const; @@ -102,6 +104,7 @@ namespace AlibabaCloud int envType_; int hasPart_; std::string location_; + std::string comment_; std::string tableName_; std::string appGuid_; long projectId_; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetDagRequest.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetDagRequest.h new file mode 100644 index 000000000..3d4a9cabd --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetDagRequest.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_GETDAGREQUEST_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETDAGREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT GetDagRequest : public RpcServiceRequest + { + + public: + GetDagRequest(); + ~GetDagRequest(); + + std::string getProjectEnv()const; + void setProjectEnv(const std::string& projectEnv); + long getDagId()const; + void setDagId(long dagId); + + private: + std::string projectEnv_; + long dagId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETDAGREQUEST_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 new file mode 100644 index 000000000..10cbabf61 --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetDagResult.h @@ -0,0 +1,74 @@ +/* + * 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_GETDAGRESULT_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETDAGRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT GetDagResult : public ServiceResult + { + public: + 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; + }; + + + GetDagResult(); + explicit GetDagResult(const std::string &payload); + ~GetDagResult(); + 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_GETDAGRESULT_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 7a557a31d..22156f35c 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceResult.h @@ -35,20 +35,29 @@ namespace AlibabaCloud struct Data { std::string status; + long baselineId; long modifyTime; long instanceId; std::string dagType; std::string nodeName; + int priority; + int dqcType; std::string paramValues; long createTime; + std::string connection; + long relatedFlowId; long cycTime; long beginWaitTimeTime; long dagId; long bizdate; long beginRunningTime; + bool repeatability; long finishTime; + std::string dqcDescription; long nodeId; long beginWaitResTime; + std::string errorMessage; + long repeatInterval; }; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesRequest.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesRequest.h new file mode 100644 index 000000000..f44bafcec --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesRequest.h @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMANUALDAGINSTANCESREQUEST_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMANUALDAGINSTANCESREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT GetManualDagInstancesRequest : public RpcServiceRequest + { + + public: + GetManualDagInstancesRequest(); + ~GetManualDagInstancesRequest(); + + std::string getProjectEnv()const; + void setProjectEnv(const std::string& projectEnv); + std::string getProjectName()const; + void setProjectName(const std::string& projectName); + std::string getDagId()const; + void setDagId(const std::string& dagId); + + private: + std::string projectEnv_; + std::string projectName_; + std::string dagId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMANUALDAGINSTANCESREQUEST_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesResult.h new file mode 100644 index 000000000..b59428062 --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesResult.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_GETMANUALDAGINSTANCESRESULT_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMANUALDAGINSTANCESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT GetManualDagInstancesResult : public ServiceResult + { + public: + struct InstancesItem + { + std::string status; + long modifyTime; + long instanceId; + std::string dagType; + std::string nodeName; + long createTime; + std::string paramValues; + long cycTime; + long beginWaitTimeTime; + long dagId; + long beginRunningTime; + long finishTime; + long nodeId; + long beginWaitResTime; + long bizDate; + }; + + + GetManualDagInstancesResult(); + explicit GetManualDagInstancesResult(const std::string &payload); + ~GetManualDagInstancesResult(); + std::vector getInstances()const; + + protected: + void parse(const std::string &payload); + private: + std::vector instances_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMANUALDAGINSTANCESRESULT_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/GetNodeResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/GetNodeResult.h index 9c64d7c4d..8108cd524 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/GetNodeResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/GetNodeResult.h @@ -34,17 +34,24 @@ namespace AlibabaCloud public: struct Data { - std::string repeatability; + long baselineId; std::string description; std::string resGroupName; - std::string ownerId; std::string nodeName; + int priority; + int dqcType; std::string paramValues; - long nodeId; long projectId; - std::string programType; + std::string connection; std::string schedulerType; + long relatedFlowId; std::string cronExpress; + std::string repeatability; + std::string ownerId; + std::string dqcDescription; + long nodeId; + std::string programType; + long repeatInterval; }; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/ListInstancesRequest.h b/dataworks-public/include/alibabacloud/dataworks-public/model/ListInstancesRequest.h index 7bac01f76..bbab57366 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/ListInstancesRequest.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/ListInstancesRequest.h @@ -41,6 +41,8 @@ namespace AlibabaCloud void setOwner(const std::string& owner); std::string getBizName()const; void setBizName(const std::string& bizName); + long getDagId()const; + void setDagId(long dagId); int getPageNumber()const; void setPageNumber(int pageNumber); std::string getNodeName()const; @@ -58,6 +60,7 @@ namespace AlibabaCloud std::string projectEnv_; std::string owner_; std::string bizName_; + long dagId_; int pageNumber_; std::string nodeName_; std::string programType_; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/ListInstancesResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/ListInstancesResult.h index befa85c84..efa566a00 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/ListInstancesResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/ListInstancesResult.h @@ -37,20 +37,29 @@ namespace AlibabaCloud struct Instance { std::string status; + long baselineId; long modifyTime; long instanceId; std::string dagType; std::string nodeName; + int priority; + int dqcType; long createTime; std::string paramValues; + std::string connection; + long relatedFlowId; long cycTime; long beginWaitTimeTime; int dagId; long bizdate; long beginRunningTime; + bool repeatability; long finishTime; + std::string dqcDescription; int nodeId; long beginWaitResTime; + std::string errorMessage; + long repeatInterval; }; std::vector instances; int totalCount; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/ListNodeIOResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/ListNodeIOResult.h index d612e3397..60463dda2 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/ListNodeIOResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/ListNodeIOResult.h @@ -35,6 +35,7 @@ namespace AlibabaCloud struct DataItem { std::string tableName; + long nodeId; std::string data; }; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/ListNodesResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/ListNodesResult.h index a963eef38..d676effd8 100644 --- a/dataworks-public/include/alibabacloud/dataworks-public/model/ListNodesResult.h +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/ListNodesResult.h @@ -36,17 +36,24 @@ namespace AlibabaCloud { struct NodesItem { - bool repeatability; + long baselineId; std::string description; std::string resGroupName; - std::string ownerId; std::string nodeName; + int priority; + int dqcType; std::string paramValues; - long nodeId; long projectId; + std::string connection; std::string schedulerType; - std::string programType; + long relatedFlowId; std::string cronExpress; + bool repeatability; + std::string ownerId; + std::string dqcDescription; + long nodeId; + std::string programType; + long repeatInterval; }; int totalCount; int pageSize; diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/RunTriggerNodeRequest.h b/dataworks-public/include/alibabacloud/dataworks-public/model/RunTriggerNodeRequest.h new file mode 100644 index 000000000..64a229591 --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/RunTriggerNodeRequest.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_RUNTRIGGERNODEREQUEST_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_RUNTRIGGERNODEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT RunTriggerNodeRequest : public RpcServiceRequest + { + + public: + RunTriggerNodeRequest(); + ~RunTriggerNodeRequest(); + + long getBizDate()const; + void setBizDate(long bizDate); + long getAppId()const; + void setAppId(long appId); + long getCycleTime()const; + void setCycleTime(long cycleTime); + long getNodeId()const; + void setNodeId(long nodeId); + + private: + long bizDate_; + long appId_; + long cycleTime_; + long nodeId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_RUNTRIGGERNODEREQUEST_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/RunTriggerNodeResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/RunTriggerNodeResult.h new file mode 100644 index 000000000..1581bb20b --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/RunTriggerNodeResult.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_RUNTRIGGERNODERESULT_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_RUNTRIGGERNODERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT RunTriggerNodeResult : public ServiceResult + { + public: + + + RunTriggerNodeResult(); + explicit RunTriggerNodeResult(const std::string &payload); + ~RunTriggerNodeResult(); + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_RUNTRIGGERNODERESULT_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/SearchNodesByOutputRequest.h b/dataworks-public/include/alibabacloud/dataworks-public/model/SearchNodesByOutputRequest.h new file mode 100644 index 000000000..dcd036bf8 --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/SearchNodesByOutputRequest.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_SEARCHNODESBYOUTPUTREQUEST_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_SEARCHNODESBYOUTPUTREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT SearchNodesByOutputRequest : public RpcServiceRequest + { + + public: + SearchNodesByOutputRequest(); + ~SearchNodesByOutputRequest(); + + std::string getProjectEnv()const; + void setProjectEnv(const std::string& projectEnv); + std::string getOutputs()const; + void setOutputs(const std::string& outputs); + + private: + std::string projectEnv_; + std::string outputs_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_SEARCHNODESBYOUTPUTREQUEST_H_ \ No newline at end of file diff --git a/dataworks-public/include/alibabacloud/dataworks-public/model/SearchNodesByOutputResult.h b/dataworks-public/include/alibabacloud/dataworks-public/model/SearchNodesByOutputResult.h new file mode 100644 index 000000000..5421a1143 --- /dev/null +++ b/dataworks-public/include/alibabacloud/dataworks-public/model/SearchNodesByOutputResult.h @@ -0,0 +1,59 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_SEARCHNODESBYOUTPUTRESULT_H_ +#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_SEARCHNODESBYOUTPUTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dataworks_public + { + namespace Model + { + class ALIBABACLOUD_DATAWORKS_PUBLIC_EXPORT SearchNodesByOutputResult : public ServiceResult + { + public: + + + SearchNodesByOutputResult(); + explicit SearchNodesByOutputResult(const std::string &payload); + ~SearchNodesByOutputResult(); + int getHttpStatusCode()const; + std::string getData()const; + std::string getErrorCode()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + int httpStatusCode_; + std::string data_; + std::string errorCode_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_SEARCHNODESBYOUTPUTRESULT_H_ \ No newline at end of file diff --git a/dataworks-public/src/Dataworks-publicClient.cc b/dataworks-public/src/Dataworks-publicClient.cc index 5fa4f213f..db72d3178 100644 --- a/dataworks-public/src/Dataworks-publicClient.cc +++ b/dataworks-public/src/Dataworks-publicClient.cc @@ -555,6 +555,42 @@ Dataworks_publicClient::CreateFolderOutcomeCallable Dataworks_publicClient::crea return task->get_future(); } +Dataworks_publicClient::CreateManualDagOutcome Dataworks_publicClient::createManualDag(const CreateManualDagRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateManualDagOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateManualDagOutcome(CreateManualDagResult(outcome.result())); + else + return CreateManualDagOutcome(outcome.error()); +} + +void Dataworks_publicClient::createManualDagAsync(const CreateManualDagRequest& request, const CreateManualDagAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createManualDag(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Dataworks_publicClient::CreateManualDagOutcomeCallable Dataworks_publicClient::createManualDagCallable(const CreateManualDagRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createManualDag(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Dataworks_publicClient::CreateMetaCategoryOutcome Dataworks_publicClient::createMetaCategory(const CreateMetaCategoryRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1815,6 +1851,42 @@ Dataworks_publicClient::GetDDLJobStatusOutcomeCallable Dataworks_publicClient::g return task->get_future(); } +Dataworks_publicClient::GetDagOutcome Dataworks_publicClient::getDag(const GetDagRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetDagOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetDagOutcome(GetDagResult(outcome.result())); + else + return GetDagOutcome(outcome.error()); +} + +void Dataworks_publicClient::getDagAsync(const GetDagRequest& request, const GetDagAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getDag(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Dataworks_publicClient::GetDagOutcomeCallable Dataworks_publicClient::getDagCallable(const GetDagRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getDag(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Dataworks_publicClient::GetDataServiceApiOutcome Dataworks_publicClient::getDataServiceApi(const GetDataServiceApiRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -2355,6 +2427,42 @@ Dataworks_publicClient::GetInstanceStatusCountOutcomeCallable Dataworks_publicCl return task->get_future(); } +Dataworks_publicClient::GetManualDagInstancesOutcome Dataworks_publicClient::getManualDagInstances(const GetManualDagInstancesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetManualDagInstancesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetManualDagInstancesOutcome(GetManualDagInstancesResult(outcome.result())); + else + return GetManualDagInstancesOutcome(outcome.error()); +} + +void Dataworks_publicClient::getManualDagInstancesAsync(const GetManualDagInstancesRequest& request, const GetManualDagInstancesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getManualDagInstances(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Dataworks_publicClient::GetManualDagInstancesOutcomeCallable Dataworks_publicClient::getManualDagInstancesCallable(const GetManualDagInstancesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getManualDagInstances(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Dataworks_publicClient::GetMetaCategoryOutcome Dataworks_publicClient::getMetaCategory(const GetMetaCategoryRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -4551,6 +4659,42 @@ Dataworks_publicClient::ResumeInstanceOutcomeCallable Dataworks_publicClient::re return task->get_future(); } +Dataworks_publicClient::RunTriggerNodeOutcome Dataworks_publicClient::runTriggerNode(const RunTriggerNodeRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return RunTriggerNodeOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RunTriggerNodeOutcome(RunTriggerNodeResult(outcome.result())); + else + return RunTriggerNodeOutcome(outcome.error()); +} + +void Dataworks_publicClient::runTriggerNodeAsync(const RunTriggerNodeRequest& request, const RunTriggerNodeAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, runTriggerNode(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Dataworks_publicClient::RunTriggerNodeOutcomeCallable Dataworks_publicClient::runTriggerNodeCallable(const RunTriggerNodeRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->runTriggerNode(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Dataworks_publicClient::SearchMetaTablesOutcome Dataworks_publicClient::searchMetaTables(const SearchMetaTablesRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -4587,6 +4731,42 @@ Dataworks_publicClient::SearchMetaTablesOutcomeCallable Dataworks_publicClient:: return task->get_future(); } +Dataworks_publicClient::SearchNodesByOutputOutcome Dataworks_publicClient::searchNodesByOutput(const SearchNodesByOutputRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return SearchNodesByOutputOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return SearchNodesByOutputOutcome(SearchNodesByOutputResult(outcome.result())); + else + return SearchNodesByOutputOutcome(outcome.error()); +} + +void Dataworks_publicClient::searchNodesByOutputAsync(const SearchNodesByOutputRequest& request, const SearchNodesByOutputAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, searchNodesByOutput(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Dataworks_publicClient::SearchNodesByOutputOutcomeCallable Dataworks_publicClient::searchNodesByOutputCallable(const SearchNodesByOutputRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->searchNodesByOutput(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Dataworks_publicClient::SetSuccessInstanceOutcome Dataworks_publicClient::setSuccessInstance(const SetSuccessInstanceRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/dataworks-public/src/model/CreateManualDagRequest.cc b/dataworks-public/src/model/CreateManualDagRequest.cc new file mode 100644 index 000000000..ae421aea4 --- /dev/null +++ b/dataworks-public/src/model/CreateManualDagRequest.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::CreateManualDagRequest; + +CreateManualDagRequest::CreateManualDagRequest() : + RpcServiceRequest("dataworks-public", "2020-05-18", "CreateManualDag") +{ + setMethod(HttpRequest::Method::Post); +} + +CreateManualDagRequest::~CreateManualDagRequest() +{} + +std::string CreateManualDagRequest::getProjectEnv()const +{ + return projectEnv_; +} + +void CreateManualDagRequest::setProjectEnv(const std::string& projectEnv) +{ + projectEnv_ = projectEnv; + setBodyParameter("ProjectEnv", projectEnv); +} + +std::string CreateManualDagRequest::getProjectName()const +{ + return projectName_; +} + +void CreateManualDagRequest::setProjectName(const std::string& projectName) +{ + projectName_ = projectName; + setBodyParameter("ProjectName", projectName); +} + +std::string CreateManualDagRequest::getBizDate()const +{ + return bizDate_; +} + +void CreateManualDagRequest::setBizDate(const std::string& bizDate) +{ + bizDate_ = bizDate; + setBodyParameter("BizDate", bizDate); +} + +std::string CreateManualDagRequest::getFlowName()const +{ + return flowName_; +} + +void CreateManualDagRequest::setFlowName(const std::string& flowName) +{ + flowName_ = flowName; + setBodyParameter("FlowName", flowName); +} + +std::string CreateManualDagRequest::getDagParameters()const +{ + return dagParameters_; +} + +void CreateManualDagRequest::setDagParameters(const std::string& dagParameters) +{ + dagParameters_ = dagParameters; + setBodyParameter("DagParameters", dagParameters); +} + +std::string CreateManualDagRequest::getNodeParameters()const +{ + return nodeParameters_; +} + +void CreateManualDagRequest::setNodeParameters(const std::string& nodeParameters) +{ + nodeParameters_ = nodeParameters; + setBodyParameter("NodeParameters", nodeParameters); +} + diff --git a/dataworks-public/src/model/CreateManualDagResult.cc b/dataworks-public/src/model/CreateManualDagResult.cc new file mode 100644 index 000000000..7fc36b699 --- /dev/null +++ b/dataworks-public/src/model/CreateManualDagResult.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 +#include + +using namespace AlibabaCloud::Dataworks_public; +using namespace AlibabaCloud::Dataworks_public::Model; + +CreateManualDagResult::CreateManualDagResult() : + ServiceResult() +{} + +CreateManualDagResult::CreateManualDagResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateManualDagResult::~CreateManualDagResult() +{} + +void CreateManualDagResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["DagId"].isNull()) + dagId_ = std::stol(value["DagId"].asString()); + +} + +long CreateManualDagResult::getDagId()const +{ + return dagId_; +} + diff --git a/dataworks-public/src/model/CreateTableRequest.cc b/dataworks-public/src/model/CreateTableRequest.cc index bcd0a830b..aa0402c2a 100644 --- a/dataworks-public/src/model/CreateTableRequest.cc +++ b/dataworks-public/src/model/CreateTableRequest.cc @@ -187,6 +187,17 @@ void CreateTableRequest::setLocation(const std::string& location) setParameter("Location", location); } +std::string CreateTableRequest::getComment()const +{ + return comment_; +} + +void CreateTableRequest::setComment(const std::string& comment) +{ + comment_ = comment; + setParameter("Comment", comment); +} + std::string CreateTableRequest::getTableName()const { return tableName_; diff --git a/dataworks-public/src/model/GetBaselineKeyPathResult.cc b/dataworks-public/src/model/GetBaselineKeyPathResult.cc index db3d833ec..27113b2cf 100644 --- a/dataworks-public/src/model/GetBaselineKeyPathResult.cc +++ b/dataworks-public/src/model/GetBaselineKeyPathResult.cc @@ -59,56 +59,56 @@ void GetBaselineKeyPathResult::parse(const std::string &payload) dataObject.owner = valueDataDataItem["Owner"].asString(); if(!valueDataDataItem["PrgType"].isNull()) dataObject.prgType = std::stoi(valueDataDataItem["PrgType"].asString()); - auto allRunsNode = allDataNode["Runs"]["RunsItem"]; - for (auto allDataNodeRunsRunsItem : allRunsNode) + auto allRunsNode = valueDataDataItem["Runs"]["RunsItem"]; + for (auto valueDataDataItemRunsRunsItem : allRunsNode) { DataItem::RunsItem runsObject; - if(!allDataNodeRunsRunsItem["AbsTime"].isNull()) - runsObject.absTime = std::stol(allDataNodeRunsRunsItem["AbsTime"].asString()); - if(!allDataNodeRunsRunsItem["BeginCast"].isNull()) - runsObject.beginCast = std::stol(allDataNodeRunsRunsItem["BeginCast"].asString()); - if(!allDataNodeRunsRunsItem["BeginRunningTime"].isNull()) - runsObject.beginRunningTime = std::stol(allDataNodeRunsRunsItem["BeginRunningTime"].asString()); - if(!allDataNodeRunsRunsItem["BeginWaitResTime"].isNull()) - runsObject.beginWaitResTime = std::stol(allDataNodeRunsRunsItem["BeginWaitResTime"].asString()); - if(!allDataNodeRunsRunsItem["BeginWaitTimeTime"].isNull()) - runsObject.beginWaitTimeTime = std::stol(allDataNodeRunsRunsItem["BeginWaitTimeTime"].asString()); - if(!allDataNodeRunsRunsItem["Bizdate"].isNull()) - runsObject.bizdate = std::stol(allDataNodeRunsRunsItem["Bizdate"].asString()); - if(!allDataNodeRunsRunsItem["CycTime"].isNull()) - runsObject.cycTime = std::stol(allDataNodeRunsRunsItem["CycTime"].asString()); - if(!allDataNodeRunsRunsItem["EndCast"].isNull()) - runsObject.endCast = std::stol(allDataNodeRunsRunsItem["EndCast"].asString()); - if(!allDataNodeRunsRunsItem["FinishTime"].isNull()) - runsObject.finishTime = std::stol(allDataNodeRunsRunsItem["FinishTime"].asString()); - if(!allDataNodeRunsRunsItem["InGroupId"].isNull()) - runsObject.inGroupId = std::stoi(allDataNodeRunsRunsItem["InGroupId"].asString()); - if(!allDataNodeRunsRunsItem["InstanceId"].isNull()) - runsObject.instanceId = std::stol(allDataNodeRunsRunsItem["InstanceId"].asString()); - if(!allDataNodeRunsRunsItem["NodeId"].isNull()) - runsObject.nodeId = std::stol(allDataNodeRunsRunsItem["NodeId"].asString()); - if(!allDataNodeRunsRunsItem["NodeName"].isNull()) - runsObject.nodeName = allDataNodeRunsRunsItem["NodeName"].asString(); - if(!allDataNodeRunsRunsItem["Owner"].isNull()) - runsObject.owner = allDataNodeRunsRunsItem["Owner"].asString(); - if(!allDataNodeRunsRunsItem["ProjectId"].isNull()) - runsObject.projectId = std::stol(allDataNodeRunsRunsItem["ProjectId"].asString()); - if(!allDataNodeRunsRunsItem["Status"].isNull()) - runsObject.status = allDataNodeRunsRunsItem["Status"].asString(); + if(!valueDataDataItemRunsRunsItem["AbsTime"].isNull()) + runsObject.absTime = std::stol(valueDataDataItemRunsRunsItem["AbsTime"].asString()); + if(!valueDataDataItemRunsRunsItem["BeginCast"].isNull()) + runsObject.beginCast = std::stol(valueDataDataItemRunsRunsItem["BeginCast"].asString()); + if(!valueDataDataItemRunsRunsItem["BeginRunningTime"].isNull()) + runsObject.beginRunningTime = std::stol(valueDataDataItemRunsRunsItem["BeginRunningTime"].asString()); + if(!valueDataDataItemRunsRunsItem["BeginWaitResTime"].isNull()) + runsObject.beginWaitResTime = std::stol(valueDataDataItemRunsRunsItem["BeginWaitResTime"].asString()); + if(!valueDataDataItemRunsRunsItem["BeginWaitTimeTime"].isNull()) + runsObject.beginWaitTimeTime = std::stol(valueDataDataItemRunsRunsItem["BeginWaitTimeTime"].asString()); + if(!valueDataDataItemRunsRunsItem["Bizdate"].isNull()) + runsObject.bizdate = std::stol(valueDataDataItemRunsRunsItem["Bizdate"].asString()); + if(!valueDataDataItemRunsRunsItem["CycTime"].isNull()) + runsObject.cycTime = std::stol(valueDataDataItemRunsRunsItem["CycTime"].asString()); + if(!valueDataDataItemRunsRunsItem["EndCast"].isNull()) + runsObject.endCast = std::stol(valueDataDataItemRunsRunsItem["EndCast"].asString()); + if(!valueDataDataItemRunsRunsItem["FinishTime"].isNull()) + runsObject.finishTime = std::stol(valueDataDataItemRunsRunsItem["FinishTime"].asString()); + if(!valueDataDataItemRunsRunsItem["InGroupId"].isNull()) + runsObject.inGroupId = std::stoi(valueDataDataItemRunsRunsItem["InGroupId"].asString()); + if(!valueDataDataItemRunsRunsItem["InstanceId"].isNull()) + runsObject.instanceId = std::stol(valueDataDataItemRunsRunsItem["InstanceId"].asString()); + if(!valueDataDataItemRunsRunsItem["NodeId"].isNull()) + runsObject.nodeId = std::stol(valueDataDataItemRunsRunsItem["NodeId"].asString()); + if(!valueDataDataItemRunsRunsItem["NodeName"].isNull()) + runsObject.nodeName = valueDataDataItemRunsRunsItem["NodeName"].asString(); + if(!valueDataDataItemRunsRunsItem["Owner"].isNull()) + runsObject.owner = valueDataDataItemRunsRunsItem["Owner"].asString(); + if(!valueDataDataItemRunsRunsItem["ProjectId"].isNull()) + runsObject.projectId = std::stol(valueDataDataItemRunsRunsItem["ProjectId"].asString()); + if(!valueDataDataItemRunsRunsItem["Status"].isNull()) + runsObject.status = valueDataDataItemRunsRunsItem["Status"].asString(); dataObject.runs.push_back(runsObject); } - auto allTopicsNode = allDataNode["Topics"]["TopicsItem"]; - for (auto allDataNodeTopicsTopicsItem : allTopicsNode) + auto allTopicsNode = valueDataDataItem["Topics"]["TopicsItem"]; + for (auto valueDataDataItemTopicsTopicsItem : allTopicsNode) { DataItem::TopicsItem topicsObject; - if(!allDataNodeTopicsTopicsItem["InstanceId"].isNull()) - topicsObject.instanceId = std::stol(allDataNodeTopicsTopicsItem["InstanceId"].asString()); - if(!allDataNodeTopicsTopicsItem["TopicId"].isNull()) - topicsObject.topicId = std::stol(allDataNodeTopicsTopicsItem["TopicId"].asString()); - if(!allDataNodeTopicsTopicsItem["TopicName"].isNull()) - topicsObject.topicName = std::stol(allDataNodeTopicsTopicsItem["TopicName"].asString()); - if(!allDataNodeTopicsTopicsItem["AddTime"].isNull()) - topicsObject.addTime = std::stol(allDataNodeTopicsTopicsItem["AddTime"].asString()); + if(!valueDataDataItemTopicsTopicsItem["InstanceId"].isNull()) + topicsObject.instanceId = std::stol(valueDataDataItemTopicsTopicsItem["InstanceId"].asString()); + if(!valueDataDataItemTopicsTopicsItem["TopicId"].isNull()) + topicsObject.topicId = std::stol(valueDataDataItemTopicsTopicsItem["TopicId"].asString()); + if(!valueDataDataItemTopicsTopicsItem["TopicName"].isNull()) + topicsObject.topicName = std::stol(valueDataDataItemTopicsTopicsItem["TopicName"].asString()); + if(!valueDataDataItemTopicsTopicsItem["AddTime"].isNull()) + topicsObject.addTime = std::stol(valueDataDataItemTopicsTopicsItem["AddTime"].asString()); dataObject.topics.push_back(topicsObject); } data_.push_back(dataObject); diff --git a/dataworks-public/src/model/GetDagRequest.cc b/dataworks-public/src/model/GetDagRequest.cc new file mode 100644 index 000000000..fd01c1bd1 --- /dev/null +++ b/dataworks-public/src/model/GetDagRequest.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::GetDagRequest; + +GetDagRequest::GetDagRequest() : + RpcServiceRequest("dataworks-public", "2020-05-18", "GetDag") +{ + setMethod(HttpRequest::Method::Post); +} + +GetDagRequest::~GetDagRequest() +{} + +std::string GetDagRequest::getProjectEnv()const +{ + return projectEnv_; +} + +void GetDagRequest::setProjectEnv(const std::string& projectEnv) +{ + projectEnv_ = projectEnv; + setBodyParameter("ProjectEnv", projectEnv); +} + +long GetDagRequest::getDagId()const +{ + return dagId_; +} + +void GetDagRequest::setDagId(long dagId) +{ + dagId_ = dagId; + setBodyParameter("DagId", std::to_string(dagId)); +} + diff --git a/dataworks-public/src/model/GetDagResult.cc b/dataworks-public/src/model/GetDagResult.cc new file mode 100644 index 000000000..3600a214f --- /dev/null +++ b/dataworks-public/src/model/GetDagResult.cc @@ -0,0 +1,102 @@ +/* + * 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; + +GetDagResult::GetDagResult() : + ServiceResult() +{} + +GetDagResult::GetDagResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetDagResult::~GetDagResult() +{} + +void GetDagResult::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["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["CreateUser"].isNull()) + data_.createUser = dataNode["CreateUser"].asString(); + if(!dataNode["ModifyTime"].isNull()) + data_.modifyTime = std::stol(dataNode["ModifyTime"].asString()); + 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(); + +} + +int GetDagResult::getHttpStatusCode()const +{ + return httpStatusCode_; +} + +GetDagResult::Data GetDagResult::getData()const +{ + return data_; +} + +std::string GetDagResult::getErrorCode()const +{ + return errorCode_; +} + +std::string GetDagResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool GetDagResult::getSuccess()const +{ + return success_; +} + diff --git a/dataworks-public/src/model/GetInstanceResult.cc b/dataworks-public/src/model/GetInstanceResult.cc index 8eeb2e9c8..6e17a04bf 100644 --- a/dataworks-public/src/model/GetInstanceResult.cc +++ b/dataworks-public/src/model/GetInstanceResult.cc @@ -70,6 +70,24 @@ void GetInstanceResult::parse(const std::string &payload) data_.modifyTime = std::stol(dataNode["ModifyTime"].asString()); if(!dataNode["NodeName"].isNull()) data_.nodeName = dataNode["NodeName"].asString(); + if(!dataNode["Priority"].isNull()) + data_.priority = std::stoi(dataNode["Priority"].asString()); + if(!dataNode["BaselineId"].isNull()) + data_.baselineId = std::stol(dataNode["BaselineId"].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["RelatedFlowId"].isNull()) + data_.relatedFlowId = std::stol(dataNode["RelatedFlowId"].asString()); if(!value["ErrorCode"].isNull()) errorCode_ = value["ErrorCode"].asString(); if(!value["ErrorMessage"].isNull()) diff --git a/dataworks-public/src/model/GetManualDagInstancesRequest.cc b/dataworks-public/src/model/GetManualDagInstancesRequest.cc new file mode 100644 index 000000000..6864a457b --- /dev/null +++ b/dataworks-public/src/model/GetManualDagInstancesRequest.cc @@ -0,0 +1,62 @@ +/* + * 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::GetManualDagInstancesRequest; + +GetManualDagInstancesRequest::GetManualDagInstancesRequest() : + RpcServiceRequest("dataworks-public", "2020-05-18", "GetManualDagInstances") +{ + setMethod(HttpRequest::Method::Post); +} + +GetManualDagInstancesRequest::~GetManualDagInstancesRequest() +{} + +std::string GetManualDagInstancesRequest::getProjectEnv()const +{ + return projectEnv_; +} + +void GetManualDagInstancesRequest::setProjectEnv(const std::string& projectEnv) +{ + projectEnv_ = projectEnv; + setBodyParameter("ProjectEnv", projectEnv); +} + +std::string GetManualDagInstancesRequest::getProjectName()const +{ + return projectName_; +} + +void GetManualDagInstancesRequest::setProjectName(const std::string& projectName) +{ + projectName_ = projectName; + setBodyParameter("ProjectName", projectName); +} + +std::string GetManualDagInstancesRequest::getDagId()const +{ + return dagId_; +} + +void GetManualDagInstancesRequest::setDagId(const std::string& dagId) +{ + dagId_ = dagId; + setBodyParameter("DagId", dagId); +} + diff --git a/dataworks-public/src/model/GetManualDagInstancesResult.cc b/dataworks-public/src/model/GetManualDagInstancesResult.cc new file mode 100644 index 000000000..2c20b646a --- /dev/null +++ b/dataworks-public/src/model/GetManualDagInstancesResult.cc @@ -0,0 +1,85 @@ +/* + * 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; + +GetManualDagInstancesResult::GetManualDagInstancesResult() : + ServiceResult() +{} + +GetManualDagInstancesResult::GetManualDagInstancesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetManualDagInstancesResult::~GetManualDagInstancesResult() +{} + +void GetManualDagInstancesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allInstancesNode = value["Instances"]["InstancesItem"]; + 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["BizDate"].isNull()) + instancesObject.bizDate = std::stol(valueInstancesInstancesItem["BizDate"].asString()); + if(!valueInstancesInstancesItem["CycTime"].isNull()) + instancesObject.cycTime = std::stol(valueInstancesInstancesItem["CycTime"].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["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()); + instances_.push_back(instancesObject); + } + +} + +std::vector GetManualDagInstancesResult::getInstances()const +{ + return instances_; +} + diff --git a/dataworks-public/src/model/GetNodeResult.cc b/dataworks-public/src/model/GetNodeResult.cc index 15d6d810e..41a4ec0c4 100644 --- a/dataworks-public/src/model/GetNodeResult.cc +++ b/dataworks-public/src/model/GetNodeResult.cc @@ -62,6 +62,20 @@ void GetNodeResult::parse(const std::string &payload) data_.schedulerType = dataNode["SchedulerType"].asString(); if(!dataNode["ParamValues"].isNull()) data_.paramValues = dataNode["ParamValues"].asString(); + if(!dataNode["Priority"].isNull()) + data_.priority = std::stoi(dataNode["Priority"].asString()); + if(!dataNode["BaselineId"].isNull()) + data_.baselineId = std::stol(dataNode["BaselineId"].asString()); + 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["RelatedFlowId"].isNull()) + data_.relatedFlowId = std::stol(dataNode["RelatedFlowId"].asString()); if(!value["Success"].isNull()) success_ = value["Success"].asString() == "true"; if(!value["ErrorCode"].isNull()) diff --git a/dataworks-public/src/model/ListAlertMessagesResult.cc b/dataworks-public/src/model/ListAlertMessagesResult.cc index 9ee173917..40218b396 100644 --- a/dataworks-public/src/model/ListAlertMessagesResult.cc +++ b/dataworks-public/src/model/ListAlertMessagesResult.cc @@ -68,52 +68,52 @@ void ListAlertMessagesResult::parse(const std::string &payload) alertMessagesItemObject.alertMessageStatus = dataNodeAlertMessagesAlertMessagesItem["AlertMessageStatus"].asString(); if(!dataNodeAlertMessagesAlertMessagesItem["Content"].isNull()) alertMessagesItemObject.content = dataNodeAlertMessagesAlertMessagesItem["Content"].asString(); - auto allInstancesNode = allAlertMessagesNode["Instances"]["InstancesItem"]; - for (auto allAlertMessagesNodeInstancesInstancesItem : allInstancesNode) + auto allInstancesNode = dataNodeAlertMessagesAlertMessagesItem["Instances"]["InstancesItem"]; + for (auto dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem : allInstancesNode) { Data::AlertMessagesItem::InstancesItem instancesObject; - if(!allAlertMessagesNodeInstancesInstancesItem["NodeId"].isNull()) - instancesObject.nodeId = std::stol(allAlertMessagesNodeInstancesInstancesItem["NodeId"].asString()); - if(!allAlertMessagesNodeInstancesInstancesItem["NodeName"].isNull()) - instancesObject.nodeName = allAlertMessagesNodeInstancesInstancesItem["NodeName"].asString(); - if(!allAlertMessagesNodeInstancesInstancesItem["ProjectId"].isNull()) - instancesObject.projectId = std::stol(allAlertMessagesNodeInstancesInstancesItem["ProjectId"].asString()); - if(!allAlertMessagesNodeInstancesInstancesItem["Status"].isNull()) - instancesObject.status = allAlertMessagesNodeInstancesInstancesItem["Status"].asString(); - if(!allAlertMessagesNodeInstancesInstancesItem["InstanceId"].isNull()) - instancesObject.instanceId = std::stol(allAlertMessagesNodeInstancesInstancesItem["InstanceId"].asString()); + if(!dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["NodeId"].isNull()) + instancesObject.nodeId = std::stol(dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["NodeId"].asString()); + if(!dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["NodeName"].isNull()) + instancesObject.nodeName = dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["NodeName"].asString(); + if(!dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["ProjectId"].isNull()) + instancesObject.projectId = std::stol(dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["ProjectId"].asString()); + if(!dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["Status"].isNull()) + instancesObject.status = dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["Status"].asString(); + if(!dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["InstanceId"].isNull()) + instancesObject.instanceId = std::stol(dataNodeAlertMessagesAlertMessagesItemInstancesInstancesItem["InstanceId"].asString()); alertMessagesItemObject.instances.push_back(instancesObject); } - auto allTopicsNode = allAlertMessagesNode["Topics"]["TopicsItem"]; - for (auto allAlertMessagesNodeTopicsTopicsItem : allTopicsNode) + auto allTopicsNode = dataNodeAlertMessagesAlertMessagesItem["Topics"]["TopicsItem"]; + for (auto dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem : allTopicsNode) { Data::AlertMessagesItem::TopicsItem topicsObject; - if(!allAlertMessagesNodeTopicsTopicsItem["NodeId"].isNull()) - topicsObject.nodeId = std::stol(allAlertMessagesNodeTopicsTopicsItem["NodeId"].asString()); - if(!allAlertMessagesNodeTopicsTopicsItem["InstanceId"].isNull()) - topicsObject.instanceId = std::stol(allAlertMessagesNodeTopicsTopicsItem["InstanceId"].asString()); - if(!allAlertMessagesNodeTopicsTopicsItem["TopicId"].isNull()) - topicsObject.topicId = std::stol(allAlertMessagesNodeTopicsTopicsItem["TopicId"].asString()); - if(!allAlertMessagesNodeTopicsTopicsItem["TopicName"].isNull()) - topicsObject.topicName = allAlertMessagesNodeTopicsTopicsItem["TopicName"].asString(); - if(!allAlertMessagesNodeTopicsTopicsItem["TopicOwner"].isNull()) - topicsObject.topicOwner = allAlertMessagesNodeTopicsTopicsItem["TopicOwner"].asString(); - if(!allAlertMessagesNodeTopicsTopicsItem["TopicStatus"].isNull()) - topicsObject.topicStatus = allAlertMessagesNodeTopicsTopicsItem["TopicStatus"].asString(); + if(!dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["NodeId"].isNull()) + topicsObject.nodeId = std::stol(dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["NodeId"].asString()); + if(!dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["InstanceId"].isNull()) + topicsObject.instanceId = std::stol(dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["InstanceId"].asString()); + if(!dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicId"].isNull()) + topicsObject.topicId = std::stol(dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicId"].asString()); + if(!dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicName"].isNull()) + topicsObject.topicName = dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicName"].asString(); + if(!dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicOwner"].isNull()) + topicsObject.topicOwner = dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicOwner"].asString(); + if(!dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicStatus"].isNull()) + topicsObject.topicStatus = dataNodeAlertMessagesAlertMessagesItemTopicsTopicsItem["TopicStatus"].asString(); alertMessagesItemObject.topics.push_back(topicsObject); } - auto allNodesNode = allAlertMessagesNode["Nodes"]["NodesItem"]; - for (auto allAlertMessagesNodeNodesNodesItem : allNodesNode) + auto allNodesNode = dataNodeAlertMessagesAlertMessagesItem["Nodes"]["NodesItem"]; + for (auto dataNodeAlertMessagesAlertMessagesItemNodesNodesItem : allNodesNode) { Data::AlertMessagesItem::NodesItem nodesObject; - if(!allAlertMessagesNodeNodesNodesItem["NodeId"].isNull()) - nodesObject.nodeId = std::stol(allAlertMessagesNodeNodesNodesItem["NodeId"].asString()); - if(!allAlertMessagesNodeNodesNodesItem["NodeName"].isNull()) - nodesObject.nodeName = allAlertMessagesNodeNodesNodesItem["NodeName"].asString(); - if(!allAlertMessagesNodeNodesNodesItem["Owner"].isNull()) - nodesObject.owner = allAlertMessagesNodeNodesNodesItem["Owner"].asString(); - if(!allAlertMessagesNodeNodesNodesItem["ProjectId"].isNull()) - nodesObject.projectId = std::stol(allAlertMessagesNodeNodesNodesItem["ProjectId"].asString()); + if(!dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["NodeId"].isNull()) + nodesObject.nodeId = std::stol(dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["NodeId"].asString()); + if(!dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["NodeName"].isNull()) + nodesObject.nodeName = dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["NodeName"].asString(); + if(!dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["Owner"].isNull()) + nodesObject.owner = dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["Owner"].asString(); + if(!dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["ProjectId"].isNull()) + nodesObject.projectId = std::stol(dataNodeAlertMessagesAlertMessagesItemNodesNodesItem["ProjectId"].asString()); alertMessagesItemObject.nodes.push_back(nodesObject); } auto slaAlertNode = value["SlaAlert"]; diff --git a/dataworks-public/src/model/ListDataServiceApiAuthoritiesResult.cc b/dataworks-public/src/model/ListDataServiceApiAuthoritiesResult.cc index 730e21e71..102c3e223 100644 --- a/dataworks-public/src/model/ListDataServiceApiAuthoritiesResult.cc +++ b/dataworks-public/src/model/ListDataServiceApiAuthoritiesResult.cc @@ -70,18 +70,18 @@ void ListDataServiceApiAuthoritiesResult::parse(const std::string &payload) apiAuthorizationObject.projectId = std::stol(dataNodeApiAuthorizationListApiAuthorization["ProjectId"].asString()); if(!dataNodeApiAuthorizationListApiAuthorization["TenantId"].isNull()) apiAuthorizationObject.tenantId = std::stol(dataNodeApiAuthorizationListApiAuthorization["TenantId"].asString()); - auto allAuthorizationRecordsNode = allApiAuthorizationListNode["AuthorizationRecords"]["AuthorizationRecord"]; - for (auto allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord : allAuthorizationRecordsNode) + auto allAuthorizationRecordsNode = dataNodeApiAuthorizationListApiAuthorization["AuthorizationRecords"]["AuthorizationRecord"]; + for (auto dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord : allAuthorizationRecordsNode) { Data::ApiAuthorization::AuthorizationRecord authorizationRecordsObject; - if(!allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["CreatedTime"].isNull()) - authorizationRecordsObject.createdTime = allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["CreatedTime"].asString(); - if(!allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["CreatorId"].isNull()) - authorizationRecordsObject.creatorId = allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["CreatorId"].asString(); - if(!allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["EndTime"].isNull()) - authorizationRecordsObject.endTime = allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["EndTime"].asString(); - if(!allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["ProjectId"].isNull()) - authorizationRecordsObject.projectId = std::stol(allApiAuthorizationListNodeAuthorizationRecordsAuthorizationRecord["ProjectId"].asString()); + if(!dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["CreatedTime"].isNull()) + authorizationRecordsObject.createdTime = dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["CreatedTime"].asString(); + if(!dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["CreatorId"].isNull()) + authorizationRecordsObject.creatorId = dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["CreatorId"].asString(); + if(!dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["EndTime"].isNull()) + authorizationRecordsObject.endTime = dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["EndTime"].asString(); + if(!dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["ProjectId"].isNull()) + authorizationRecordsObject.projectId = std::stol(dataNodeApiAuthorizationListApiAuthorizationAuthorizationRecordsAuthorizationRecord["ProjectId"].asString()); apiAuthorizationObject.authorizationRecords.push_back(authorizationRecordsObject); } data_.apiAuthorizationList.push_back(apiAuthorizationObject); diff --git a/dataworks-public/src/model/ListInstancesRequest.cc b/dataworks-public/src/model/ListInstancesRequest.cc index 30e818b80..f07851a15 100644 --- a/dataworks-public/src/model/ListInstancesRequest.cc +++ b/dataworks-public/src/model/ListInstancesRequest.cc @@ -60,6 +60,17 @@ void ListInstancesRequest::setBizName(const std::string& bizName) setBodyParameter("BizName", bizName); } +long ListInstancesRequest::getDagId()const +{ + return dagId_; +} + +void ListInstancesRequest::setDagId(long dagId) +{ + dagId_ = dagId; + setBodyParameter("DagId", std::to_string(dagId)); +} + int ListInstancesRequest::getPageNumber()const { return pageNumber_; diff --git a/dataworks-public/src/model/ListInstancesResult.cc b/dataworks-public/src/model/ListInstancesResult.cc index ae3777d28..c64e97d64 100644 --- a/dataworks-public/src/model/ListInstancesResult.cc +++ b/dataworks-public/src/model/ListInstancesResult.cc @@ -80,6 +80,24 @@ void ListInstancesResult::parse(const std::string &payload) instanceObject.paramValues = dataNodeInstancesInstance["ParamValues"].asString(); if(!dataNodeInstancesInstance["FinishTime"].isNull()) instanceObject.finishTime = std::stol(dataNodeInstancesInstance["FinishTime"].asString()); + if(!dataNodeInstancesInstance["Priority"].isNull()) + instanceObject.priority = std::stoi(dataNodeInstancesInstance["Priority"].asString()); + if(!dataNodeInstancesInstance["BaselineId"].isNull()) + instanceObject.baselineId = std::stol(dataNodeInstancesInstance["BaselineId"].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["RelatedFlowId"].isNull()) + instanceObject.relatedFlowId = std::stol(dataNodeInstancesInstance["RelatedFlowId"].asString()); data_.instances.push_back(instanceObject); } if(!value["Success"].isNull()) diff --git a/dataworks-public/src/model/ListNodeIOResult.cc b/dataworks-public/src/model/ListNodeIOResult.cc index 86fec2a80..f318bd482 100644 --- a/dataworks-public/src/model/ListNodeIOResult.cc +++ b/dataworks-public/src/model/ListNodeIOResult.cc @@ -47,6 +47,8 @@ void ListNodeIOResult::parse(const std::string &payload) dataObject.tableName = valueDataDataItem["TableName"].asString(); if(!valueDataDataItem["Data"].isNull()) dataObject.data = valueDataDataItem["Data"].asString(); + if(!valueDataDataItem["NodeId"].isNull()) + dataObject.nodeId = std::stol(valueDataDataItem["NodeId"].asString()); data_.push_back(dataObject); } if(!value["Success"].isNull()) diff --git a/dataworks-public/src/model/ListNodesResult.cc b/dataworks-public/src/model/ListNodesResult.cc index 78b463daf..e82cf474c 100644 --- a/dataworks-public/src/model/ListNodesResult.cc +++ b/dataworks-public/src/model/ListNodesResult.cc @@ -72,6 +72,20 @@ void ListNodesResult::parse(const std::string &payload) nodesItemObject.description = dataNodeNodesNodesItem["Description"].asString(); if(!dataNodeNodesNodesItem["ResGroupName"].isNull()) nodesItemObject.resGroupName = dataNodeNodesNodesItem["ResGroupName"].asString(); + if(!dataNodeNodesNodesItem["Priority"].isNull()) + nodesItemObject.priority = std::stoi(dataNodeNodesNodesItem["Priority"].asString()); + if(!dataNodeNodesNodesItem["BaselineId"].isNull()) + nodesItemObject.baselineId = std::stol(dataNodeNodesNodesItem["BaselineId"].asString()); + if(!dataNodeNodesNodesItem["RepeatInterval"].isNull()) + nodesItemObject.repeatInterval = std::stol(dataNodeNodesNodesItem["RepeatInterval"].asString()); + if(!dataNodeNodesNodesItem["Connection"].isNull()) + nodesItemObject.connection = dataNodeNodesNodesItem["Connection"].asString(); + if(!dataNodeNodesNodesItem["DqcType"].isNull()) + nodesItemObject.dqcType = std::stoi(dataNodeNodesNodesItem["DqcType"].asString()); + if(!dataNodeNodesNodesItem["DqcDescription"].isNull()) + nodesItemObject.dqcDescription = dataNodeNodesNodesItem["DqcDescription"].asString(); + if(!dataNodeNodesNodesItem["RelatedFlowId"].isNull()) + nodesItemObject.relatedFlowId = std::stol(dataNodeNodesNodesItem["RelatedFlowId"].asString()); data_.nodes.push_back(nodesItemObject); } if(!value["Success"].isNull()) diff --git a/dataworks-public/src/model/ListProjectMembersResult.cc b/dataworks-public/src/model/ListProjectMembersResult.cc index 24be26b43..32c77d35e 100644 --- a/dataworks-public/src/model/ListProjectMembersResult.cc +++ b/dataworks-public/src/model/ListProjectMembersResult.cc @@ -60,18 +60,18 @@ void ListProjectMembersResult::parse(const std::string &payload) projectMemberObject.projectMemberType = dataNodeProjectMemberListProjectMember["ProjectMemberType"].asString(); if(!dataNodeProjectMemberListProjectMember["Status"].isNull()) projectMemberObject.status = dataNodeProjectMemberListProjectMember["Status"].asString(); - auto allProjectRoleListNode = allProjectMemberListNode["ProjectRoleList"]["Role"]; - for (auto allProjectMemberListNodeProjectRoleListRole : allProjectRoleListNode) + auto allProjectRoleListNode = dataNodeProjectMemberListProjectMember["ProjectRoleList"]["Role"]; + for (auto dataNodeProjectMemberListProjectMemberProjectRoleListRole : allProjectRoleListNode) { Data::ProjectMember::Role projectRoleListObject; - if(!allProjectMemberListNodeProjectRoleListRole["ProjectRoleCode"].isNull()) - projectRoleListObject.projectRoleCode = allProjectMemberListNodeProjectRoleListRole["ProjectRoleCode"].asString(); - if(!allProjectMemberListNodeProjectRoleListRole["ProjectRoleId"].isNull()) - projectRoleListObject.projectRoleId = std::stoi(allProjectMemberListNodeProjectRoleListRole["ProjectRoleId"].asString()); - if(!allProjectMemberListNodeProjectRoleListRole["ProjectRoleName"].isNull()) - projectRoleListObject.projectRoleName = allProjectMemberListNodeProjectRoleListRole["ProjectRoleName"].asString(); - if(!allProjectMemberListNodeProjectRoleListRole["ProjectRoleType"].isNull()) - projectRoleListObject.projectRoleType = allProjectMemberListNodeProjectRoleListRole["ProjectRoleType"].asString(); + if(!dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleCode"].isNull()) + projectRoleListObject.projectRoleCode = dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleCode"].asString(); + if(!dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleId"].isNull()) + projectRoleListObject.projectRoleId = std::stoi(dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleId"].asString()); + if(!dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleName"].isNull()) + projectRoleListObject.projectRoleName = dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleName"].asString(); + if(!dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleType"].isNull()) + projectRoleListObject.projectRoleType = dataNodeProjectMemberListProjectMemberProjectRoleListRole["ProjectRoleType"].asString(); projectMemberObject.projectRoleList.push_back(projectRoleListObject); } data_.projectMemberList.push_back(projectMemberObject); diff --git a/dataworks-public/src/model/ListQualityResultsByEntityResult.cc b/dataworks-public/src/model/ListQualityResultsByEntityResult.cc index 4ebc23c89..c719146f3 100644 --- a/dataworks-public/src/model/ListQualityResultsByEntityResult.cc +++ b/dataworks-public/src/model/ListQualityResultsByEntityResult.cc @@ -128,32 +128,32 @@ void ListQualityResultsByEntityResult::parse(const std::string &payload) ruleChecksItemObject.lowerValue = std::stof(qualityResultsNodeRuleChecksRuleChecksItem["LowerValue"].asString()); if(!qualityResultsNodeRuleChecksRuleChecksItem["CheckerName"].isNull()) ruleChecksItemObject.checkerName = qualityResultsNodeRuleChecksRuleChecksItem["CheckerName"].asString(); - auto allReferenceValueNode = allRuleChecksNode["ReferenceValue"]["ReferenceValueItem"]; - for (auto allRuleChecksNodeReferenceValueReferenceValueItem : allReferenceValueNode) + auto allReferenceValueNode = qualityResultsNodeRuleChecksRuleChecksItem["ReferenceValue"]["ReferenceValueItem"]; + for (auto qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem : allReferenceValueNode) { QualityResults::RuleChecksItem::ReferenceValueItem referenceValueObject; - if(!allRuleChecksNodeReferenceValueReferenceValueItem["BizDate"].isNull()) - referenceValueObject.bizDate = std::stol(allRuleChecksNodeReferenceValueReferenceValueItem["BizDate"].asString()); - if(!allRuleChecksNodeReferenceValueReferenceValueItem["DiscreteProperty"].isNull()) - referenceValueObject.discreteProperty = allRuleChecksNodeReferenceValueReferenceValueItem["DiscreteProperty"].asString(); - if(!allRuleChecksNodeReferenceValueReferenceValueItem["Value"].isNull()) - referenceValueObject.value = std::stof(allRuleChecksNodeReferenceValueReferenceValueItem["Value"].asString()); - if(!allRuleChecksNodeReferenceValueReferenceValueItem["Threshold"].isNull()) - referenceValueObject.threshold = std::stof(allRuleChecksNodeReferenceValueReferenceValueItem["Threshold"].asString()); - if(!allRuleChecksNodeReferenceValueReferenceValueItem["SingleCheckResult"].isNull()) - referenceValueObject.singleCheckResult = std::stoi(allRuleChecksNodeReferenceValueReferenceValueItem["SingleCheckResult"].asString()); + if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].isNull()) + referenceValueObject.bizDate = std::stol(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].asString()); + if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].isNull()) + referenceValueObject.discreteProperty = qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].asString(); + if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].isNull()) + referenceValueObject.value = std::stof(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].asString()); + if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].isNull()) + referenceValueObject.threshold = std::stof(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].asString()); + if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].isNull()) + referenceValueObject.singleCheckResult = std::stoi(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].asString()); ruleChecksItemObject.referenceValue.push_back(referenceValueObject); } - auto allSampleValueNode = allRuleChecksNode["SampleValue"]["SampleValueItem"]; - for (auto allRuleChecksNodeSampleValueSampleValueItem : allSampleValueNode) + auto allSampleValueNode = qualityResultsNodeRuleChecksRuleChecksItem["SampleValue"]["SampleValueItem"]; + for (auto qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem : allSampleValueNode) { QualityResults::RuleChecksItem::SampleValueItem sampleValueObject; - if(!allRuleChecksNodeSampleValueSampleValueItem["BizDate"].isNull()) - sampleValueObject.bizDate = std::stol(allRuleChecksNodeSampleValueSampleValueItem["BizDate"].asString()); - if(!allRuleChecksNodeSampleValueSampleValueItem["DiscreteProperty"].isNull()) - sampleValueObject.discreteProperty = allRuleChecksNodeSampleValueSampleValueItem["DiscreteProperty"].asString(); - if(!allRuleChecksNodeSampleValueSampleValueItem["Value"].isNull()) - sampleValueObject.value = std::stof(allRuleChecksNodeSampleValueSampleValueItem["Value"].asString()); + if(!qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].isNull()) + sampleValueObject.bizDate = std::stol(qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].asString()); + if(!qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].isNull()) + sampleValueObject.discreteProperty = qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].asString(); + if(!qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].isNull()) + sampleValueObject.value = std::stof(qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].asString()); ruleChecksItemObject.sampleValue.push_back(sampleValueObject); } qualityResults_.ruleChecks.push_back(ruleChecksItemObject); diff --git a/dataworks-public/src/model/ListQualityResultsByRuleResult.cc b/dataworks-public/src/model/ListQualityResultsByRuleResult.cc index 6b9c791ec..799c37ed3 100644 --- a/dataworks-public/src/model/ListQualityResultsByRuleResult.cc +++ b/dataworks-public/src/model/ListQualityResultsByRuleResult.cc @@ -128,32 +128,32 @@ void ListQualityResultsByRuleResult::parse(const std::string &payload) ruleChecksItemObject.lowerValue = std::stof(qualityResultsNodeRuleChecksRuleChecksItem["LowerValue"].asString()); if(!qualityResultsNodeRuleChecksRuleChecksItem["CheckerName"].isNull()) ruleChecksItemObject.checkerName = qualityResultsNodeRuleChecksRuleChecksItem["CheckerName"].asString(); - auto allReferenceValueNode = allRuleChecksNode["ReferenceValue"]["ReferenceValueItem"]; - for (auto allRuleChecksNodeReferenceValueReferenceValueItem : allReferenceValueNode) + auto allReferenceValueNode = qualityResultsNodeRuleChecksRuleChecksItem["ReferenceValue"]["ReferenceValueItem"]; + for (auto qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem : allReferenceValueNode) { QualityResults::RuleChecksItem::ReferenceValueItem referenceValueObject; - if(!allRuleChecksNodeReferenceValueReferenceValueItem["BizDate"].isNull()) - referenceValueObject.bizDate = std::stol(allRuleChecksNodeReferenceValueReferenceValueItem["BizDate"].asString()); - if(!allRuleChecksNodeReferenceValueReferenceValueItem["DiscreteProperty"].isNull()) - referenceValueObject.discreteProperty = allRuleChecksNodeReferenceValueReferenceValueItem["DiscreteProperty"].asString(); - if(!allRuleChecksNodeReferenceValueReferenceValueItem["Value"].isNull()) - referenceValueObject.value = std::stof(allRuleChecksNodeReferenceValueReferenceValueItem["Value"].asString()); - if(!allRuleChecksNodeReferenceValueReferenceValueItem["Threshold"].isNull()) - referenceValueObject.threshold = std::stof(allRuleChecksNodeReferenceValueReferenceValueItem["Threshold"].asString()); - if(!allRuleChecksNodeReferenceValueReferenceValueItem["SingleCheckResult"].isNull()) - referenceValueObject.singleCheckResult = std::stoi(allRuleChecksNodeReferenceValueReferenceValueItem["SingleCheckResult"].asString()); + if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].isNull()) + referenceValueObject.bizDate = std::stol(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["BizDate"].asString()); + if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].isNull()) + referenceValueObject.discreteProperty = qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["DiscreteProperty"].asString(); + if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].isNull()) + referenceValueObject.value = std::stof(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Value"].asString()); + if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].isNull()) + referenceValueObject.threshold = std::stof(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["Threshold"].asString()); + if(!qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].isNull()) + referenceValueObject.singleCheckResult = std::stoi(qualityResultsNodeRuleChecksRuleChecksItemReferenceValueReferenceValueItem["SingleCheckResult"].asString()); ruleChecksItemObject.referenceValue.push_back(referenceValueObject); } - auto allSampleValueNode = allRuleChecksNode["SampleValue"]["SampleValueItem"]; - for (auto allRuleChecksNodeSampleValueSampleValueItem : allSampleValueNode) + auto allSampleValueNode = qualityResultsNodeRuleChecksRuleChecksItem["SampleValue"]["SampleValueItem"]; + for (auto qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem : allSampleValueNode) { QualityResults::RuleChecksItem::SampleValueItem sampleValueObject; - if(!allRuleChecksNodeSampleValueSampleValueItem["BizDate"].isNull()) - sampleValueObject.bizDate = std::stol(allRuleChecksNodeSampleValueSampleValueItem["BizDate"].asString()); - if(!allRuleChecksNodeSampleValueSampleValueItem["DiscreteProperty"].isNull()) - sampleValueObject.discreteProperty = allRuleChecksNodeSampleValueSampleValueItem["DiscreteProperty"].asString(); - if(!allRuleChecksNodeSampleValueSampleValueItem["Value"].isNull()) - sampleValueObject.value = std::stof(allRuleChecksNodeSampleValueSampleValueItem["Value"].asString()); + if(!qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].isNull()) + sampleValueObject.bizDate = std::stol(qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["BizDate"].asString()); + if(!qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].isNull()) + sampleValueObject.discreteProperty = qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["DiscreteProperty"].asString(); + if(!qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].isNull()) + sampleValueObject.value = std::stof(qualityResultsNodeRuleChecksRuleChecksItemSampleValueSampleValueItem["Value"].asString()); ruleChecksItemObject.sampleValue.push_back(sampleValueObject); } qualityResults_.ruleChecks.push_back(ruleChecksItemObject); diff --git a/dataworks-public/src/model/RunTriggerNodeRequest.cc b/dataworks-public/src/model/RunTriggerNodeRequest.cc new file mode 100644 index 000000000..4bd77930e --- /dev/null +++ b/dataworks-public/src/model/RunTriggerNodeRequest.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::RunTriggerNodeRequest; + +RunTriggerNodeRequest::RunTriggerNodeRequest() : + RpcServiceRequest("dataworks-public", "2020-05-18", "RunTriggerNode") +{ + setMethod(HttpRequest::Method::Put); +} + +RunTriggerNodeRequest::~RunTriggerNodeRequest() +{} + +long RunTriggerNodeRequest::getBizDate()const +{ + return bizDate_; +} + +void RunTriggerNodeRequest::setBizDate(long bizDate) +{ + bizDate_ = bizDate; + setBodyParameter("BizDate", std::to_string(bizDate)); +} + +long RunTriggerNodeRequest::getAppId()const +{ + return appId_; +} + +void RunTriggerNodeRequest::setAppId(long appId) +{ + appId_ = appId; + setBodyParameter("AppId", std::to_string(appId)); +} + +long RunTriggerNodeRequest::getCycleTime()const +{ + return cycleTime_; +} + +void RunTriggerNodeRequest::setCycleTime(long cycleTime) +{ + cycleTime_ = cycleTime; + setBodyParameter("CycleTime", std::to_string(cycleTime)); +} + +long RunTriggerNodeRequest::getNodeId()const +{ + return nodeId_; +} + +void RunTriggerNodeRequest::setNodeId(long nodeId) +{ + nodeId_ = nodeId; + setBodyParameter("NodeId", std::to_string(nodeId)); +} + diff --git a/dataworks-public/src/model/RunTriggerNodeResult.cc b/dataworks-public/src/model/RunTriggerNodeResult.cc new file mode 100644 index 000000000..0c33f9e8a --- /dev/null +++ b/dataworks-public/src/model/RunTriggerNodeResult.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 +#include + +using namespace AlibabaCloud::Dataworks_public; +using namespace AlibabaCloud::Dataworks_public::Model; + +RunTriggerNodeResult::RunTriggerNodeResult() : + ServiceResult() +{} + +RunTriggerNodeResult::RunTriggerNodeResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RunTriggerNodeResult::~RunTriggerNodeResult() +{} + +void RunTriggerNodeResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +bool RunTriggerNodeResult::getSuccess()const +{ + return success_; +} + diff --git a/dataworks-public/src/model/SearchNodesByOutputRequest.cc b/dataworks-public/src/model/SearchNodesByOutputRequest.cc new file mode 100644 index 000000000..e830a27a3 --- /dev/null +++ b/dataworks-public/src/model/SearchNodesByOutputRequest.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::SearchNodesByOutputRequest; + +SearchNodesByOutputRequest::SearchNodesByOutputRequest() : + RpcServiceRequest("dataworks-public", "2020-05-18", "SearchNodesByOutput") +{ + setMethod(HttpRequest::Method::Post); +} + +SearchNodesByOutputRequest::~SearchNodesByOutputRequest() +{} + +std::string SearchNodesByOutputRequest::getProjectEnv()const +{ + return projectEnv_; +} + +void SearchNodesByOutputRequest::setProjectEnv(const std::string& projectEnv) +{ + projectEnv_ = projectEnv; + setBodyParameter("ProjectEnv", projectEnv); +} + +std::string SearchNodesByOutputRequest::getOutputs()const +{ + return outputs_; +} + +void SearchNodesByOutputRequest::setOutputs(const std::string& outputs) +{ + outputs_ = outputs; + setBodyParameter("Outputs", outputs); +} + diff --git a/dataworks-public/src/model/SearchNodesByOutputResult.cc b/dataworks-public/src/model/SearchNodesByOutputResult.cc new file mode 100644 index 000000000..afc887de7 --- /dev/null +++ b/dataworks-public/src/model/SearchNodesByOutputResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::Dataworks_public; +using namespace AlibabaCloud::Dataworks_public::Model; + +SearchNodesByOutputResult::SearchNodesByOutputResult() : + ServiceResult() +{} + +SearchNodesByOutputResult::SearchNodesByOutputResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +SearchNodesByOutputResult::~SearchNodesByOutputResult() +{} + +void SearchNodesByOutputResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + 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["Data"].isNull()) + data_ = value["Data"].asString(); + +} + +int SearchNodesByOutputResult::getHttpStatusCode()const +{ + return httpStatusCode_; +} + +std::string SearchNodesByOutputResult::getData()const +{ + return data_; +} + +std::string SearchNodesByOutputResult::getErrorCode()const +{ + return errorCode_; +} + +std::string SearchNodesByOutputResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool SearchNodesByOutputResult::getSuccess()const +{ + return success_; +} +