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

Generated 2020-05-18 for dataworks-public.

Browse Source
This commit is contained in:
sdk-team
2020-12-03 07:29:53 +00:00
parent 423e3b65e3
commit 2acf4250c6
44 changed files with 1798 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
dataworks-public/CMakeLists.txt
View File

@@ -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

40
dataworks-public/include/alibabacloud/dataworks-public/Dataworks_publicClient.h
View File

@@ -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<Error, Model::CreateFolderResult> CreateFolderOutcome;
typedef std::future<CreateFolderOutcome> CreateFolderOutcomeCallable;
typedef std::function<void(const Dataworks_publicClient*, const Model::CreateFolderRequest&, const CreateFolderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFolderAsyncHandler;
typedef Outcome<Error, Model::CreateManualDagResult> CreateManualDagOutcome;
typedef std::future<CreateManualDagOutcome> CreateManualDagOutcomeCallable;
typedef std::function<void(const Dataworks_publicClient*, const Model::CreateManualDagRequest&, const CreateManualDagOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateManualDagAsyncHandler;
typedef Outcome<Error, Model::CreateMetaCategoryResult> CreateMetaCategoryOutcome;
typedef std::future<CreateMetaCategoryOutcome> CreateMetaCategoryOutcomeCallable;
typedef std::function<void(const Dataworks_publicClient*, const Model::CreateMetaCategoryRequest&, const CreateMetaCategoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMetaCategoryAsyncHandler;
@@ -470,6 +483,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::GetDDLJobStatusResult> GetDDLJobStatusOutcome;
typedef std::future<GetDDLJobStatusOutcome> GetDDLJobStatusOutcomeCallable;
typedef std::function<void(const Dataworks_publicClient*, const Model::GetDDLJobStatusRequest&, const GetDDLJobStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDDLJobStatusAsyncHandler;
typedef Outcome<Error, Model::GetDagResult> GetDagOutcome;
typedef std::future<GetDagOutcome> GetDagOutcomeCallable;
typedef std::function<void(const Dataworks_publicClient*, const Model::GetDagRequest&, const GetDagOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDagAsyncHandler;
typedef Outcome<Error, Model::GetDataServiceApiResult> GetDataServiceApiOutcome;
typedef std::future<GetDataServiceApiOutcome> GetDataServiceApiOutcomeCallable;
typedef std::function<void(const Dataworks_publicClient*, const Model::GetDataServiceApiRequest&, const GetDataServiceApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDataServiceApiAsyncHandler;
@@ -515,6 +531,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::GetInstanceStatusCountResult> GetInstanceStatusCountOutcome;
typedef std::future<GetInstanceStatusCountOutcome> GetInstanceStatusCountOutcomeCallable;
typedef std::function<void(const Dataworks_publicClient*, const Model::GetInstanceStatusCountRequest&, const GetInstanceStatusCountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInstanceStatusCountAsyncHandler;
typedef Outcome<Error, Model::GetManualDagInstancesResult> GetManualDagInstancesOutcome;
typedef std::future<GetManualDagInstancesOutcome> GetManualDagInstancesOutcomeCallable;
typedef std::function<void(const Dataworks_publicClient*, const Model::GetManualDagInstancesRequest&, const GetManualDagInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetManualDagInstancesAsyncHandler;
typedef Outcome<Error, Model::GetMetaCategoryResult> GetMetaCategoryOutcome;
typedef std::future<GetMetaCategoryOutcome> GetMetaCategoryOutcomeCallable;
typedef std::function<void(const Dataworks_publicClient*, const Model::GetMetaCategoryRequest&, const GetMetaCategoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMetaCategoryAsyncHandler;
@@ -698,9 +717,15 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ResumeInstanceResult> ResumeInstanceOutcome;
typedef std::future<ResumeInstanceOutcome> ResumeInstanceOutcomeCallable;
typedef std::function<void(const Dataworks_publicClient*, const Model::ResumeInstanceRequest&, const ResumeInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResumeInstanceAsyncHandler;
typedef Outcome<Error, Model::RunTriggerNodeResult> RunTriggerNodeOutcome;
typedef std::future<RunTriggerNodeOutcome> RunTriggerNodeOutcomeCallable;
typedef std::function<void(const Dataworks_publicClient*, const Model::RunTriggerNodeRequest&, const RunTriggerNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RunTriggerNodeAsyncHandler;
typedef Outcome<Error, Model::SearchMetaTablesResult> SearchMetaTablesOutcome;
typedef std::future<SearchMetaTablesOutcome> SearchMetaTablesOutcomeCallable;
typedef std::function<void(const Dataworks_publicClient*, const Model::SearchMetaTablesRequest&, const SearchMetaTablesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchMetaTablesAsyncHandler;
typedef Outcome<Error, Model::SearchNodesByOutputResult> SearchNodesByOutputOutcome;
typedef std::future<SearchNodesByOutputOutcome> SearchNodesByOutputOutcomeCallable;
typedef std::function<void(const Dataworks_publicClient*, const Model::SearchNodesByOutputRequest&, const SearchNodesByOutputOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchNodesByOutputAsyncHandler;
typedef Outcome<Error, Model::SetSuccessInstanceResult> SetSuccessInstanceOutcome;
typedef std::future<SetSuccessInstanceOutcome> SetSuccessInstanceOutcomeCallable;
typedef std::function<void(const Dataworks_publicClient*, const Model::SetSuccessInstanceRequest&, const SetSuccessInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& context = nullptr) const;
SetSuccessInstanceOutcomeCallable setSuccessInstanceCallable(const Model::SetSuccessInstanceRequest& request) const;

63
dataworks-public/include/alibabacloud/dataworks-public/model/CreateManualDagRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEMANUALDAGREQUEST_H_
#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_CREATEMANUALDAGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
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_

51
dataworks-public/include/alibabacloud/dataworks-public/model/CreateManualDagResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
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_

3
dataworks-public/include/alibabacloud/dataworks-public/model/CreateTableRequest.h
View File

@@ -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_;

51
dataworks-public/include/alibabacloud/dataworks-public/model/GetDagRequest.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
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_

74
dataworks-public/include/alibabacloud/dataworks-public/model/GetDagResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
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_

9
dataworks-public/include/alibabacloud/dataworks-public/model/GetInstanceResult.h
View File

@@ -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;
};

54
dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMANUALDAGINSTANCESREQUEST_H_
#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMANUALDAGINSTANCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
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_

69
dataworks-public/include/alibabacloud/dataworks-public/model/GetManualDagInstancesResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
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<InstancesItem> getInstances()const;
protected:
void parse(const std::string &payload);
private:
std::vector<InstancesItem> instances_;
};
}
}
}
#endif // !ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_GETMANUALDAGINSTANCESRESULT_H_

15
dataworks-public/include/alibabacloud/dataworks-public/model/GetNodeResult.h
View File

@@ -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;
};

3
dataworks-public/include/alibabacloud/dataworks-public/model/ListInstancesRequest.h
View File

@@ -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_;

9
dataworks-public/include/alibabacloud/dataworks-public/model/ListInstancesResult.h
View File

@@ -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<Instance> instances;
int totalCount;

1
dataworks-public/include/alibabacloud/dataworks-public/model/ListNodeIOResult.h
View File

@@ -35,6 +35,7 @@ namespace AlibabaCloud
struct DataItem
{
std::string tableName;
long nodeId;
std::string data;
};

15
dataworks-public/include/alibabacloud/dataworks-public/model/ListNodesResult.h
View File

@@ -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;

57
dataworks-public/include/alibabacloud/dataworks-public/model/RunTriggerNodeRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_RUNTRIGGERNODEREQUEST_H_
#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_RUNTRIGGERNODEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
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_

51
dataworks-public/include/alibabacloud/dataworks-public/model/RunTriggerNodeResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
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_

51
dataworks-public/include/alibabacloud/dataworks-public/model/SearchNodesByOutputRequest.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
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_

59
dataworks-public/include/alibabacloud/dataworks-public/model/SearchNodesByOutputResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_SEARCHNODESBYOUTPUTRESULT_H_
#define ALIBABACLOUD_DATAWORKS_PUBLIC_MODEL_SEARCHNODESBYOUTPUTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dataworks-public/Dataworks_publicExport.h>
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_

180
dataworks-public/src/Dataworks-publicClient.cc
View File

@@ -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<const AsyncCallerContext>& 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<std::packaged_task<CreateManualDagOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<GetDagOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<GetManualDagInstancesOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<RunTriggerNodeOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<SearchNodesByOutputOutcome()>>(
[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();

95
dataworks-public/src/model/CreateManualDagRequest.cc Normal file
View File

@@ -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 <alibabacloud/dataworks-public/model/CreateManualDagRequest.h>
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);
}

51
dataworks-public/src/model/CreateManualDagResult.cc Normal file
View File

@@ -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 <alibabacloud/dataworks-public/model/CreateManualDagResult.h>
#include <json/json.h>
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_;
}

11
dataworks-public/src/model/CreateTableRequest.cc
View File

@@ -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_;

88
dataworks-public/src/model/GetBaselineKeyPathResult.cc
View File

@@ -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);

51
dataworks-public/src/model/GetDagRequest.cc Normal file
View File

@@ -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 <alibabacloud/dataworks-public/model/GetDagRequest.h>
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));
}

102
dataworks-public/src/model/GetDagResult.cc Normal file
View File

@@ -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 <alibabacloud/dataworks-public/model/GetDagResult.h>
#include <json/json.h>
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_;
}

18
dataworks-public/src/model/GetInstanceResult.cc
View File

@@ -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())

