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

FnF public version.

Browse Source
This commit is contained in:
sdk-team
2019-08-15 14:42:06 +08:00
parent 8be7bd42dc
commit 2244282621
51 changed files with 3314 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG
View File

@@ -1,3 +1,7 @@
2019-08-15 Version 1.36.90
- FnF public version.
- Add Report task api.
2019-08-15 Version 1.36.89
- Add API BatchStartCdnDomain, BatchStopCdnDomain, DescribeTagResources, DescribeUserTags, TagResources, UntagResources.

2
VERSION
View File

@@ -1 +1 @@
1.36.89
1.36.90

32
fnf/include/alibabacloud/fnf/FnfExport.h Normal file
View File

@@ -0,0 +1,32 @@
/*
* 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_FNF_FNFEXPORT_H_
#define ALIBABACLOUD_FNF_FNFEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_FNF_LIBRARY)
# define ALIBABACLOUD_FNF_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_FNF_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_FNF_EXPORT
#endif
#endif // !ALIBABACLOUD_FNF_FNFEXPORT_H_

63
fnf/include/alibabacloud/fnf/model/CreateFlowRequest.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_FNF_MODEL_CREATEFLOWREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_CREATEFLOWREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT CreateFlowRequest : public RpcServiceRequest
{
public:
CreateFlowRequest();
~CreateFlowRequest();
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getRoleArn()const;
void setRoleArn(const std::string& roleArn);
std::string getName()const;
void setName(const std::string& name);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getDefinition()const;
void setDefinition(const std::string& definition);
std::string getType()const;
void setType(const std::string& type);
private:
std::string requestId_;
std::string roleArn_;
std::string name_;
std::string description_;
std::string definition_;
std::string type_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_CREATEFLOWREQUEST_H_

65
fnf/include/alibabacloud/fnf/model/CreateFlowResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FNF_MODEL_CREATEFLOWRESULT_H_
#define ALIBABACLOUD_FNF_MODEL_CREATEFLOWRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT CreateFlowResult : public ServiceResult
{
public:
CreateFlowResult();
explicit CreateFlowResult(const std::string &payload);
~CreateFlowResult();
std::string getType()const;
std::string getDescription()const;
std::string getCreatedTime()const;
std::string getDefinition()const;
std::string getLastModifiedTime()const;
std::string getId()const;
std::string getRoleArn()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::string type_;
std::string description_;
std::string createdTime_;
std::string definition_;
std::string lastModifiedTime_;
std::string id_;
std::string roleArn_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_CREATEFLOWRESULT_H_

51
fnf/include/alibabacloud/fnf/model/DeleteFlowRequest.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_FNF_MODEL_DELETEFLOWREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_DELETEFLOWREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT DeleteFlowRequest : public RpcServiceRequest
{
public:
DeleteFlowRequest();
~DeleteFlowRequest();
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getName()const;
void setName(const std::string& name);
private:
std::string requestId_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_DELETEFLOWREQUEST_H_

49
fnf/include/alibabacloud/fnf/model/DeleteFlowResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FNF_MODEL_DELETEFLOWRESULT_H_
#define ALIBABACLOUD_FNF_MODEL_DELETEFLOWRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT DeleteFlowResult : public ServiceResult
{
public:
DeleteFlowResult();
explicit DeleteFlowResult(const std::string &payload);
~DeleteFlowResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_DELETEFLOWRESULT_H_

54
fnf/include/alibabacloud/fnf/model/DescribeExecutionRequest.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_FNF_MODEL_DESCRIBEEXECUTIONREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_DESCRIBEEXECUTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT DescribeExecutionRequest : public RpcServiceRequest
{
public:
DescribeExecutionRequest();
~DescribeExecutionRequest();
std::string getExecutionName()const;
void setExecutionName(const std::string& executionName);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getFlowName()const;
void setFlowName(const std::string& flowName);
private:
std::string executionName_;
std::string requestId_;
std::string flowName_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_DESCRIBEEXECUTIONREQUEST_H_

65
fnf/include/alibabacloud/fnf/model/DescribeExecutionResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FNF_MODEL_DESCRIBEEXECUTIONRESULT_H_
#define ALIBABACLOUD_FNF_MODEL_DESCRIBEEXECUTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT DescribeExecutionResult : public ServiceResult
{
public:
DescribeExecutionResult();
explicit DescribeExecutionResult(const std::string &payload);
~DescribeExecutionResult();
std::string getStatus()const;
std::string getInput()const;
std::string getStoppedTime()const;
std::string getFlowName()const;
std::string getOutput()const;
std::string getStartedTime()const;
std::string getFlowDefinition()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
std::string input_;
std::string stoppedTime_;
std::string flowName_;
std::string output_;
std::string startedTime_;
std::string flowDefinition_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_DESCRIBEEXECUTIONRESULT_H_

51
fnf/include/alibabacloud/fnf/model/DescribeFlowRequest.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_FNF_MODEL_DESCRIBEFLOWREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_DESCRIBEFLOWREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT DescribeFlowRequest : public RpcServiceRequest
{
public:
DescribeFlowRequest();
~DescribeFlowRequest();
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getName()const;
void setName(const std::string& name);
private:
std::string requestId_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_DESCRIBEFLOWREQUEST_H_

65
fnf/include/alibabacloud/fnf/model/DescribeFlowResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FNF_MODEL_DESCRIBEFLOWRESULT_H_
#define ALIBABACLOUD_FNF_MODEL_DESCRIBEFLOWRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT DescribeFlowResult : public ServiceResult
{
public:
DescribeFlowResult();
explicit DescribeFlowResult(const std::string &payload);
~DescribeFlowResult();
std::string getType()const;
std::string getDescription()const;
std::string getCreatedTime()const;
std::string getDefinition()const;
std::string getLastModifiedTime()const;
std::string getId()const;
std::string getRoleArn()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::string type_;
std::string description_;
std::string createdTime_;
std::string definition_;
std::string lastModifiedTime_;
std::string id_;
std::string roleArn_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_DESCRIBEFLOWRESULT_H_

60
fnf/include/alibabacloud/fnf/model/GetExecutionHistoryRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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_FNF_MODEL_GETEXECUTIONHISTORYREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_GETEXECUTIONHISTORYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT GetExecutionHistoryRequest : public RpcServiceRequest
{
public:
GetExecutionHistoryRequest();
~GetExecutionHistoryRequest();
std::string getExecutionName()const;
void setExecutionName(const std::string& executionName);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
int getLimit()const;
void setLimit(int limit);
std::string getFlowName()const;
void setFlowName(const std::string& flowName);
private:
std::string executionName_;
std::string nextToken_;
std::string requestId_;
int limit_;
std::string flowName_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_GETEXECUTIONHISTORYREQUEST_H_

62
fnf/include/alibabacloud/fnf/model/GetExecutionHistoryResult.h 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.
*/
#ifndef ALIBABACLOUD_FNF_MODEL_GETEXECUTIONHISTORYRESULT_H_
#define ALIBABACLOUD_FNF_MODEL_GETEXECUTIONHISTORYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT GetExecutionHistoryResult : public ServiceResult
{
public:
struct EventsItem
{
std::string type;
long eventId;
std::string stepName;
std::string eventDetail;
std::string time;
long scheduleEventId;
};
GetExecutionHistoryResult();
explicit GetExecutionHistoryResult(const std::string &payload);
~GetExecutionHistoryResult();
std::string getNextToken()const;
std::vector<EventsItem> getEvents()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::vector<EventsItem> events_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_GETEXECUTIONHISTORYRESULT_H_

57
fnf/include/alibabacloud/fnf/model/ListExecutionsRequest.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_FNF_MODEL_LISTEXECUTIONSREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_LISTEXECUTIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT ListExecutionsRequest : public RpcServiceRequest
{
public:
ListExecutionsRequest();
~ListExecutionsRequest();
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
int getLimit()const;
void setLimit(int limit);
std::string getFlowName()const;
void setFlowName(const std::string& flowName);
private:
std::string nextToken_;
std::string requestId_;
int limit_;
std::string flowName_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_LISTEXECUTIONSREQUEST_H_

64
fnf/include/alibabacloud/fnf/model/ListExecutionsResult.h Normal file
View File

@@ -0,0 +1,64 @@
/*
* 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_FNF_MODEL_LISTEXECUTIONSRESULT_H_
#define ALIBABACLOUD_FNF_MODEL_LISTEXECUTIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT ListExecutionsResult : public ServiceResult
{
public:
struct ExecutionsItem
{
std::string status;
std::string input;
std::string stoppedTime;
std::string flowName;
std::string output;
std::string startedTime;
std::string flowDefinition;
std::string name;
};
ListExecutionsResult();
explicit ListExecutionsResult(const std::string &payload);
~ListExecutionsResult();
std::vector<ExecutionsItem> getExecutions()const;
std::string getNextToken()const;
protected:
void parse(const std::string &payload);
private:
std::vector<ExecutionsItem> executions_;
std::string nextToken_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_LISTEXECUTIONSRESULT_H_

54
fnf/include/alibabacloud/fnf/model/ListFlowsRequest.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_FNF_MODEL_LISTFLOWSREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_LISTFLOWSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT ListFlowsRequest : public RpcServiceRequest
{
public:
ListFlowsRequest();
~ListFlowsRequest();
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
int getLimit()const;
void setLimit(int limit);
private:
std::string nextToken_;
std::string requestId_;
int limit_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_LISTFLOWSREQUEST_H_

64
fnf/include/alibabacloud/fnf/model/ListFlowsResult.h Normal file
View File

@@ -0,0 +1,64 @@
/*
* 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_FNF_MODEL_LISTFLOWSRESULT_H_
#define ALIBABACLOUD_FNF_MODEL_LISTFLOWSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT ListFlowsResult : public ServiceResult
{
public:
struct FlowsItem
{
std::string type;
std::string description;
std::string createdTime;
std::string definition;
std::string lastModifiedTime;
std::string id;
std::string roleArn;
std::string name;
};
ListFlowsResult();
explicit ListFlowsResult(const std::string &payload);
~ListFlowsResult();
std::string getNextToken()const;
std::vector<FlowsItem> getFlows()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::vector<FlowsItem> flows_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_LISTFLOWSRESULT_H_

57
fnf/include/alibabacloud/fnf/model/ReportTaskFailedRequest.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_FNF_MODEL_REPORTTASKFAILEDREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_REPORTTASKFAILEDREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT ReportTaskFailedRequest : public RpcServiceRequest
{
public:
ReportTaskFailedRequest();
~ReportTaskFailedRequest();
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getCause()const;
void setCause(const std::string& cause);
std::string getTaskToken()const;
void setTaskToken(const std::string& taskToken);
std::string getError()const;
void setError(const std::string& error);
private:
std::string requestId_;
std::string cause_;
std::string taskToken_;
std::string error_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_REPORTTASKFAILEDREQUEST_H_

51
fnf/include/alibabacloud/fnf/model/ReportTaskFailedResult.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_FNF_MODEL_REPORTTASKFAILEDRESULT_H_
#define ALIBABACLOUD_FNF_MODEL_REPORTTASKFAILEDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT ReportTaskFailedResult : public ServiceResult
{
public:
ReportTaskFailedResult();
explicit ReportTaskFailedResult(const std::string &payload);
~ReportTaskFailedResult();
long getEventId()const;
protected:
void parse(const std::string &payload);
private:
long eventId_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_REPORTTASKFAILEDRESULT_H_

54
fnf/include/alibabacloud/fnf/model/ReportTaskSucceededRequest.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_FNF_MODEL_REPORTTASKSUCCEEDEDREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_REPORTTASKSUCCEEDEDREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT ReportTaskSucceededRequest : public RpcServiceRequest
{
public:
ReportTaskSucceededRequest();
~ReportTaskSucceededRequest();
std::string getOutput()const;
void setOutput(const std::string& output);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getTaskToken()const;
void setTaskToken(const std::string& taskToken);
private:
std::string output_;
std::string requestId_;
std::string taskToken_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_REPORTTASKSUCCEEDEDREQUEST_H_

51
fnf/include/alibabacloud/fnf/model/ReportTaskSucceededResult.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_FNF_MODEL_REPORTTASKSUCCEEDEDRESULT_H_
#define ALIBABACLOUD_FNF_MODEL_REPORTTASKSUCCEEDEDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT ReportTaskSucceededResult : public ServiceResult
{
public:
ReportTaskSucceededResult();
explicit ReportTaskSucceededResult(const std::string &payload);
~ReportTaskSucceededResult();
long getEventId()const;
protected:
void parse(const std::string &payload);
private:
long eventId_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_REPORTTASKSUCCEEDEDRESULT_H_

57
fnf/include/alibabacloud/fnf/model/StartExecutionRequest.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_FNF_MODEL_STARTEXECUTIONREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_STARTEXECUTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT StartExecutionRequest : public RpcServiceRequest
{
public:
StartExecutionRequest();
~StartExecutionRequest();
std::string getInput()const;
void setInput(const std::string& input);
std::string getExecutionName()const;
void setExecutionName(const std::string& executionName);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getFlowName()const;
void setFlowName(const std::string& flowName);
private:
std::string input_;
std::string executionName_;
std::string requestId_;
std::string flowName_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_STARTEXECUTIONREQUEST_H_

65
fnf/include/alibabacloud/fnf/model/StartExecutionResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FNF_MODEL_STARTEXECUTIONRESULT_H_
#define ALIBABACLOUD_FNF_MODEL_STARTEXECUTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT StartExecutionResult : public ServiceResult
{
public:
StartExecutionResult();
explicit StartExecutionResult(const std::string &payload);
~StartExecutionResult();
std::string getStatus()const;
std::string getInput()const;
std::string getStoppedTime()const;
std::string getFlowName()const;
std::string getOutput()const;
std::string getStartedTime()const;
std::string getFlowDefinition()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
std::string input_;
std::string stoppedTime_;
std::string flowName_;
std::string output_;
std::string startedTime_;
std::string flowDefinition_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_STARTEXECUTIONRESULT_H_

60
fnf/include/alibabacloud/fnf/model/StopExecutionRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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_FNF_MODEL_STOPEXECUTIONREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_STOPEXECUTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT StopExecutionRequest : public RpcServiceRequest
{
public:
StopExecutionRequest();
~StopExecutionRequest();
std::string getExecutionName()const;
void setExecutionName(const std::string& executionName);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getCause()const;
void setCause(const std::string& cause);
std::string getFlowName()const;
void setFlowName(const std::string& flowName);
std::string getError()const;
void setError(const std::string& error);
private:
std::string executionName_;
std::string requestId_;
std::string cause_;
std::string flowName_;
std::string error_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_STOPEXECUTIONREQUEST_H_

65
fnf/include/alibabacloud/fnf/model/StopExecutionResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FNF_MODEL_STOPEXECUTIONRESULT_H_
#define ALIBABACLOUD_FNF_MODEL_STOPEXECUTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT StopExecutionResult : public ServiceResult
{
public:
StopExecutionResult();
explicit StopExecutionResult(const std::string &payload);
~StopExecutionResult();
std::string getStatus()const;
std::string getInput()const;
std::string getStoppedTime()const;
std::string getFlowName()const;
std::string getOutput()const;
std::string getStartedTime()const;
std::string getFlowDefinition()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
std::string input_;
std::string stoppedTime_;
std::string flowName_;
std::string output_;
std::string startedTime_;
std::string flowDefinition_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_STOPEXECUTIONRESULT_H_

63
fnf/include/alibabacloud/fnf/model/UpdateFlowRequest.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_FNF_MODEL_UPDATEFLOWREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_UPDATEFLOWREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT UpdateFlowRequest : public RpcServiceRequest
{
public:
UpdateFlowRequest();
~UpdateFlowRequest();
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getRoleArn()const;
void setRoleArn(const std::string& roleArn);
std::string getName()const;
void setName(const std::string& name);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getDefinition()const;
void setDefinition(const std::string& definition);
std::string getType()const;
void setType(const std::string& type);
private:
std::string requestId_;
std::string roleArn_;
std::string name_;
std::string description_;
std::string definition_;
std::string type_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_UPDATEFLOWREQUEST_H_

65
fnf/include/alibabacloud/fnf/model/UpdateFlowResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FNF_MODEL_UPDATEFLOWRESULT_H_
#define ALIBABACLOUD_FNF_MODEL_UPDATEFLOWRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/fnf/FnfExport.h>
namespace AlibabaCloud
{
namespace Fnf
{
namespace Model
{
class ALIBABACLOUD_FNF_EXPORT UpdateFlowResult : public ServiceResult
{
public:
UpdateFlowResult();
explicit UpdateFlowResult(const std::string &payload);
~UpdateFlowResult();
std::string getType()const;
std::string getDescription()const;
std::string getCreatedTime()const;
std::string getDefinition()const;
std::string getLastModifiedTime()const;
std::string getId()const;
std::string getRoleArn()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::string type_;
std::string description_;
std::string createdTime_;
std::string definition_;
std::string lastModifiedTime_;
std::string id_;
std::string roleArn_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_UPDATEFLOWRESULT_H_

93
fnf/src/model/CreateFlowRequest.cc Normal file
View File

@@ -0,0 +1,93 @@
/*
* 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/fnf/model/CreateFlowRequest.h>
using AlibabaCloud::Fnf::Model::CreateFlowRequest;
CreateFlowRequest::CreateFlowRequest() :
RpcServiceRequest("fnf", "2019-03-15", "CreateFlow")
{}
CreateFlowRequest::~CreateFlowRequest()
{}
std::string CreateFlowRequest::getRequestId()const
{
return requestId_;
}
void CreateFlowRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setCoreParameter("RequestId", requestId);
}
std::string CreateFlowRequest::getRoleArn()const
{
return roleArn_;
}
void CreateFlowRequest::setRoleArn(const std::string& roleArn)
{
roleArn_ = roleArn;
setCoreParameter("RoleArn", roleArn);
}
std::string CreateFlowRequest::getName()const
{
return name_;
}
void CreateFlowRequest::setName(const std::string& name)
{
name_ = name;
setCoreParameter("Name", name);
}
std::string CreateFlowRequest::getDescription()const
{
return description_;
}
void CreateFlowRequest::setDescription(const std::string& description)
{
description_ = description;
setCoreParameter("Description", description);
}
std::string CreateFlowRequest::getDefinition()const
{
return definition_;
}
void CreateFlowRequest::setDefinition(const std::string& definition)
{
definition_ = definition;
setCoreParameter("Definition", definition);
}
std::string CreateFlowRequest::getType()const
{
return type_;
}
void CreateFlowRequest::setType(const std::string& type)
{
type_ = type;
setCoreParameter("Type", type);
}

104
fnf/src/model/CreateFlowResult.cc Normal file
View File

@@ -0,0 +1,104 @@
/*
* 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/fnf/model/CreateFlowResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Fnf;
using namespace AlibabaCloud::Fnf::Model;
CreateFlowResult::CreateFlowResult() :
ServiceResult()
{}
CreateFlowResult::CreateFlowResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateFlowResult::~CreateFlowResult()
{}
void CreateFlowResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
setRequestId(value["RequestId"].asString());
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["Description"].isNull())
description_ = value["Description"].asString();
if(!value["Definition"].isNull())
definition_ = value["Definition"].asString();
if(!value["Id"].isNull())
id_ = value["Id"].asString();
if(!value["Type"].isNull())
type_ = value["Type"].asString();
if(!value["RoleArn"].isNull())
roleArn_ = value["RoleArn"].asString();
if(!value["CreatedTime"].isNull())
createdTime_ = value["CreatedTime"].asString();
if(!value["LastModifiedTime"].isNull())
lastModifiedTime_ = value["LastModifiedTime"].asString();
}
std::string CreateFlowResult::getType()const
{
return type_;
}
std::string CreateFlowResult::getDescription()const
{
return description_;
}
std::string CreateFlowResult::getCreatedTime()const
{
return createdTime_;
}
std::string CreateFlowResult::getDefinition()const
{
return definition_;
}
std::string CreateFlowResult::getLastModifiedTime()const
{
return lastModifiedTime_;
}
std::string CreateFlowResult::getId()const
{
return id_;
}
std::string CreateFlowResult::getRoleArn()const
{
return roleArn_;
}
std::string CreateFlowResult::getName()const
{
return name_;
}

49
fnf/src/model/DeleteFlowRequest.cc Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/fnf/model/DeleteFlowRequest.h>
using AlibabaCloud::Fnf::Model::DeleteFlowRequest;
DeleteFlowRequest::DeleteFlowRequest() :
RpcServiceRequest("fnf", "2019-03-15", "DeleteFlow")
{}
DeleteFlowRequest::~DeleteFlowRequest()
{}
std::string DeleteFlowRequest::getRequestId()const
{
return requestId_;
}
void DeleteFlowRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setCoreParameter("RequestId", requestId);
}
std::string DeleteFlowRequest::getName()const
{
return name_;
}
void DeleteFlowRequest::setName(const std::string& name)
{
name_ = name;
setCoreParameter("Name", name);
}

48
fnf/src/model/DeleteFlowResult.cc Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/fnf/model/DeleteFlowResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Fnf;
using namespace AlibabaCloud::Fnf::Model;
DeleteFlowResult::DeleteFlowResult() :
ServiceResult()
{}
DeleteFlowResult::DeleteFlowResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteFlowResult::~DeleteFlowResult()
{}
void DeleteFlowResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
setRequestId(value["RequestId"].asString());
}

60
fnf/src/model/DescribeExecutionRequest.cc Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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/fnf/model/DescribeExecutionRequest.h>
using AlibabaCloud::Fnf::Model::DescribeExecutionRequest;
DescribeExecutionRequest::DescribeExecutionRequest() :
RpcServiceRequest("fnf", "2019-03-15", "DescribeExecution")
{}
DescribeExecutionRequest::~DescribeExecutionRequest()
{}
std::string DescribeExecutionRequest::getExecutionName()const
{
return executionName_;
}
void DescribeExecutionRequest::setExecutionName(const std::string& executionName)
{
executionName_ = executionName;
setCoreParameter("ExecutionName", executionName);
}
std::string DescribeExecutionRequest::getRequestId()const
{
return requestId_;
}
void DescribeExecutionRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setCoreParameter("RequestId", requestId);
}
std::string DescribeExecutionRequest::getFlowName()const
{
return flowName_;
}
void DescribeExecutionRequest::setFlowName(const std::string& flowName)
{
flowName_ = flowName;
setCoreParameter("FlowName", flowName);
}

104
fnf/src/model/DescribeExecutionResult.cc Normal file
View File

@@ -0,0 +1,104 @@
/*
* 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/fnf/model/DescribeExecutionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Fnf;
using namespace AlibabaCloud::Fnf::Model;
DescribeExecutionResult::DescribeExecutionResult() :
ServiceResult()
{}
DescribeExecutionResult::DescribeExecutionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeExecutionResult::~DescribeExecutionResult()
{}
void DescribeExecutionResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
setRequestId(value["RequestId"].asString());
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["FlowName"].isNull())
flowName_ = value["FlowName"].asString();
if(!value["FlowDefinition"].isNull())
flowDefinition_ = value["FlowDefinition"].asString();
if(!value["Input"].isNull())
input_ = value["Input"].asString();
if(!value["Output"].isNull())
output_ = value["Output"].asString();
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["StartedTime"].isNull())
startedTime_ = value["StartedTime"].asString();
if(!value["StoppedTime"].isNull())
stoppedTime_ = value["StoppedTime"].asString();
}
std::string DescribeExecutionResult::getStatus()const
{
return status_;
}
std::string DescribeExecutionResult::getInput()const
{
return input_;
}
std::string DescribeExecutionResult::getStoppedTime()const
{
return stoppedTime_;
}
std::string DescribeExecutionResult::getFlowName()const
{
return flowName_;
}
std::string DescribeExecutionResult::getOutput()const
{
return output_;
}
std::string DescribeExecutionResult::getStartedTime()const
{
return startedTime_;
}
std::string DescribeExecutionResult::getFlowDefinition()const
{
return flowDefinition_;
}
std::string DescribeExecutionResult::getName()const
{
return name_;
}

49
fnf/src/model/DescribeFlowRequest.cc Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/fnf/model/DescribeFlowRequest.h>
using AlibabaCloud::Fnf::Model::DescribeFlowRequest;
DescribeFlowRequest::DescribeFlowRequest() :
RpcServiceRequest("fnf", "2019-03-15", "DescribeFlow")
{}
DescribeFlowRequest::~DescribeFlowRequest()
{}
std::string DescribeFlowRequest::getRequestId()const
{
return requestId_;
}
void DescribeFlowRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setCoreParameter("RequestId", requestId);
}
std::string DescribeFlowRequest::getName()const
{
return name_;
}
void DescribeFlowRequest::setName(const std::string& name)
{
name_ = name;
setCoreParameter("Name", name);
}

104
fnf/src/model/DescribeFlowResult.cc Normal file
View File

@@ -0,0 +1,104 @@
/*
* 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/fnf/model/DescribeFlowResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Fnf;
using namespace AlibabaCloud::Fnf::Model;
DescribeFlowResult::DescribeFlowResult() :
ServiceResult()
{}
DescribeFlowResult::DescribeFlowResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeFlowResult::~DescribeFlowResult()
{}
void DescribeFlowResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
setRequestId(value["RequestId"].asString());
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["Description"].isNull())
description_ = value["Description"].asString();
if(!value["Definition"].isNull())
definition_ = value["Definition"].asString();
if(!value["Id"].isNull())
id_ = value["Id"].asString();
if(!value["Type"].isNull())
type_ = value["Type"].asString();
if(!value["RoleArn"].isNull())
roleArn_ = value["RoleArn"].asString();
if(!value["CreatedTime"].isNull())
createdTime_ = value["CreatedTime"].asString();
if(!value["LastModifiedTime"].isNull())
lastModifiedTime_ = value["LastModifiedTime"].asString();
}
std::string DescribeFlowResult::getType()const
{
return type_;
}
std::string DescribeFlowResult::getDescription()const
{
return description_;
}
std::string DescribeFlowResult::getCreatedTime()const
{
return createdTime_;
}
std::string DescribeFlowResult::getDefinition()const
{
return definition_;
}
std::string DescribeFlowResult::getLastModifiedTime()const
{
return lastModifiedTime_;
}
std::string DescribeFlowResult::getId()const
{
return id_;
}
std::string DescribeFlowResult::getRoleArn()const
{
return roleArn_;
}
std::string DescribeFlowResult::getName()const
{
return name_;
}

82
fnf/src/model/GetExecutionHistoryRequest.cc Normal file
View File

@@ -0,0 +1,82 @@
/*
* 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/fnf/model/GetExecutionHistoryRequest.h>
using AlibabaCloud::Fnf::Model::GetExecutionHistoryRequest;
GetExecutionHistoryRequest::GetExecutionHistoryRequest() :
RpcServiceRequest("fnf", "2019-03-15", "GetExecutionHistory")
{}
GetExecutionHistoryRequest::~GetExecutionHistoryRequest()
{}
std::string GetExecutionHistoryRequest::getExecutionName()const
{
return executionName_;
}
void GetExecutionHistoryRequest::setExecutionName(const std::string& executionName)
{
executionName_ = executionName;
setCoreParameter("ExecutionName", executionName);
}
std::string GetExecutionHistoryRequest::getNextToken()const
{
return nextToken_;
}
void GetExecutionHistoryRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setCoreParameter("NextToken", nextToken);
}
std::string GetExecutionHistoryRequest::getRequestId()const
{
return requestId_;
}
void GetExecutionHistoryRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setCoreParameter("RequestId", requestId);
}
int GetExecutionHistoryRequest::getLimit()const
{
return limit_;
}
void GetExecutionHistoryRequest::setLimit(int limit)
{
limit_ = limit;
setCoreParameter("Limit", std::to_string(limit));
}
std::string GetExecutionHistoryRequest::getFlowName()const
{
return flowName_;
}
void GetExecutionHistoryRequest::setFlowName(const std::string& flowName)
{
flowName_ = flowName;
setCoreParameter("FlowName", flowName);
}

78
fnf/src/model/GetExecutionHistoryResult.cc Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/fnf/model/GetExecutionHistoryResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Fnf;
using namespace AlibabaCloud::Fnf::Model;
GetExecutionHistoryResult::GetExecutionHistoryResult() :
ServiceResult()
{}
GetExecutionHistoryResult::GetExecutionHistoryResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetExecutionHistoryResult::~GetExecutionHistoryResult()
{}
void GetExecutionHistoryResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
setRequestId(value["RequestId"].asString());
auto allEvents = value["Events"]["EventsItem"];
for (auto value : allEvents)
{
EventsItem eventsObject;
if(!value["StepName"].isNull())
eventsObject.stepName = value["StepName"].asString();
if(!value["Type"].isNull())
eventsObject.type = value["Type"].asString();
if(!value["EventId"].isNull())
eventsObject.eventId = std::stol(value["EventId"].asString());
if(!value["ScheduleEventId"].isNull())
eventsObject.scheduleEventId = std::stol(value["ScheduleEventId"].asString());
if(!value["EventDetail"].isNull())
eventsObject.eventDetail = value["EventDetail"].asString();
if(!value["Time"].isNull())
eventsObject.time = value["Time"].asString();
events_.push_back(eventsObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::string GetExecutionHistoryResult::getNextToken()const
{
return nextToken_;
}
std::vector<GetExecutionHistoryResult::EventsItem> GetExecutionHistoryResult::getEvents()const
{
return events_;
}

71
fnf/src/model/ListExecutionsRequest.cc Normal file
View File

@@ -0,0 +1,71 @@
/*
* 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/fnf/model/ListExecutionsRequest.h>
using AlibabaCloud::Fnf::Model::ListExecutionsRequest;
ListExecutionsRequest::ListExecutionsRequest() :
RpcServiceRequest("fnf", "2019-03-15", "ListExecutions")
{}
ListExecutionsRequest::~ListExecutionsRequest()
{}
std::string ListExecutionsRequest::getNextToken()const
{
return nextToken_;
}
void ListExecutionsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setCoreParameter("NextToken", nextToken);
}
std::string ListExecutionsRequest::getRequestId()const
{
return requestId_;
}
void ListExecutionsRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setCoreParameter("RequestId", requestId);
}
int ListExecutionsRequest::getLimit()const
{
return limit_;
}
void ListExecutionsRequest::setLimit(int limit)
{
limit_ = limit;
setCoreParameter("Limit", std::to_string(limit));
}
std::string ListExecutionsRequest::getFlowName()const
{
return flowName_;
}
void ListExecutionsRequest::setFlowName(const std::string& flowName)
{
flowName_ = flowName;
setCoreParameter("FlowName", flowName);
}

82
fnf/src/model/ListExecutionsResult.cc Normal file
View File

@@ -0,0 +1,82 @@
/*
* 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/fnf/model/ListExecutionsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Fnf;
using namespace AlibabaCloud::Fnf::Model;
ListExecutionsResult::ListExecutionsResult() :
ServiceResult()
{}
ListExecutionsResult::ListExecutionsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListExecutionsResult::~ListExecutionsResult()
{}
void ListExecutionsResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
setRequestId(value["RequestId"].asString());
auto allExecutions = value["Executions"]["ExecutionsItem"];
for (auto value : allExecutions)
{
ExecutionsItem executionsObject;
if(!value["Name"].isNull())
executionsObject.name = value["Name"].asString();
if(!value["FlowName"].isNull())
executionsObject.flowName = value["FlowName"].asString();
if(!value["FlowDefinition"].isNull())
executionsObject.flowDefinition = value["FlowDefinition"].asString();
if(!value["Input"].isNull())
executionsObject.input = value["Input"].asString();
if(!value["Output"].isNull())
executionsObject.output = value["Output"].asString();
if(!value["Status"].isNull())
executionsObject.status = value["Status"].asString();
if(!value["StartedTime"].isNull())
executionsObject.startedTime = value["StartedTime"].asString();
if(!value["StoppedTime"].isNull())
executionsObject.stoppedTime = value["StoppedTime"].asString();
executions_.push_back(executionsObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::vector<ListExecutionsResult::ExecutionsItem> ListExecutionsResult::getExecutions()const
{
return executions_;
}
std::string ListExecutionsResult::getNextToken()const
{
return nextToken_;
}

60
fnf/src/model/ListFlowsRequest.cc Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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/fnf/model/ListFlowsRequest.h>
using AlibabaCloud::Fnf::Model::ListFlowsRequest;
ListFlowsRequest::ListFlowsRequest() :
RpcServiceRequest("fnf", "2019-03-15", "ListFlows")
{}
ListFlowsRequest::~ListFlowsRequest()
{}
std::string ListFlowsRequest::getNextToken()const
{
return nextToken_;
}
void ListFlowsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setCoreParameter("NextToken", nextToken);
}
std::string ListFlowsRequest::getRequestId()const
{
return requestId_;
}
void ListFlowsRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setCoreParameter("RequestId", requestId);
}
int ListFlowsRequest::getLimit()const
{
return limit_;
}
void ListFlowsRequest::setLimit(int limit)
{
limit_ = limit;
setCoreParameter("Limit", std::to_string(limit));
}

82
fnf/src/model/ListFlowsResult.cc Normal file
View File

@@ -0,0 +1,82 @@
/*
* 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/fnf/model/ListFlowsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Fnf;
using namespace AlibabaCloud::Fnf::Model;
ListFlowsResult::ListFlowsResult() :
ServiceResult()
{}
ListFlowsResult::ListFlowsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListFlowsResult::~ListFlowsResult()
{}
void ListFlowsResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
setRequestId(value["RequestId"].asString());
auto allFlows = value["Flows"]["FlowsItem"];
for (auto value : allFlows)
{
FlowsItem flowsObject;
if(!value["Name"].isNull())
flowsObject.name = value["Name"].asString();
if(!value["Description"].isNull())
flowsObject.description = value["Description"].asString();
if(!value["Definition"].isNull())
flowsObject.definition = value["Definition"].asString();
if(!value["Id"].isNull())
flowsObject.id = value["Id"].asString();
if(!value["Type"].isNull())
flowsObject.type = value["Type"].asString();
if(!value["RoleArn"].isNull())
flowsObject.roleArn = value["RoleArn"].asString();
if(!value["CreatedTime"].isNull())
flowsObject.createdTime = value["CreatedTime"].asString();
if(!value["LastModifiedTime"].isNull())
flowsObject.lastModifiedTime = value["LastModifiedTime"].asString();
flows_.push_back(flowsObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::string ListFlowsResult::getNextToken()const
{
return nextToken_;
}
std::vector<ListFlowsResult::FlowsItem> ListFlowsResult::getFlows()const
{
return flows_;
}

71
fnf/src/model/ReportTaskFailedRequest.cc Normal file
View File

@@ -0,0 +1,71 @@
/*
* 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/fnf/model/ReportTaskFailedRequest.h>
using AlibabaCloud::Fnf::Model::ReportTaskFailedRequest;
ReportTaskFailedRequest::ReportTaskFailedRequest() :
RpcServiceRequest("fnf", "2019-03-15", "ReportTaskFailed")
{}
ReportTaskFailedRequest::~ReportTaskFailedRequest()
{}
std::string ReportTaskFailedRequest::getRequestId()const
{
return requestId_;
}
void ReportTaskFailedRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setCoreParameter("RequestId", requestId);
}
std::string ReportTaskFailedRequest::getCause()const
{
return cause_;
}
void ReportTaskFailedRequest::setCause(const std::string& cause)
{
cause_ = cause;
setCoreParameter("Cause", cause);
}
std::string ReportTaskFailedRequest::getTaskToken()const
{
return taskToken_;
}
void ReportTaskFailedRequest::setTaskToken(const std::string& taskToken)
{
taskToken_ = taskToken;
setCoreParameter("TaskToken", taskToken);
}
std::string ReportTaskFailedRequest::getError()const
{
return error_;
}
void ReportTaskFailedRequest::setError(const std::string& error)
{
error_ = error;
setCoreParameter("Error", error);
}

55
fnf/src/model/ReportTaskFailedResult.cc Normal file
View File

@@ -0,0 +1,55 @@
/*
* 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/fnf/model/ReportTaskFailedResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Fnf;
using namespace AlibabaCloud::Fnf::Model;
ReportTaskFailedResult::ReportTaskFailedResult() :
ServiceResult()
{}
ReportTaskFailedResult::ReportTaskFailedResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ReportTaskFailedResult::~ReportTaskFailedResult()
{}
void ReportTaskFailedResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
setRequestId(value["RequestId"].asString());
if(!value["EventId"].isNull())
eventId_ = std::stol(value["EventId"].asString());
}
long ReportTaskFailedResult::getEventId()const
{
return eventId_;
}

60
fnf/src/model/ReportTaskSucceededRequest.cc Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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/fnf/model/ReportTaskSucceededRequest.h>
using AlibabaCloud::Fnf::Model::ReportTaskSucceededRequest;
ReportTaskSucceededRequest::ReportTaskSucceededRequest() :
RpcServiceRequest("fnf", "2019-03-15", "ReportTaskSucceeded")
{}
ReportTaskSucceededRequest::~ReportTaskSucceededRequest()
{}
std::string ReportTaskSucceededRequest::getOutput()const
{
return output_;
}
void ReportTaskSucceededRequest::setOutput(const std::string& output)
{
output_ = output;
setCoreParameter("Output", output);
}
std::string ReportTaskSucceededRequest::getRequestId()const
{
return requestId_;
}
void ReportTaskSucceededRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setCoreParameter("RequestId", requestId);
}
std::string ReportTaskSucceededRequest::getTaskToken()const
{
return taskToken_;
}
void ReportTaskSucceededRequest::setTaskToken(const std::string& taskToken)
{
taskToken_ = taskToken;
setCoreParameter("TaskToken", taskToken);
}

55
fnf/src/model/ReportTaskSucceededResult.cc Normal file
View File

@@ -0,0 +1,55 @@
/*
* 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/fnf/model/ReportTaskSucceededResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Fnf;
using namespace AlibabaCloud::Fnf::Model;
ReportTaskSucceededResult::ReportTaskSucceededResult() :
ServiceResult()
{}
ReportTaskSucceededResult::ReportTaskSucceededResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ReportTaskSucceededResult::~ReportTaskSucceededResult()
{}
void ReportTaskSucceededResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
setRequestId(value["RequestId"].asString());
if(!value["EventId"].isNull())
eventId_ = std::stol(value["EventId"].asString());
}
long ReportTaskSucceededResult::getEventId()const
{
return eventId_;
}

71
fnf/src/model/StartExecutionRequest.cc Normal file
View File

@@ -0,0 +1,71 @@
/*
* 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/fnf/model/StartExecutionRequest.h>
using AlibabaCloud::Fnf::Model::StartExecutionRequest;
StartExecutionRequest::StartExecutionRequest() :
RpcServiceRequest("fnf", "2019-03-15", "StartExecution")
{}
StartExecutionRequest::~StartExecutionRequest()
{}
std::string StartExecutionRequest::getInput()const
{
return input_;
}
void StartExecutionRequest::setInput(const std::string& input)
{
input_ = input;
setCoreParameter("Input", input);
}
std::string StartExecutionRequest::getExecutionName()const
{
return executionName_;
}
void StartExecutionRequest::setExecutionName(const std::string& executionName)
{
executionName_ = executionName;
setCoreParameter("ExecutionName", executionName);
}
std::string StartExecutionRequest::getRequestId()const
{
return requestId_;
}
void StartExecutionRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setCoreParameter("RequestId", requestId);
}
std::string StartExecutionRequest::getFlowName()const
{
return flowName_;
}
void StartExecutionRequest::setFlowName(const std::string& flowName)
{
flowName_ = flowName;
setCoreParameter("FlowName", flowName);
}

104
fnf/src/model/StartExecutionResult.cc Normal file
View File

@@ -0,0 +1,104 @@
/*
* 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/fnf/model/StartExecutionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Fnf;
using namespace AlibabaCloud::Fnf::Model;
StartExecutionResult::StartExecutionResult() :
ServiceResult()
{}
StartExecutionResult::StartExecutionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
StartExecutionResult::~StartExecutionResult()
{}
void StartExecutionResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
setRequestId(value["RequestId"].asString());
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["FlowName"].isNull())
flowName_ = value["FlowName"].asString();
if(!value["FlowDefinition"].isNull())
flowDefinition_ = value["FlowDefinition"].asString();
if(!value["Input"].isNull())
input_ = value["Input"].asString();
if(!value["Output"].isNull())
output_ = value["Output"].asString();
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["StartedTime"].isNull())
startedTime_ = value["StartedTime"].asString();
if(!value["StoppedTime"].isNull())
stoppedTime_ = value["StoppedTime"].asString();
}
std::string StartExecutionResult::getStatus()const
{
return status_;
}
std::string StartExecutionResult::getInput()const
{
return input_;
}
std::string StartExecutionResult::getStoppedTime()const
{
return stoppedTime_;
}
std::string StartExecutionResult::getFlowName()const
{
return flowName_;
}
std::string StartExecutionResult::getOutput()const
{
return output_;
}
std::string StartExecutionResult::getStartedTime()const
{
return startedTime_;
}
std::string StartExecutionResult::getFlowDefinition()const
{
return flowDefinition_;
}
std::string StartExecutionResult::getName()const
{
return name_;
}

82
fnf/src/model/StopExecutionRequest.cc Normal file
View File

@@ -0,0 +1,82 @@
/*
* 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/fnf/model/StopExecutionRequest.h>
using AlibabaCloud::Fnf::Model::StopExecutionRequest;
StopExecutionRequest::StopExecutionRequest() :
RpcServiceRequest("fnf", "2019-03-15", "StopExecution")
{}
StopExecutionRequest::~StopExecutionRequest()
{}
std::string StopExecutionRequest::getExecutionName()const
{
return executionName_;
}
void StopExecutionRequest::setExecutionName(const std::string& executionName)
{
executionName_ = executionName;
setCoreParameter("ExecutionName", executionName);
}
std::string StopExecutionRequest::getRequestId()const
{
return requestId_;
}
void StopExecutionRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setCoreParameter("RequestId", requestId);
}
std::string StopExecutionRequest::getCause()const
{
return cause_;
}
void StopExecutionRequest::setCause(const std::string& cause)
{
cause_ = cause;
setCoreParameter("Cause", cause);
}
std::string StopExecutionRequest::getFlowName()const
{
return flowName_;
}
void StopExecutionRequest::setFlowName(const std::string& flowName)
{
flowName_ = flowName;
setCoreParameter("FlowName", flowName);
}
std::string StopExecutionRequest::getError()const
{
return error_;
}
void StopExecutionRequest::setError(const std::string& error)
{
error_ = error;
setCoreParameter("Error", error);
}

104
fnf/src/model/StopExecutionResult.cc Normal file
View File

@@ -0,0 +1,104 @@
/*
* 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/fnf/model/StopExecutionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Fnf;
using namespace AlibabaCloud::Fnf::Model;
StopExecutionResult::StopExecutionResult() :
ServiceResult()
{}
StopExecutionResult::StopExecutionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
StopExecutionResult::~StopExecutionResult()
{}
void StopExecutionResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
setRequestId(value["RequestId"].asString());
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["FlowName"].isNull())
flowName_ = value["FlowName"].asString();
if(!value["FlowDefinition"].isNull())
flowDefinition_ = value["FlowDefinition"].asString();
if(!value["Input"].isNull())
input_ = value["Input"].asString();
if(!value["Output"].isNull())
output_ = value["Output"].asString();
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["StartedTime"].isNull())
startedTime_ = value["StartedTime"].asString();
if(!value["StoppedTime"].isNull())
stoppedTime_ = value["StoppedTime"].asString();
}
std::string StopExecutionResult::getStatus()const
{
return status_;
}
std::string StopExecutionResult::getInput()const
{
return input_;
}
std::string StopExecutionResult::getStoppedTime()const
{
return stoppedTime_;
}
std::string StopExecutionResult::getFlowName()const
{
return flowName_;
}
std::string StopExecutionResult::getOutput()const
{
return output_;
}
std::string StopExecutionResult::getStartedTime()const
{
return startedTime_;
}
std::string StopExecutionResult::getFlowDefinition()const
{
return flowDefinition_;
}
std::string StopExecutionResult::getName()const
{
return name_;
}

93
fnf/src/model/UpdateFlowRequest.cc Normal file
View File

@@ -0,0 +1,93 @@
/*
* 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/fnf/model/UpdateFlowRequest.h>
using AlibabaCloud::Fnf::Model::UpdateFlowRequest;
UpdateFlowRequest::UpdateFlowRequest() :
RpcServiceRequest("fnf", "2019-03-15", "UpdateFlow")
{}
UpdateFlowRequest::~UpdateFlowRequest()
{}
std::string UpdateFlowRequest::getRequestId()const
{
return requestId_;
}
void UpdateFlowRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setCoreParameter("RequestId", requestId);
}
std::string UpdateFlowRequest::getRoleArn()const
{
return roleArn_;
}
void UpdateFlowRequest::setRoleArn(const std::string& roleArn)
{
roleArn_ = roleArn;
setCoreParameter("RoleArn", roleArn);
}
std::string UpdateFlowRequest::getName()const
{
return name_;
}
void UpdateFlowRequest::setName(const std::string& name)
{
name_ = name;
setCoreParameter("Name", name);
}
std::string UpdateFlowRequest::getDescription()const
{
return description_;
}
void UpdateFlowRequest::setDescription(const std::string& description)
{
description_ = description;
setCoreParameter("Description", description);
}
std::string UpdateFlowRequest::getDefinition()const
{
return definition_;
}
void UpdateFlowRequest::setDefinition(const std::string& definition)
{
definition_ = definition;
setCoreParameter("Definition", definition);
}
std::string UpdateFlowRequest::getType()const
{
return type_;
}
void UpdateFlowRequest::setType(const std::string& type)
{
type_ = type;
setCoreParameter("Type", type);
}

104
fnf/src/model/UpdateFlowResult.cc Normal file
View File

@@ -0,0 +1,104 @@
/*
* 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/fnf/model/UpdateFlowResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Fnf;
using namespace AlibabaCloud::Fnf::Model;
UpdateFlowResult::UpdateFlowResult() :
ServiceResult()
{}
UpdateFlowResult::UpdateFlowResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateFlowResult::~UpdateFlowResult()
{}
void UpdateFlowResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
setRequestId(value["RequestId"].asString());
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["Description"].isNull())
description_ = value["Description"].asString();
if(!value["Definition"].isNull())
definition_ = value["Definition"].asString();
if(!value["Id"].isNull())
id_ = value["Id"].asString();
if(!value["Type"].isNull())
type_ = value["Type"].asString();
if(!value["RoleArn"].isNull())
roleArn_ = value["RoleArn"].asString();
if(!value["CreatedTime"].isNull())
createdTime_ = value["CreatedTime"].asString();
if(!value["LastModifiedTime"].isNull())
lastModifiedTime_ = value["LastModifiedTime"].asString();
}
std::string UpdateFlowResult::getType()const
{
return type_;
}
std::string UpdateFlowResult::getDescription()const
{
return description_;
}
std::string UpdateFlowResult::getCreatedTime()const
{
return createdTime_;
}
std::string UpdateFlowResult::getDefinition()const
{
return definition_;
}
std::string UpdateFlowResult::getLastModifiedTime()const
{
return lastModifiedTime_;
}
std::string UpdateFlowResult::getId()const
{
return id_;
}
std::string UpdateFlowResult::getRoleArn()const
{
return roleArn_;
}
std::string UpdateFlowResult::getName()const
{
return name_;
}