From cd65c6d0635d56d9e3251cb4492ecb32fb3fb06b Mon Sep 17 00:00:00 2001 From: sdk-team Date: Thu, 25 May 2023 06:57:36 +0000 Subject: [PATCH] Support AnalyzeLineage API. --- VERSION | 2 +- dms-enterprise/CMakeLists.txt | 8 + .../dms-enterprise/Dms_enterpriseClient.h | 16 + .../model/AnalyzeSQLLineageRequest.h | 48 +++ .../model/AnalyzeSQLLineageResult.h | 86 +++++ .../dms-enterprise/model/BackFillRequest.h | 3 + .../dms-enterprise/model/BackFillResult.h | 2 + .../model/GetDataArchiveOrderDetailRequest.h | 45 +++ .../model/GetDataArchiveOrderDetailResult.h | 192 +++++++++++ .../model/ListTaskFlowInstanceRequest.h | 6 + .../model/ListTaskFlowInstanceResult.h | 1 + .../model/ListTaskFlowsByPageRequest.h | 6 + .../model/ListTaskFlowsByPageResult.h | 13 +- dms-enterprise/src/Dms-enterpriseClient.cc | 72 +++++ .../src/model/AnalyzeSQLLineageRequest.cc | 54 ++++ .../src/model/AnalyzeSQLLineageResult.cc | 110 +++++++ dms-enterprise/src/model/BackFillRequest.cc | 11 + dms-enterprise/src/model/BackFillResult.cc | 7 + .../model/GetDataArchiveOrderDetailRequest.cc | 45 +++ .../model/GetDataArchiveOrderDetailResult.cc | 299 ++++++++++++++++++ .../src/model/ListTaskFlowInstanceRequest.cc | 18 ++ .../src/model/ListTaskFlowInstanceResult.cc | 2 + .../src/model/ListTaskFlowsByPageRequest.cc | 20 ++ .../src/model/ListTaskFlowsByPageResult.cc | 14 + 24 files changed, 1076 insertions(+), 4 deletions(-) create mode 100644 dms-enterprise/include/alibabacloud/dms-enterprise/model/AnalyzeSQLLineageRequest.h create mode 100644 dms-enterprise/include/alibabacloud/dms-enterprise/model/AnalyzeSQLLineageResult.h create mode 100644 dms-enterprise/include/alibabacloud/dms-enterprise/model/GetDataArchiveOrderDetailRequest.h create mode 100644 dms-enterprise/include/alibabacloud/dms-enterprise/model/GetDataArchiveOrderDetailResult.h create mode 100644 dms-enterprise/src/model/AnalyzeSQLLineageRequest.cc create mode 100644 dms-enterprise/src/model/AnalyzeSQLLineageResult.cc create mode 100644 dms-enterprise/src/model/GetDataArchiveOrderDetailRequest.cc create mode 100644 dms-enterprise/src/model/GetDataArchiveOrderDetailResult.cc diff --git a/VERSION b/VERSION index 933ddff7a..b5f9a3ccb 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1582 \ No newline at end of file +1.36.1583 \ No newline at end of file diff --git a/dms-enterprise/CMakeLists.txt b/dms-enterprise/CMakeLists.txt index d6c5d9b25..c1dbc87b7 100644 --- a/dms-enterprise/CMakeLists.txt +++ b/dms-enterprise/CMakeLists.txt @@ -29,6 +29,8 @@ set(dms-enterprise_public_header_model include/alibabacloud/dms-enterprise/model/AddLogicTableRouteConfigResult.h include/alibabacloud/dms-enterprise/model/AddTaskFlowEdgesRequest.h include/alibabacloud/dms-enterprise/model/AddTaskFlowEdgesResult.h + include/alibabacloud/dms-enterprise/model/AnalyzeSQLLineageRequest.h + include/alibabacloud/dms-enterprise/model/AnalyzeSQLLineageResult.h include/alibabacloud/dms-enterprise/model/ApproveOrderRequest.h include/alibabacloud/dms-enterprise/model/ApproveOrderResult.h include/alibabacloud/dms-enterprise/model/BackFillRequest.h @@ -135,6 +137,8 @@ set(dms-enterprise_public_header_model include/alibabacloud/dms-enterprise/model/GetDBTaskSQLJobLogResult.h include/alibabacloud/dms-enterprise/model/GetDBTopologyRequest.h include/alibabacloud/dms-enterprise/model/GetDBTopologyResult.h + include/alibabacloud/dms-enterprise/model/GetDataArchiveOrderDetailRequest.h + include/alibabacloud/dms-enterprise/model/GetDataArchiveOrderDetailResult.h include/alibabacloud/dms-enterprise/model/GetDataCorrectBackupFilesRequest.h include/alibabacloud/dms-enterprise/model/GetDataCorrectBackupFilesResult.h include/alibabacloud/dms-enterprise/model/GetDataCorrectOrderDetailRequest.h @@ -440,6 +444,8 @@ set(dms-enterprise_src src/model/AddLogicTableRouteConfigResult.cc src/model/AddTaskFlowEdgesRequest.cc src/model/AddTaskFlowEdgesResult.cc + src/model/AnalyzeSQLLineageRequest.cc + src/model/AnalyzeSQLLineageResult.cc src/model/ApproveOrderRequest.cc src/model/ApproveOrderResult.cc src/model/BackFillRequest.cc @@ -546,6 +552,8 @@ set(dms-enterprise_src src/model/GetDBTaskSQLJobLogResult.cc src/model/GetDBTopologyRequest.cc src/model/GetDBTopologyResult.cc + src/model/GetDataArchiveOrderDetailRequest.cc + src/model/GetDataArchiveOrderDetailResult.cc src/model/GetDataCorrectBackupFilesRequest.cc src/model/GetDataCorrectBackupFilesResult.cc src/model/GetDataCorrectOrderDetailRequest.cc diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/Dms_enterpriseClient.h b/dms-enterprise/include/alibabacloud/dms-enterprise/Dms_enterpriseClient.h index 6e90b3db2..0236493b8 100644 --- a/dms-enterprise/include/alibabacloud/dms-enterprise/Dms_enterpriseClient.h +++ b/dms-enterprise/include/alibabacloud/dms-enterprise/Dms_enterpriseClient.h @@ -30,6 +30,8 @@ #include "model/AddLogicTableRouteConfigResult.h" #include "model/AddTaskFlowEdgesRequest.h" #include "model/AddTaskFlowEdgesResult.h" +#include "model/AnalyzeSQLLineageRequest.h" +#include "model/AnalyzeSQLLineageResult.h" #include "model/ApproveOrderRequest.h" #include "model/ApproveOrderResult.h" #include "model/BackFillRequest.h" @@ -136,6 +138,8 @@ #include "model/GetDBTaskSQLJobLogResult.h" #include "model/GetDBTopologyRequest.h" #include "model/GetDBTopologyResult.h" +#include "model/GetDataArchiveOrderDetailRequest.h" +#include "model/GetDataArchiveOrderDetailResult.h" #include "model/GetDataCorrectBackupFilesRequest.h" #include "model/GetDataCorrectBackupFilesResult.h" #include "model/GetDataCorrectOrderDetailRequest.h" @@ -451,6 +455,9 @@ namespace AlibabaCloud typedef Outcome AddTaskFlowEdgesOutcome; typedef std::future AddTaskFlowEdgesOutcomeCallable; typedef std::function&)> AddTaskFlowEdgesAsyncHandler; + typedef Outcome AnalyzeSQLLineageOutcome; + typedef std::future AnalyzeSQLLineageOutcomeCallable; + typedef std::function&)> AnalyzeSQLLineageAsyncHandler; typedef Outcome ApproveOrderOutcome; typedef std::future ApproveOrderOutcomeCallable; typedef std::function&)> ApproveOrderAsyncHandler; @@ -610,6 +617,9 @@ namespace AlibabaCloud typedef Outcome GetDBTopologyOutcome; typedef std::future GetDBTopologyOutcomeCallable; typedef std::function&)> GetDBTopologyAsyncHandler; + typedef Outcome GetDataArchiveOrderDetailOutcome; + typedef std::future GetDataArchiveOrderDetailOutcomeCallable; + typedef std::function&)> GetDataArchiveOrderDetailAsyncHandler; typedef Outcome GetDataCorrectBackupFilesOutcome; typedef std::future GetDataCorrectBackupFilesOutcomeCallable; typedef std::function&)> GetDataCorrectBackupFilesAsyncHandler; @@ -1068,6 +1078,9 @@ namespace AlibabaCloud AddTaskFlowEdgesOutcome addTaskFlowEdges(const Model::AddTaskFlowEdgesRequest &request)const; void addTaskFlowEdgesAsync(const Model::AddTaskFlowEdgesRequest& request, const AddTaskFlowEdgesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; AddTaskFlowEdgesOutcomeCallable addTaskFlowEdgesCallable(const Model::AddTaskFlowEdgesRequest& request) const; + AnalyzeSQLLineageOutcome analyzeSQLLineage(const Model::AnalyzeSQLLineageRequest &request)const; + void analyzeSQLLineageAsync(const Model::AnalyzeSQLLineageRequest& request, const AnalyzeSQLLineageAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + AnalyzeSQLLineageOutcomeCallable analyzeSQLLineageCallable(const Model::AnalyzeSQLLineageRequest& request) const; ApproveOrderOutcome approveOrder(const Model::ApproveOrderRequest &request)const; void approveOrderAsync(const Model::ApproveOrderRequest& request, const ApproveOrderAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ApproveOrderOutcomeCallable approveOrderCallable(const Model::ApproveOrderRequest& request) const; @@ -1227,6 +1240,9 @@ namespace AlibabaCloud GetDBTopologyOutcome getDBTopology(const Model::GetDBTopologyRequest &request)const; void getDBTopologyAsync(const Model::GetDBTopologyRequest& request, const GetDBTopologyAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetDBTopologyOutcomeCallable getDBTopologyCallable(const Model::GetDBTopologyRequest& request) const; + GetDataArchiveOrderDetailOutcome getDataArchiveOrderDetail(const Model::GetDataArchiveOrderDetailRequest &request)const; + void getDataArchiveOrderDetailAsync(const Model::GetDataArchiveOrderDetailRequest& request, const GetDataArchiveOrderDetailAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetDataArchiveOrderDetailOutcomeCallable getDataArchiveOrderDetailCallable(const Model::GetDataArchiveOrderDetailRequest& request) const; GetDataCorrectBackupFilesOutcome getDataCorrectBackupFiles(const Model::GetDataCorrectBackupFilesRequest &request)const; void getDataCorrectBackupFilesAsync(const Model::GetDataCorrectBackupFilesRequest& request, const GetDataCorrectBackupFilesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; GetDataCorrectBackupFilesOutcomeCallable getDataCorrectBackupFilesCallable(const Model::GetDataCorrectBackupFilesRequest& request) const; diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/AnalyzeSQLLineageRequest.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/AnalyzeSQLLineageRequest.h new file mode 100644 index 000000000..17e78d890 --- /dev/null +++ b/dms-enterprise/include/alibabacloud/dms-enterprise/model/AnalyzeSQLLineageRequest.h @@ -0,0 +1,48 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_DMS_ENTERPRISE_MODEL_ANALYZESQLLINEAGEREQUEST_H_ +#define ALIBABACLOUD_DMS_ENTERPRISE_MODEL_ANALYZESQLLINEAGEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Dms_enterprise { +namespace Model { +class ALIBABACLOUD_DMS_ENTERPRISE_EXPORT AnalyzeSQLLineageRequest : public RpcServiceRequest { +public: + AnalyzeSQLLineageRequest(); + ~AnalyzeSQLLineageRequest(); + std::string getSqlContent() const; + void setSqlContent(const std::string &sqlContent); + long getTid() const; + void setTid(long tid); + long getDbId() const; + void setDbId(long dbId); + +private: + std::string sqlContent_; + long tid_; + long dbId_; +}; +} // namespace Model +} // namespace Dms_enterprise +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_DMS_ENTERPRISE_MODEL_ANALYZESQLLINEAGEREQUEST_H_ diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/AnalyzeSQLLineageResult.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/AnalyzeSQLLineageResult.h new file mode 100644 index 000000000..ac4903e37 --- /dev/null +++ b/dms-enterprise/include/alibabacloud/dms-enterprise/model/AnalyzeSQLLineageResult.h @@ -0,0 +1,86 @@ +/* + * 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_DMS_ENTERPRISE_MODEL_ANALYZESQLLINEAGERESULT_H_ +#define ALIBABACLOUD_DMS_ENTERPRISE_MODEL_ANALYZESQLLINEAGERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dms_enterprise + { + namespace Model + { + class ALIBABACLOUD_DMS_ENTERPRISE_EXPORT AnalyzeSQLLineageResult : public ServiceResult + { + public: + struct LineageResult + { + struct LineageItem + { + struct ProcessDetail + { + std::string code; + std::string calWay; + }; + ProcessDetail processDetail; + std::string dst; + std::string src; + std::string operType; + std::string lineageType; + }; + struct ObjectMetadataItem + { + struct Field + { + std::string name; + }; + std::string type; + std::vector fields; + std::string source; + std::string name; + }; + std::vector lineages; + std::vector objectMetadata; + }; + + + AnalyzeSQLLineageResult(); + explicit AnalyzeSQLLineageResult(const std::string &payload); + ~AnalyzeSQLLineageResult(); + LineageResult getLineageResult()const; + std::string getErrorCode()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + LineageResult lineageResult_; + std::string errorCode_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DMS_ENTERPRISE_MODEL_ANALYZESQLLINEAGERESULT_H_ \ No newline at end of file diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/BackFillRequest.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/BackFillRequest.h index 12993367e..f12d7dd78 100644 --- a/dms-enterprise/include/alibabacloud/dms-enterprise/model/BackFillRequest.h +++ b/dms-enterprise/include/alibabacloud/dms-enterprise/model/BackFillRequest.h @@ -42,6 +42,8 @@ public: void setHistoryDagId(long historyDagId); std::vector getStartNodeIds() const; void setStartNodeIds(const std::vector &startNodeIds); + std::vector getFilterNodeIds() const; + void setFilterNodeIds(const std::vector &filterNodeIds); std::string getBackFillDateBegin() const; void setBackFillDateBegin(const std::string &backFillDateBegin); std::string getBackFillDate() const; @@ -58,6 +60,7 @@ private: std::string backFillDateEnd_; long historyDagId_; std::vector startNodeIds_; + std::vector filterNodeIds_; std::string backFillDateBegin_; std::string backFillDate_; bool asc_; diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/BackFillResult.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/BackFillResult.h index fbb164f94..ceb1c26be 100644 --- a/dms-enterprise/include/alibabacloud/dms-enterprise/model/BackFillResult.h +++ b/dms-enterprise/include/alibabacloud/dms-enterprise/model/BackFillResult.h @@ -40,6 +40,7 @@ namespace AlibabaCloud long getNodeId()const; std::string getErrorCode()const; std::string getErrorMessage()const; + long getDagInstanceId()const; bool getSuccess()const; protected: @@ -48,6 +49,7 @@ namespace AlibabaCloud long nodeId_; std::string errorCode_; std::string errorMessage_; + long dagInstanceId_; bool success_; }; diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/GetDataArchiveOrderDetailRequest.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/GetDataArchiveOrderDetailRequest.h new file mode 100644 index 000000000..33d94bf4c --- /dev/null +++ b/dms-enterprise/include/alibabacloud/dms-enterprise/model/GetDataArchiveOrderDetailRequest.h @@ -0,0 +1,45 @@ +/* + * 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_DMS_ENTERPRISE_MODEL_GETDATAARCHIVEORDERDETAILREQUEST_H_ +#define ALIBABACLOUD_DMS_ENTERPRISE_MODEL_GETDATAARCHIVEORDERDETAILREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace Dms_enterprise { +namespace Model { +class ALIBABACLOUD_DMS_ENTERPRISE_EXPORT GetDataArchiveOrderDetailRequest : public RpcServiceRequest { +public: + GetDataArchiveOrderDetailRequest(); + ~GetDataArchiveOrderDetailRequest(); + long getTid() const; + void setTid(long tid); + long getOrderId() const; + void setOrderId(long orderId); + +private: + long tid_; + long orderId_; +}; +} // namespace Model +} // namespace Dms_enterprise +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_DMS_ENTERPRISE_MODEL_GETDATAARCHIVEORDERDETAILREQUEST_H_ diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/GetDataArchiveOrderDetailResult.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/GetDataArchiveOrderDetailResult.h new file mode 100644 index 000000000..cb7327c64 --- /dev/null +++ b/dms-enterprise/include/alibabacloud/dms-enterprise/model/GetDataArchiveOrderDetailResult.h @@ -0,0 +1,192 @@ +/* + * 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_DMS_ENTERPRISE_MODEL_GETDATAARCHIVEORDERDETAILRESULT_H_ +#define ALIBABACLOUD_DMS_ENTERPRISE_MODEL_GETDATAARCHIVEORDERDETAILRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Dms_enterprise + { + namespace Model + { + class ALIBABACLOUD_DMS_ENTERPRISE_EXPORT GetDataArchiveOrderDetailResult : public ServiceResult + { + public: + struct DataArchiveOrderDetail + { + struct PluginExtraData + { + struct DagInfo + { + bool cronTrigger; + std::string description; + std::string creatorId; + bool legacy; + std::string dagOwnerId; + long deployId; + long editDagId; + std::string gmtModified; + bool dWDevelop; + bool triggerOnce; + std::string dagName; + bool system; + std::string gmtCreate; + std::string tenantId; + long isPublic; + std::string cronEndDate; + long id; + std::string cronBeginDate; + }; + struct DbBaseInfo + { + struct StandardGroup + { + std::string groupName; + std::string gmtCreate; + std::string description; + bool freeOrStable; + long lastMenderId; + std::string gmtModified; + std::string groupMode; + long id; + std::string dbType; + }; + long alterTimeout; + std::string description; + std::string searchName; + long port; + std::string idc; + std::string envType; + long dbaId; + bool follow; + std::string idcTitle; + std::string lastSyncTime; + std::string unitType; + long tableCount; + bool logic; + std::vector ownerIds; + bool assetControl; + std::string clusterNode; + StandardGroup standardGroup; + std::string instanceSource; + std::vector ownerNames; + long instanceId; + std::string encoding; + std::string host; + std::string dbType; + std::string dbaName; + std::string alias; + std::string state; + long dbId; + std::string catalogName; + std::string level; + std::string schemaName; + std::string tnsName; + }; + struct NextFireTimeResult + { + std::string cronFireType; + }; + struct InstancesItem + { + std::string msg; + long status; + long triggerType; + long historyDagId; + std::string endTime; + std::string gmtModified; + long dagId; + std::string gmtCreate; + std::string tenantId; + std::string lastRunningContext; + std::string version; + long id; + std::string businessTime; + }; + DbBaseInfo dbBaseInfo; + std::vector instances; + DagInfo dagInfo; + long instanceTotal; + long pageSize; + long pageIndex; + NextFireTimeResult nextFireTimeResult; + }; + struct PluginParam + { + struct IncludeTables + { + std::string tableName; + std::string tableWhere; + }; + std::string archiveMethod; + std::vector variables; + std::string runMethod; + std::vector orderAfter; + std::string dbSchema; + std::vector tableIncludes; + std::string targetInstanceId; + std::vector tableMapping; + bool logic; + long sourceDatabaseId; + }; + std::string comment; + std::string gmtModified; + PluginExtraData pluginExtraData; + long committerId; + std::string pluginType; + std::string statusCode; + std::vector relatedUserNickList; + PluginParam pluginParam; + std::string statusDesc; + std::string workflowStatusDesc; + std::string gmtCreate; + long workflowInstanceId; + std::string committer; + long id; + std::vector relatedUserList; + }; + + + GetDataArchiveOrderDetailResult(); + explicit GetDataArchiveOrderDetailResult(const std::string &payload); + ~GetDataArchiveOrderDetailResult(); + std::string getTraceId()const; + std::string getErrorCode()const; + DataArchiveOrderDetail getDataArchiveOrderDetail()const; + std::string getErrorMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string traceId_; + std::string errorCode_; + DataArchiveOrderDetail dataArchiveOrderDetail_; + std::string errorMessage_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_DMS_ENTERPRISE_MODEL_GETDATAARCHIVEORDERDETAILRESULT_H_ \ No newline at end of file diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowInstanceRequest.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowInstanceRequest.h index 7c5b36156..2c8db9931 100644 --- a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowInstanceRequest.h +++ b/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowInstanceRequest.h @@ -30,6 +30,8 @@ class ALIBABACLOUD_DMS_ENTERPRISE_EXPORT ListTaskFlowInstanceRequest : public Rp public: ListTaskFlowInstanceRequest(); ~ListTaskFlowInstanceRequest(); + bool getUseBizDate() const; + void setUseBizDate(bool useBizDate); int getTriggerType() const; void setTriggerType(int triggerType); long getDagId() const; @@ -44,8 +46,11 @@ public: void setStartTimeBegin(const std::string &startTimeBegin); std::string getStartTimeEnd() const; void setStartTimeEnd(const std::string &startTimeEnd); + int getStatus() const; + void setStatus(int status); private: + bool useBizDate_; int triggerType_; long dagId_; long tid_; @@ -53,6 +58,7 @@ private: int pageIndex_; std::string startTimeBegin_; std::string startTimeEnd_; + int status_; }; } // namespace Model } // namespace Dms_enterprise diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowInstanceResult.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowInstanceResult.h index d74783a75..a2ae64ad2 100644 --- a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowInstanceResult.h +++ b/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowInstanceResult.h @@ -40,6 +40,7 @@ namespace AlibabaCloud std::string ownerName; std::string endTime; std::string message; + std::string startTime; std::string dagVersion; long id; std::string dagName; diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowsByPageRequest.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowsByPageRequest.h index b03f4fecf..48ab8538f 100644 --- a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowsByPageRequest.h +++ b/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowsByPageRequest.h @@ -32,20 +32,26 @@ public: ~ListTaskFlowsByPageRequest(); std::string getSearchKey() const; void setSearchKey(const std::string &searchKey); + std::vector getDagIdList() const; + void setDagIdList(const std::vector &dagIdList); long getTid() const; void setTid(long tid); int getPageSize() const; void setPageSize(int pageSize); int getPageIndex() const; void setPageIndex(int pageIndex); + long getScenarioId() const; + void setScenarioId(long scenarioId); bool getNeedLastDagInstance() const; void setNeedLastDagInstance(bool needLastDagInstance); private: std::string searchKey_; + std::vector dagIdList_; long tid_; int pageSize_; int pageIndex_; + long scenarioId_; bool needLastDagInstance_; }; } // namespace Model diff --git a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowsByPageResult.h b/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowsByPageResult.h index bc5a680a9..c62f5ec75 100644 --- a/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowsByPageResult.h +++ b/dms-enterprise/include/alibabacloud/dms-enterprise/model/ListTaskFlowsByPageResult.h @@ -35,15 +35,22 @@ namespace AlibabaCloud struct TaskFlow { int status; - int latestInstanceStatus; std::string latestInstanceTime; + bool cronSwitch; + int triggerType; std::string description; + std::string scenarioId; std::string creatorId; long deployId; - long id; std::string dagName; - std::string creatorNickName; std::string dagOwnerNickName; + int latestInstanceStatus; + std::string cronParam; + std::string timeZoneId; + std::string cronStr; + long id; + std::string creatorNickName; + int cronType; }; diff --git a/dms-enterprise/src/Dms-enterpriseClient.cc b/dms-enterprise/src/Dms-enterpriseClient.cc index f81d71654..28a2c94c0 100644 --- a/dms-enterprise/src/Dms-enterpriseClient.cc +++ b/dms-enterprise/src/Dms-enterpriseClient.cc @@ -195,6 +195,42 @@ Dms_enterpriseClient::AddTaskFlowEdgesOutcomeCallable Dms_enterpriseClient::addT return task->get_future(); } +Dms_enterpriseClient::AnalyzeSQLLineageOutcome Dms_enterpriseClient::analyzeSQLLineage(const AnalyzeSQLLineageRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return AnalyzeSQLLineageOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return AnalyzeSQLLineageOutcome(AnalyzeSQLLineageResult(outcome.result())); + else + return AnalyzeSQLLineageOutcome(outcome.error()); +} + +void Dms_enterpriseClient::analyzeSQLLineageAsync(const AnalyzeSQLLineageRequest& request, const AnalyzeSQLLineageAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, analyzeSQLLineage(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Dms_enterpriseClient::AnalyzeSQLLineageOutcomeCallable Dms_enterpriseClient::analyzeSQLLineageCallable(const AnalyzeSQLLineageRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->analyzeSQLLineage(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Dms_enterpriseClient::ApproveOrderOutcome Dms_enterpriseClient::approveOrder(const ApproveOrderRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -2103,6 +2139,42 @@ Dms_enterpriseClient::GetDBTopologyOutcomeCallable Dms_enterpriseClient::getDBTo return task->get_future(); } +Dms_enterpriseClient::GetDataArchiveOrderDetailOutcome Dms_enterpriseClient::getDataArchiveOrderDetail(const GetDataArchiveOrderDetailRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetDataArchiveOrderDetailOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetDataArchiveOrderDetailOutcome(GetDataArchiveOrderDetailResult(outcome.result())); + else + return GetDataArchiveOrderDetailOutcome(outcome.error()); +} + +void Dms_enterpriseClient::getDataArchiveOrderDetailAsync(const GetDataArchiveOrderDetailRequest& request, const GetDataArchiveOrderDetailAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getDataArchiveOrderDetail(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Dms_enterpriseClient::GetDataArchiveOrderDetailOutcomeCallable Dms_enterpriseClient::getDataArchiveOrderDetailCallable(const GetDataArchiveOrderDetailRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getDataArchiveOrderDetail(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + Dms_enterpriseClient::GetDataCorrectBackupFilesOutcome Dms_enterpriseClient::getDataCorrectBackupFiles(const GetDataCorrectBackupFilesRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/dms-enterprise/src/model/AnalyzeSQLLineageRequest.cc b/dms-enterprise/src/model/AnalyzeSQLLineageRequest.cc new file mode 100644 index 000000000..95323100d --- /dev/null +++ b/dms-enterprise/src/model/AnalyzeSQLLineageRequest.cc @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Dms_enterprise::Model::AnalyzeSQLLineageRequest; + +AnalyzeSQLLineageRequest::AnalyzeSQLLineageRequest() + : RpcServiceRequest("dms-enterprise", "2018-11-01", "AnalyzeSQLLineage") { + setMethod(HttpRequest::Method::Post); +} + +AnalyzeSQLLineageRequest::~AnalyzeSQLLineageRequest() {} + +std::string AnalyzeSQLLineageRequest::getSqlContent() const { + return sqlContent_; +} + +void AnalyzeSQLLineageRequest::setSqlContent(const std::string &sqlContent) { + sqlContent_ = sqlContent; + setParameter(std::string("SqlContent"), sqlContent); +} + +long AnalyzeSQLLineageRequest::getTid() const { + return tid_; +} + +void AnalyzeSQLLineageRequest::setTid(long tid) { + tid_ = tid; + setParameter(std::string("Tid"), std::to_string(tid)); +} + +long AnalyzeSQLLineageRequest::getDbId() const { + return dbId_; +} + +void AnalyzeSQLLineageRequest::setDbId(long dbId) { + dbId_ = dbId; + setParameter(std::string("DbId"), std::to_string(dbId)); +} + diff --git a/dms-enterprise/src/model/AnalyzeSQLLineageResult.cc b/dms-enterprise/src/model/AnalyzeSQLLineageResult.cc new file mode 100644 index 000000000..ef0fdb970 --- /dev/null +++ b/dms-enterprise/src/model/AnalyzeSQLLineageResult.cc @@ -0,0 +1,110 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Dms_enterprise; +using namespace AlibabaCloud::Dms_enterprise::Model; + +AnalyzeSQLLineageResult::AnalyzeSQLLineageResult() : + ServiceResult() +{} + +AnalyzeSQLLineageResult::AnalyzeSQLLineageResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +AnalyzeSQLLineageResult::~AnalyzeSQLLineageResult() +{} + +void AnalyzeSQLLineageResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto lineageResultNode = value["LineageResult"]; + auto allLineagesNode = lineageResultNode["Lineages"]["LineageItem"]; + for (auto lineageResultNodeLineagesLineageItem : allLineagesNode) + { + LineageResult::LineageItem lineageItemObject; + if(!lineageResultNodeLineagesLineageItem["LineageType"].isNull()) + lineageItemObject.lineageType = lineageResultNodeLineagesLineageItem["LineageType"].asString(); + if(!lineageResultNodeLineagesLineageItem["Src"].isNull()) + lineageItemObject.src = lineageResultNodeLineagesLineageItem["Src"].asString(); + if(!lineageResultNodeLineagesLineageItem["Dst"].isNull()) + lineageItemObject.dst = lineageResultNodeLineagesLineageItem["Dst"].asString(); + if(!lineageResultNodeLineagesLineageItem["OperType"].isNull()) + lineageItemObject.operType = lineageResultNodeLineagesLineageItem["OperType"].asString(); + auto processDetailNode = value["ProcessDetail"]; + if(!processDetailNode["Code"].isNull()) + lineageItemObject.processDetail.code = processDetailNode["Code"].asString(); + if(!processDetailNode["CalWay"].isNull()) + lineageItemObject.processDetail.calWay = processDetailNode["CalWay"].asString(); + lineageResult_.lineages.push_back(lineageItemObject); + } + auto allObjectMetadataNode = lineageResultNode["ObjectMetadata"]["ObjectMetadataItem"]; + for (auto lineageResultNodeObjectMetadataObjectMetadataItem : allObjectMetadataNode) + { + LineageResult::ObjectMetadataItem objectMetadataItemObject; + if(!lineageResultNodeObjectMetadataObjectMetadataItem["Name"].isNull()) + objectMetadataItemObject.name = lineageResultNodeObjectMetadataObjectMetadataItem["Name"].asString(); + if(!lineageResultNodeObjectMetadataObjectMetadataItem["Type"].isNull()) + objectMetadataItemObject.type = lineageResultNodeObjectMetadataObjectMetadataItem["Type"].asString(); + if(!lineageResultNodeObjectMetadataObjectMetadataItem["Source"].isNull()) + objectMetadataItemObject.source = lineageResultNodeObjectMetadataObjectMetadataItem["Source"].asString(); + auto allFieldsNode = lineageResultNodeObjectMetadataObjectMetadataItem["Fields"]["Field"]; + for (auto lineageResultNodeObjectMetadataObjectMetadataItemFieldsField : allFieldsNode) + { + LineageResult::ObjectMetadataItem::Field fieldsObject; + if(!lineageResultNodeObjectMetadataObjectMetadataItemFieldsField["Name"].isNull()) + fieldsObject.name = lineageResultNodeObjectMetadataObjectMetadataItemFieldsField["Name"].asString(); + objectMetadataItemObject.fields.push_back(fieldsObject); + } + lineageResult_.objectMetadata.push_back(objectMetadataItemObject); + } + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + +} + +AnalyzeSQLLineageResult::LineageResult AnalyzeSQLLineageResult::getLineageResult()const +{ + return lineageResult_; +} + +std::string AnalyzeSQLLineageResult::getErrorCode()const +{ + return errorCode_; +} + +std::string AnalyzeSQLLineageResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool AnalyzeSQLLineageResult::getSuccess()const +{ + return success_; +} + diff --git a/dms-enterprise/src/model/BackFillRequest.cc b/dms-enterprise/src/model/BackFillRequest.cc index a2477f88f..68e70e434 100644 --- a/dms-enterprise/src/model/BackFillRequest.cc +++ b/dms-enterprise/src/model/BackFillRequest.cc @@ -81,6 +81,17 @@ void BackFillRequest::setStartNodeIds(const std::vector & } } +std::vector BackFillRequest::getFilterNodeIds() const { + return filterNodeIds_; +} + +void BackFillRequest::setFilterNodeIds(const std::vector &filterNodeIds) { + filterNodeIds_ = filterNodeIds; + for(int dep1 = 0; dep1 != filterNodeIds.size(); dep1++) { + setParameter(std::string("FilterNodeIds") + "." + std::to_string(dep1 + 1), std::to_string(filterNodeIds[dep1])); + } +} + std::string BackFillRequest::getBackFillDateBegin() const { return backFillDateBegin_; } diff --git a/dms-enterprise/src/model/BackFillResult.cc b/dms-enterprise/src/model/BackFillResult.cc index 6d93ce2b2..632f8e9e7 100644 --- a/dms-enterprise/src/model/BackFillResult.cc +++ b/dms-enterprise/src/model/BackFillResult.cc @@ -45,6 +45,8 @@ void BackFillResult::parse(const std::string &payload) errorMessage_ = value["ErrorMessage"].asString(); if(!value["Success"].isNull()) success_ = value["Success"].asString() == "true"; + if(!value["DagInstanceId"].isNull()) + dagInstanceId_ = std::stol(value["DagInstanceId"].asString()); if(!value["NodeId"].isNull()) nodeId_ = std::stol(value["NodeId"].asString()); @@ -65,6 +67,11 @@ std::string BackFillResult::getErrorMessage()const return errorMessage_; } +long BackFillResult::getDagInstanceId()const +{ + return dagInstanceId_; +} + bool BackFillResult::getSuccess()const { return success_; diff --git a/dms-enterprise/src/model/GetDataArchiveOrderDetailRequest.cc b/dms-enterprise/src/model/GetDataArchiveOrderDetailRequest.cc new file mode 100644 index 000000000..628f6fbb2 --- /dev/null +++ b/dms-enterprise/src/model/GetDataArchiveOrderDetailRequest.cc @@ -0,0 +1,45 @@ +/* + * 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::Dms_enterprise::Model::GetDataArchiveOrderDetailRequest; + +GetDataArchiveOrderDetailRequest::GetDataArchiveOrderDetailRequest() + : RpcServiceRequest("dms-enterprise", "2018-11-01", "GetDataArchiveOrderDetail") { + setMethod(HttpRequest::Method::Post); +} + +GetDataArchiveOrderDetailRequest::~GetDataArchiveOrderDetailRequest() {} + +long GetDataArchiveOrderDetailRequest::getTid() const { + return tid_; +} + +void GetDataArchiveOrderDetailRequest::setTid(long tid) { + tid_ = tid; + setParameter(std::string("Tid"), std::to_string(tid)); +} + +long GetDataArchiveOrderDetailRequest::getOrderId() const { + return orderId_; +} + +void GetDataArchiveOrderDetailRequest::setOrderId(long orderId) { + orderId_ = orderId; + setParameter(std::string("OrderId"), std::to_string(orderId)); +} + diff --git a/dms-enterprise/src/model/GetDataArchiveOrderDetailResult.cc b/dms-enterprise/src/model/GetDataArchiveOrderDetailResult.cc new file mode 100644 index 000000000..83f1d307c --- /dev/null +++ b/dms-enterprise/src/model/GetDataArchiveOrderDetailResult.cc @@ -0,0 +1,299 @@ +/* + * 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::Dms_enterprise; +using namespace AlibabaCloud::Dms_enterprise::Model; + +GetDataArchiveOrderDetailResult::GetDataArchiveOrderDetailResult() : + ServiceResult() +{} + +GetDataArchiveOrderDetailResult::GetDataArchiveOrderDetailResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetDataArchiveOrderDetailResult::~GetDataArchiveOrderDetailResult() +{} + +void GetDataArchiveOrderDetailResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataArchiveOrderDetailNode = value["DataArchiveOrderDetail"]; + if(!dataArchiveOrderDetailNode["Comment"].isNull()) + dataArchiveOrderDetail_.comment = dataArchiveOrderDetailNode["Comment"].asString(); + if(!dataArchiveOrderDetailNode["Committer"].isNull()) + dataArchiveOrderDetail_.committer = dataArchiveOrderDetailNode["Committer"].asString(); + if(!dataArchiveOrderDetailNode["CommitterId"].isNull()) + dataArchiveOrderDetail_.committerId = std::stol(dataArchiveOrderDetailNode["CommitterId"].asString()); + if(!dataArchiveOrderDetailNode["GmtCreate"].isNull()) + dataArchiveOrderDetail_.gmtCreate = dataArchiveOrderDetailNode["GmtCreate"].asString(); + if(!dataArchiveOrderDetailNode["GmtModified"].isNull()) + dataArchiveOrderDetail_.gmtModified = dataArchiveOrderDetailNode["GmtModified"].asString(); + if(!dataArchiveOrderDetailNode["Id"].isNull()) + dataArchiveOrderDetail_.id = std::stol(dataArchiveOrderDetailNode["Id"].asString()); + if(!dataArchiveOrderDetailNode["PluginType"].isNull()) + dataArchiveOrderDetail_.pluginType = dataArchiveOrderDetailNode["PluginType"].asString(); + if(!dataArchiveOrderDetailNode["StatusCode"].isNull()) + dataArchiveOrderDetail_.statusCode = dataArchiveOrderDetailNode["StatusCode"].asString(); + if(!dataArchiveOrderDetailNode["StatusDesc"].isNull()) + dataArchiveOrderDetail_.statusDesc = dataArchiveOrderDetailNode["StatusDesc"].asString(); + if(!dataArchiveOrderDetailNode["WorkflowInstanceId"].isNull()) + dataArchiveOrderDetail_.workflowInstanceId = std::stol(dataArchiveOrderDetailNode["WorkflowInstanceId"].asString()); + if(!dataArchiveOrderDetailNode["WorkflowStatusDesc"].isNull()) + dataArchiveOrderDetail_.workflowStatusDesc = dataArchiveOrderDetailNode["WorkflowStatusDesc"].asString(); + auto pluginExtraDataNode = dataArchiveOrderDetailNode["PluginExtraData"]; + if(!pluginExtraDataNode["InstanceTotal"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.instanceTotal = std::stol(pluginExtraDataNode["InstanceTotal"].asString()); + if(!pluginExtraDataNode["PageIndex"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.pageIndex = std::stol(pluginExtraDataNode["PageIndex"].asString()); + if(!pluginExtraDataNode["PageSize"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.pageSize = std::stol(pluginExtraDataNode["PageSize"].asString()); + auto allInstancesNode = pluginExtraDataNode["Instances"]["InstancesItem"]; + for (auto pluginExtraDataNodeInstancesInstancesItem : allInstancesNode) + { + DataArchiveOrderDetail::PluginExtraData::InstancesItem instancesItemObject; + if(!pluginExtraDataNodeInstancesInstancesItem["BusinessTime"].isNull()) + instancesItemObject.businessTime = pluginExtraDataNodeInstancesInstancesItem["BusinessTime"].asString(); + if(!pluginExtraDataNodeInstancesInstancesItem["DagId"].isNull()) + instancesItemObject.dagId = std::stol(pluginExtraDataNodeInstancesInstancesItem["DagId"].asString()); + if(!pluginExtraDataNodeInstancesInstancesItem["EndTime"].isNull()) + instancesItemObject.endTime = pluginExtraDataNodeInstancesInstancesItem["EndTime"].asString(); + if(!pluginExtraDataNodeInstancesInstancesItem["GmtCreate"].isNull()) + instancesItemObject.gmtCreate = pluginExtraDataNodeInstancesInstancesItem["GmtCreate"].asString(); + if(!pluginExtraDataNodeInstancesInstancesItem["GmtModified"].isNull()) + instancesItemObject.gmtModified = pluginExtraDataNodeInstancesInstancesItem["GmtModified"].asString(); + if(!pluginExtraDataNodeInstancesInstancesItem["HistoryDagId"].isNull()) + instancesItemObject.historyDagId = std::stol(pluginExtraDataNodeInstancesInstancesItem["HistoryDagId"].asString()); + if(!pluginExtraDataNodeInstancesInstancesItem["Id"].isNull()) + instancesItemObject.id = std::stol(pluginExtraDataNodeInstancesInstancesItem["Id"].asString()); + if(!pluginExtraDataNodeInstancesInstancesItem["LastRunningContext"].isNull()) + instancesItemObject.lastRunningContext = pluginExtraDataNodeInstancesInstancesItem["LastRunningContext"].asString(); + if(!pluginExtraDataNodeInstancesInstancesItem["Msg"].isNull()) + instancesItemObject.msg = pluginExtraDataNodeInstancesInstancesItem["Msg"].asString(); + if(!pluginExtraDataNodeInstancesInstancesItem["Status"].isNull()) + instancesItemObject.status = std::stol(pluginExtraDataNodeInstancesInstancesItem["Status"].asString()); + if(!pluginExtraDataNodeInstancesInstancesItem["TenantId"].isNull()) + instancesItemObject.tenantId = pluginExtraDataNodeInstancesInstancesItem["TenantId"].asString(); + if(!pluginExtraDataNodeInstancesInstancesItem["TriggerType"].isNull()) + instancesItemObject.triggerType = std::stol(pluginExtraDataNodeInstancesInstancesItem["TriggerType"].asString()); + if(!pluginExtraDataNodeInstancesInstancesItem["Version"].isNull()) + instancesItemObject.version = pluginExtraDataNodeInstancesInstancesItem["Version"].asString(); + dataArchiveOrderDetail_.pluginExtraData.instances.push_back(instancesItemObject); + } + auto dagInfoNode = pluginExtraDataNode["DagInfo"]; + if(!dagInfoNode["CreatorId"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.creatorId = dagInfoNode["CreatorId"].asString(); + if(!dagInfoNode["CronBeginDate"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.cronBeginDate = dagInfoNode["CronBeginDate"].asString(); + if(!dagInfoNode["CronEndDate"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.cronEndDate = dagInfoNode["CronEndDate"].asString(); + if(!dagInfoNode["CronTrigger"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.cronTrigger = dagInfoNode["CronTrigger"].asString() == "true"; + if(!dagInfoNode["DWDevelop"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.dWDevelop = dagInfoNode["DWDevelop"].asString() == "true"; + if(!dagInfoNode["DagName"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.dagName = dagInfoNode["DagName"].asString(); + if(!dagInfoNode["DagOwnerId"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.dagOwnerId = dagInfoNode["DagOwnerId"].asString(); + if(!dagInfoNode["DeployId"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.deployId = std::stol(dagInfoNode["DeployId"].asString()); + if(!dagInfoNode["Description"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.description = dagInfoNode["Description"].asString(); + if(!dagInfoNode["EditDagId"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.editDagId = std::stol(dagInfoNode["EditDagId"].asString()); + if(!dagInfoNode["GmtCreate"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.gmtCreate = dagInfoNode["GmtCreate"].asString(); + if(!dagInfoNode["GmtModified"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.gmtModified = dagInfoNode["GmtModified"].asString(); + if(!dagInfoNode["Id"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.id = std::stol(dagInfoNode["Id"].asString()); + if(!dagInfoNode["IsPublic"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.isPublic = std::stol(dagInfoNode["IsPublic"].asString()); + if(!dagInfoNode["Legacy"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.legacy = dagInfoNode["Legacy"].asString() == "true"; + if(!dagInfoNode["System"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.system = dagInfoNode["System"].asString() == "true"; + if(!dagInfoNode["TenantId"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.tenantId = dagInfoNode["TenantId"].asString(); + if(!dagInfoNode["TriggerOnce"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dagInfo.triggerOnce = dagInfoNode["TriggerOnce"].asString() == "true"; + auto dbBaseInfoNode = pluginExtraDataNode["DbBaseInfo"]; + if(!dbBaseInfoNode["Alias"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.alias = dbBaseInfoNode["Alias"].asString(); + if(!dbBaseInfoNode["AlterTimeout"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.alterTimeout = std::stol(dbBaseInfoNode["AlterTimeout"].asString()); + if(!dbBaseInfoNode["AssetControl"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.assetControl = dbBaseInfoNode["AssetControl"].asString() == "true"; + if(!dbBaseInfoNode["CatalogName"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.catalogName = dbBaseInfoNode["CatalogName"].asString(); + if(!dbBaseInfoNode["ClusterNode"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.clusterNode = dbBaseInfoNode["ClusterNode"].asString(); + if(!dbBaseInfoNode["DbId"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.dbId = std::stol(dbBaseInfoNode["DbId"].asString()); + if(!dbBaseInfoNode["DbType"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.dbType = dbBaseInfoNode["DbType"].asString(); + if(!dbBaseInfoNode["DbaId"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.dbaId = std::stol(dbBaseInfoNode["DbaId"].asString()); + if(!dbBaseInfoNode["DbaName"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.dbaName = dbBaseInfoNode["DbaName"].asString(); + if(!dbBaseInfoNode["Description"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.description = dbBaseInfoNode["Description"].asString(); + if(!dbBaseInfoNode["Encoding"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.encoding = dbBaseInfoNode["Encoding"].asString(); + if(!dbBaseInfoNode["EnvType"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.envType = dbBaseInfoNode["EnvType"].asString(); + if(!dbBaseInfoNode["Follow"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.follow = dbBaseInfoNode["Follow"].asString() == "true"; + if(!dbBaseInfoNode["Host"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.host = dbBaseInfoNode["Host"].asString(); + if(!dbBaseInfoNode["Idc"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.idc = dbBaseInfoNode["Idc"].asString(); + if(!dbBaseInfoNode["IdcTitle"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.idcTitle = dbBaseInfoNode["IdcTitle"].asString(); + if(!dbBaseInfoNode["InstanceId"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.instanceId = std::stol(dbBaseInfoNode["InstanceId"].asString()); + if(!dbBaseInfoNode["InstanceSource"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.instanceSource = dbBaseInfoNode["InstanceSource"].asString(); + if(!dbBaseInfoNode["LastSyncTime"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.lastSyncTime = dbBaseInfoNode["LastSyncTime"].asString(); + if(!dbBaseInfoNode["Level"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.level = dbBaseInfoNode["Level"].asString(); + if(!dbBaseInfoNode["Logic"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.logic = dbBaseInfoNode["Logic"].asString() == "true"; + if(!dbBaseInfoNode["Port"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.port = std::stol(dbBaseInfoNode["Port"].asString()); + if(!dbBaseInfoNode["SchemaName"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.schemaName = dbBaseInfoNode["SchemaName"].asString(); + if(!dbBaseInfoNode["SearchName"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.searchName = dbBaseInfoNode["SearchName"].asString(); + if(!dbBaseInfoNode["State"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.state = dbBaseInfoNode["State"].asString(); + if(!dbBaseInfoNode["TableCount"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.tableCount = std::stol(dbBaseInfoNode["TableCount"].asString()); + if(!dbBaseInfoNode["TnsName"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.tnsName = dbBaseInfoNode["TnsName"].asString(); + if(!dbBaseInfoNode["UnitType"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.unitType = dbBaseInfoNode["UnitType"].asString(); + auto standardGroupNode = dbBaseInfoNode["StandardGroup"]; + if(!standardGroupNode["DbType"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.standardGroup.dbType = standardGroupNode["DbType"].asString(); + if(!standardGroupNode["Description"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.standardGroup.description = standardGroupNode["Description"].asString(); + if(!standardGroupNode["FreeOrStable"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.standardGroup.freeOrStable = standardGroupNode["FreeOrStable"].asString() == "true"; + if(!standardGroupNode["GmtCreate"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.standardGroup.gmtCreate = standardGroupNode["GmtCreate"].asString(); + if(!standardGroupNode["GmtModified"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.standardGroup.gmtModified = standardGroupNode["GmtModified"].asString(); + if(!standardGroupNode["GroupMode"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.standardGroup.groupMode = standardGroupNode["GroupMode"].asString(); + if(!standardGroupNode["GroupName"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.standardGroup.groupName = standardGroupNode["GroupName"].asString(); + if(!standardGroupNode["Id"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.standardGroup.id = std::stol(standardGroupNode["Id"].asString()); + if(!standardGroupNode["LastMenderId"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.standardGroup.lastMenderId = std::stol(standardGroupNode["LastMenderId"].asString()); + auto allOwnerIds = dbBaseInfoNode["OwnerIds"]["OwnerIds"]; + for (auto value : allOwnerIds) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.ownerIds.push_back(value.asString()); + auto allOwnerNames = dbBaseInfoNode["OwnerNames"]["OwnerNames"]; + for (auto value : allOwnerNames) + dataArchiveOrderDetail_.pluginExtraData.dbBaseInfo.ownerNames.push_back(value.asString()); + auto nextFireTimeResultNode = pluginExtraDataNode["NextFireTimeResult"]; + if(!nextFireTimeResultNode["CronFireType"].isNull()) + dataArchiveOrderDetail_.pluginExtraData.nextFireTimeResult.cronFireType = nextFireTimeResultNode["CronFireType"].asString(); + auto pluginParamNode = dataArchiveOrderDetailNode["PluginParam"]; + if(!pluginParamNode["ArchiveMethod"].isNull()) + dataArchiveOrderDetail_.pluginParam.archiveMethod = pluginParamNode["ArchiveMethod"].asString(); + if(!pluginParamNode["DbSchema"].isNull()) + dataArchiveOrderDetail_.pluginParam.dbSchema = pluginParamNode["DbSchema"].asString(); + if(!pluginParamNode["Logic"].isNull()) + dataArchiveOrderDetail_.pluginParam.logic = pluginParamNode["Logic"].asString() == "true"; + if(!pluginParamNode["RunMethod"].isNull()) + dataArchiveOrderDetail_.pluginParam.runMethod = pluginParamNode["RunMethod"].asString(); + if(!pluginParamNode["SourceDatabaseId"].isNull()) + dataArchiveOrderDetail_.pluginParam.sourceDatabaseId = std::stol(pluginParamNode["SourceDatabaseId"].asString()); + if(!pluginParamNode["TargetInstanceId"].isNull()) + dataArchiveOrderDetail_.pluginParam.targetInstanceId = pluginParamNode["TargetInstanceId"].asString(); + auto allTableIncludesNode = pluginParamNode["TableIncludes"]["IncludeTables"]; + for (auto pluginParamNodeTableIncludesIncludeTables : allTableIncludesNode) + { + DataArchiveOrderDetail::PluginParam::IncludeTables includeTablesObject; + if(!pluginParamNodeTableIncludesIncludeTables["TableName"].isNull()) + includeTablesObject.tableName = pluginParamNodeTableIncludesIncludeTables["TableName"].asString(); + if(!pluginParamNodeTableIncludesIncludeTables["TableWhere"].isNull()) + includeTablesObject.tableWhere = pluginParamNodeTableIncludesIncludeTables["TableWhere"].asString(); + dataArchiveOrderDetail_.pluginParam.tableIncludes.push_back(includeTablesObject); + } + auto allOrderAfter = pluginParamNode["OrderAfter"]["AfterOrder"]; + for (auto value : allOrderAfter) + dataArchiveOrderDetail_.pluginParam.orderAfter.push_back(value.asString()); + auto allTableMapping = pluginParamNode["TableMapping"]["MappingTable"]; + for (auto value : allTableMapping) + dataArchiveOrderDetail_.pluginParam.tableMapping.push_back(value.asString()); + auto allVariables = pluginParamNode["Variables"]["Variables"]; + for (auto value : allVariables) + dataArchiveOrderDetail_.pluginParam.variables.push_back(value.asString()); + auto allRelatedUserList = dataArchiveOrderDetailNode["RelatedUserList"]["RelatedUserList"]; + for (auto value : allRelatedUserList) + dataArchiveOrderDetail_.relatedUserList.push_back(value.asString()); + auto allRelatedUserNickList = dataArchiveOrderDetailNode["RelatedUserNickList"]["RelatedUserNickList"]; + for (auto value : allRelatedUserNickList) + dataArchiveOrderDetail_.relatedUserNickList.push_back(value.asString()); + if(!value["TraceId"].isNull()) + traceId_ = value["TraceId"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["ErrorMessage"].isNull()) + errorMessage_ = value["ErrorMessage"].asString(); + if(!value["ErrorCode"].isNull()) + errorCode_ = value["ErrorCode"].asString(); + +} + +std::string GetDataArchiveOrderDetailResult::getTraceId()const +{ + return traceId_; +} + +std::string GetDataArchiveOrderDetailResult::getErrorCode()const +{ + return errorCode_; +} + +GetDataArchiveOrderDetailResult::DataArchiveOrderDetail GetDataArchiveOrderDetailResult::getDataArchiveOrderDetail()const +{ + return dataArchiveOrderDetail_; +} + +std::string GetDataArchiveOrderDetailResult::getErrorMessage()const +{ + return errorMessage_; +} + +bool GetDataArchiveOrderDetailResult::getSuccess()const +{ + return success_; +} + diff --git a/dms-enterprise/src/model/ListTaskFlowInstanceRequest.cc b/dms-enterprise/src/model/ListTaskFlowInstanceRequest.cc index b1c7f283f..fe2283c17 100644 --- a/dms-enterprise/src/model/ListTaskFlowInstanceRequest.cc +++ b/dms-enterprise/src/model/ListTaskFlowInstanceRequest.cc @@ -25,6 +25,15 @@ ListTaskFlowInstanceRequest::ListTaskFlowInstanceRequest() ListTaskFlowInstanceRequest::~ListTaskFlowInstanceRequest() {} +bool ListTaskFlowInstanceRequest::getUseBizDate() const { + return useBizDate_; +} + +void ListTaskFlowInstanceRequest::setUseBizDate(bool useBizDate) { + useBizDate_ = useBizDate; + setParameter(std::string("UseBizDate"), useBizDate ? "true" : "false"); +} + int ListTaskFlowInstanceRequest::getTriggerType() const { return triggerType_; } @@ -88,3 +97,12 @@ void ListTaskFlowInstanceRequest::setStartTimeEnd(const std::string &startTimeEn setParameter(std::string("StartTimeEnd"), startTimeEnd); } +int ListTaskFlowInstanceRequest::getStatus() const { + return status_; +} + +void ListTaskFlowInstanceRequest::setStatus(int status) { + status_ = status; + setParameter(std::string("Status"), std::to_string(status)); +} + diff --git a/dms-enterprise/src/model/ListTaskFlowInstanceResult.cc b/dms-enterprise/src/model/ListTaskFlowInstanceResult.cc index 790254a73..dba2033d0 100644 --- a/dms-enterprise/src/model/ListTaskFlowInstanceResult.cc +++ b/dms-enterprise/src/model/ListTaskFlowInstanceResult.cc @@ -47,6 +47,8 @@ void ListTaskFlowInstanceResult::parse(const std::string &payload) dAGInstanceListObject.id = std::stol(valueDAGInstanceListDAGInstance["Id"].asString()); if(!valueDAGInstanceListDAGInstance["BusinessTime"].isNull()) dAGInstanceListObject.businessTime = valueDAGInstanceListDAGInstance["BusinessTime"].asString(); + if(!valueDAGInstanceListDAGInstance["startTime"].isNull()) + dAGInstanceListObject.startTime = valueDAGInstanceListDAGInstance["startTime"].asString(); if(!valueDAGInstanceListDAGInstance["EndTime"].isNull()) dAGInstanceListObject.endTime = valueDAGInstanceListDAGInstance["EndTime"].asString(); if(!valueDAGInstanceListDAGInstance["DagId"].isNull()) diff --git a/dms-enterprise/src/model/ListTaskFlowsByPageRequest.cc b/dms-enterprise/src/model/ListTaskFlowsByPageRequest.cc index b365cab97..568a02060 100644 --- a/dms-enterprise/src/model/ListTaskFlowsByPageRequest.cc +++ b/dms-enterprise/src/model/ListTaskFlowsByPageRequest.cc @@ -34,6 +34,17 @@ void ListTaskFlowsByPageRequest::setSearchKey(const std::string &searchKey) { setParameter(std::string("SearchKey"), searchKey); } +std::vector ListTaskFlowsByPageRequest::getDagIdList() const { + return dagIdList_; +} + +void ListTaskFlowsByPageRequest::setDagIdList(const std::vector &dagIdList) { + dagIdList_ = dagIdList; + for(int dep1 = 0; dep1 != dagIdList.size(); dep1++) { + setParameter(std::string("DagIdList") + "." + std::to_string(dep1 + 1), std::to_string(dagIdList[dep1])); + } +} + long ListTaskFlowsByPageRequest::getTid() const { return tid_; } @@ -61,6 +72,15 @@ void ListTaskFlowsByPageRequest::setPageIndex(int pageIndex) { setParameter(std::string("PageIndex"), std::to_string(pageIndex)); } +long ListTaskFlowsByPageRequest::getScenarioId() const { + return scenarioId_; +} + +void ListTaskFlowsByPageRequest::setScenarioId(long scenarioId) { + scenarioId_ = scenarioId; + setParameter(std::string("ScenarioId"), std::to_string(scenarioId)); +} + bool ListTaskFlowsByPageRequest::getNeedLastDagInstance() const { return needLastDagInstance_; } diff --git a/dms-enterprise/src/model/ListTaskFlowsByPageResult.cc b/dms-enterprise/src/model/ListTaskFlowsByPageResult.cc index 10909c93b..7027244bc 100644 --- a/dms-enterprise/src/model/ListTaskFlowsByPageResult.cc +++ b/dms-enterprise/src/model/ListTaskFlowsByPageResult.cc @@ -63,6 +63,20 @@ void ListTaskFlowsByPageResult::parse(const std::string &payload) taskFlowListObject.latestInstanceStatus = std::stoi(valueTaskFlowListTaskFlow["LatestInstanceStatus"].asString()); if(!valueTaskFlowListTaskFlow["LatestInstanceTime"].isNull()) taskFlowListObject.latestInstanceTime = valueTaskFlowListTaskFlow["LatestInstanceTime"].asString(); + if(!valueTaskFlowListTaskFlow["ScenarioId"].isNull()) + taskFlowListObject.scenarioId = valueTaskFlowListTaskFlow["ScenarioId"].asString(); + if(!valueTaskFlowListTaskFlow["CronSwitch"].isNull()) + taskFlowListObject.cronSwitch = valueTaskFlowListTaskFlow["CronSwitch"].asString() == "true"; + if(!valueTaskFlowListTaskFlow["CronStr"].isNull()) + taskFlowListObject.cronStr = valueTaskFlowListTaskFlow["CronStr"].asString(); + if(!valueTaskFlowListTaskFlow["CronParam"].isNull()) + taskFlowListObject.cronParam = valueTaskFlowListTaskFlow["CronParam"].asString(); + if(!valueTaskFlowListTaskFlow["TriggerType"].isNull()) + taskFlowListObject.triggerType = std::stoi(valueTaskFlowListTaskFlow["TriggerType"].asString()); + if(!valueTaskFlowListTaskFlow["CronType"].isNull()) + taskFlowListObject.cronType = std::stoi(valueTaskFlowListTaskFlow["CronType"].asString()); + if(!valueTaskFlowListTaskFlow["TimeZoneId"].isNull()) + taskFlowListObject.timeZoneId = valueTaskFlowListTaskFlow["TimeZoneId"].asString(); taskFlowList_.push_back(taskFlowListObject); } if(!value["ErrorCode"].isNull())