62
dataworks-public/src/model/GetManualDagInstancesRequest.cc Normal file
View File

@@ -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 <alibabacloud/dataworks-public/model/GetManualDagInstancesRequest.h>
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);
}

85
dataworks-public/src/model/GetManualDagInstancesResult.cc Normal file
View File

@@ -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 <alibabacloud/dataworks-public/model/GetManualDagInstancesResult.h>
#include <json/json.h>
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::InstancesItem> GetManualDagInstancesResult::getInstances()const
{
return instances_;
}

14
dataworks-public/src/model/GetNodeResult.cc
View File

@@ -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())

72
dataworks-public/src/model/ListAlertMessagesResult.cc
View File

@@ -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"];

20
dataworks-public/src/model/ListDataServiceApiAuthoritiesResult.cc
View File

@@ -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);

11
dataworks-public/src/model/ListInstancesRequest.cc
View File

@@ -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_;

18
dataworks-public/src/model/ListInstancesResult.cc
View File

@@ -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())

2
dataworks-public/src/model/ListNodeIOResult.cc
View File

@@ -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())

14
dataworks-public/src/model/ListNodesResult.cc
View File

@@ -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())

20
dataworks-public/src/model/ListProjectMembersResult.cc
View File

@@ -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);

40
dataworks-public/src/model/ListQualityResultsByEntityResult.cc
View File

@@ -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);

40
dataworks-public/src/model/ListQualityResultsByRuleResult.cc
View File

@@ -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);

73
dataworks-public/src/model/RunTriggerNodeRequest.cc Normal file
View File

@@ -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 <alibabacloud/dataworks-public/model/RunTriggerNodeRequest.h>
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));
}

51
dataworks-public/src/model/RunTriggerNodeResult.cc Normal file
View File

@@ -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 <alibabacloud/dataworks-public/model/RunTriggerNodeResult.h>
#include <json/json.h>
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_;
}

51
dataworks-public/src/model/SearchNodesByOutputRequest.cc Normal file
View File

@@ -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 <alibabacloud/dataworks-public/model/SearchNodesByOutputRequest.h>
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);
}

79
dataworks-public/src/model/SearchNodesByOutputResult.cc Normal file
View File

@@ -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 <alibabacloud/dataworks-public/model/SearchNodesByOutputResult.h>
#include <json/json.h>
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_;
}