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

增加StartSyncExecution

Browse Source
This commit is contained in:
sdk-team
2023-10-26 15:51:54 +00:00
parent 879e8b9359
commit 2b84cadd9d
59 changed files with 1859 additions and 1793 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1792
1.36.1793

4
fnf/CMakeLists.txt
View File

@@ -49,6 +49,8 @@ set(fnf_public_header_model
include/alibabacloud/fnf/model/ReportTaskSucceededResult.h
include/alibabacloud/fnf/model/StartExecutionRequest.h
include/alibabacloud/fnf/model/StartExecutionResult.h
include/alibabacloud/fnf/model/StartSyncExecutionRequest.h
include/alibabacloud/fnf/model/StartSyncExecutionResult.h
include/alibabacloud/fnf/model/StopExecutionRequest.h
include/alibabacloud/fnf/model/StopExecutionResult.h
include/alibabacloud/fnf/model/UpdateFlowRequest.h
@@ -86,6 +88,8 @@ set(fnf_src
src/model/ReportTaskSucceededResult.cc
src/model/StartExecutionRequest.cc
src/model/StartExecutionResult.cc
src/model/StartSyncExecutionRequest.cc
src/model/StartSyncExecutionResult.cc
src/model/StopExecutionRequest.cc
src/model/StopExecutionResult.cc
src/model/UpdateFlowRequest.cc

8
fnf/include/alibabacloud/fnf/FnfClient.h
View File

@@ -50,6 +50,8 @@
#include "model/ReportTaskSucceededResult.h"
#include "model/StartExecutionRequest.h"
#include "model/StartExecutionResult.h"
#include "model/StartSyncExecutionRequest.h"
#include "model/StartSyncExecutionResult.h"
#include "model/StopExecutionRequest.h"
#include "model/StopExecutionResult.h"
#include "model/UpdateFlowRequest.h"
@@ -107,6 +109,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::StartExecutionResult> StartExecutionOutcome;
typedef std::future<StartExecutionOutcome> StartExecutionOutcomeCallable;
typedef std::function<void(const FnfClient*, const Model::StartExecutionRequest&, const StartExecutionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartExecutionAsyncHandler;
typedef Outcome<Error, Model::StartSyncExecutionResult> StartSyncExecutionOutcome;
typedef std::future<StartSyncExecutionOutcome> StartSyncExecutionOutcomeCallable;
typedef std::function<void(const FnfClient*, const Model::StartSyncExecutionRequest&, const StartSyncExecutionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartSyncExecutionAsyncHandler;
typedef Outcome<Error, Model::StopExecutionResult> StopExecutionOutcome;
typedef std::future<StopExecutionOutcome> StopExecutionOutcomeCallable;
typedef std::function<void(const FnfClient*, const Model::StopExecutionRequest&, const StopExecutionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopExecutionAsyncHandler;
@@ -163,6 +168,9 @@ namespace AlibabaCloud
StartExecutionOutcome startExecution(const Model::StartExecutionRequest &request)const;
void startExecutionAsync(const Model::StartExecutionRequest& request, const StartExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartExecutionOutcomeCallable startExecutionCallable(const Model::StartExecutionRequest& request) const;
StartSyncExecutionOutcome startSyncExecution(const Model::StartSyncExecutionRequest &request)const;
void startSyncExecutionAsync(const Model::StartSyncExecutionRequest& request, const StartSyncExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartSyncExecutionOutcomeCallable startSyncExecutionCallable(const Model::StartSyncExecutionRequest& request) const;
StopExecutionOutcome stopExecution(const Model::StopExecutionRequest &request)const;
void stopExecutionAsync(const Model::StopExecutionRequest& request, const StopExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopExecutionOutcomeCallable stopExecutionCallable(const Model::StopExecutionRequest& request) const;

107
fnf/include/alibabacloud/fnf/model/CreateFlowRequest.h
View File

@@ -1,66 +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 getDescription()const;
void setDescription(const std::string& description);
std::string getType()const;
void setType(const std::string& type);
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 getDefinition()const;
void setDefinition(const std::string& definition);
std::string getExternalStorageLocation()const;
void setExternalStorageLocation(const std::string& externalStorageLocation);
private:
std::string description_;
std::string type_;
std::string requestId_;
std::string roleArn_;
std::string name_;
std::string definition_;
std::string externalStorageLocation_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_CREATEFLOWREQUEST_H_
*/
#ifndef ALIBABACLOUD_FNF_MODEL_CREATEFLOWREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_CREATEFLOWREQUEST_H_
#include <alibabacloud/fnf/FnfExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Fnf {
namespace Model {
class ALIBABACLOUD_FNF_EXPORT CreateFlowRequest : public RpcServiceRequest {
public:
CreateFlowRequest();
~CreateFlowRequest();
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getType() const;
void setType(const std::string &type);
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 getDefinition() const;
void setDefinition(const std::string &definition);
std::string getExternalStorageLocation() const;
void setExternalStorageLocation(const std::string &externalStorageLocation);
std::string getExecutionMode() const;
void setExecutionMode(const std::string &executionMode);
private:
std::string description_;
std::string type_;
std::string requestId_;
std::string roleArn_;
std::string name_;
std::string definition_;
std::string externalStorageLocation_;
std::string executionMode_;
};
} // namespace Model
} // namespace Fnf
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FNF_MODEL_CREATEFLOWREQUEST_H_

2
fnf/include/alibabacloud/fnf/model/CreateFlowResult.h
View File

@@ -42,6 +42,7 @@ namespace AlibabaCloud
std::string getCreatedTime()const;
std::string getDefinition()const;
std::string getLastModifiedTime()const;
std::string getExecutionMode()const;
std::string getId()const;
std::string getExternalStorageLocation()const;
std::string getRoleArn()const;
@@ -55,6 +56,7 @@ namespace AlibabaCloud
std::string createdTime_;
std::string definition_;
std::string lastModifiedTime_;
std::string executionMode_;
std::string id_;
std::string externalStorageLocation_;
std::string roleArn_;

104
fnf/include/alibabacloud/fnf/model/CreateScheduleRequest.h
View File

@@ -1,66 +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_CREATESCHEDULEREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_CREATESCHEDULEREQUEST_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 CreateScheduleRequest : public RpcServiceRequest
{
public:
CreateScheduleRequest();
~CreateScheduleRequest();
std::string getScheduleName()const;
void setScheduleName(const std::string& scheduleName);
std::string getCronExpression()const;
void setCronExpression(const std::string& cronExpression);
std::string getPayload()const;
void setPayload(const std::string& payload);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
bool getEnable()const;
void setEnable(bool enable);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getFlowName()const;
void setFlowName(const std::string& flowName);
private:
std::string scheduleName_;
std::string cronExpression_;
std::string payload_;
std::string requestId_;
bool enable_;
std::string description_;
std::string flowName_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_CREATESCHEDULEREQUEST_H_
*/
#ifndef ALIBABACLOUD_FNF_MODEL_CREATESCHEDULEREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_CREATESCHEDULEREQUEST_H_
#include <alibabacloud/fnf/FnfExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Fnf {
namespace Model {
class ALIBABACLOUD_FNF_EXPORT CreateScheduleRequest : public RpcServiceRequest {
public:
CreateScheduleRequest();
~CreateScheduleRequest();
std::string getScheduleName() const;
void setScheduleName(const std::string &scheduleName);
std::string getCronExpression() const;
void setCronExpression(const std::string &cronExpression);
std::string getPayload() const;
void setPayload(const std::string &payload);
std::string getRequestId() const;
void setRequestId(const std::string &requestId);
bool getEnable() const;
void setEnable(bool enable);
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getFlowName() const;
void setFlowName(const std::string &flowName);
private:
std::string scheduleName_;
std::string cronExpression_;
std::string payload_;
std::string requestId_;
bool enable_;
std::string description_;
std::string flowName_;
};
} // namespace Model
} // namespace Fnf
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FNF_MODEL_CREATESCHEDULEREQUEST_H_

74
fnf/include/alibabacloud/fnf/model/DeleteFlowRequest.h
View File

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

80
fnf/include/alibabacloud/fnf/model/DeleteScheduleRequest.h
View File

@@ -1,54 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FNF_MODEL_DELETESCHEDULEREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_DELETESCHEDULEREQUEST_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 DeleteScheduleRequest : public RpcServiceRequest
{
public:
DeleteScheduleRequest();
~DeleteScheduleRequest();
std::string getScheduleName()const;
void setScheduleName(const std::string& scheduleName);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getFlowName()const;
void setFlowName(const std::string& flowName);
private:
std::string scheduleName_;
std::string requestId_;
std::string flowName_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_DELETESCHEDULEREQUEST_H_
*/
#ifndef ALIBABACLOUD_FNF_MODEL_DELETESCHEDULEREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_DELETESCHEDULEREQUEST_H_
#include <alibabacloud/fnf/FnfExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Fnf {
namespace Model {
class ALIBABACLOUD_FNF_EXPORT DeleteScheduleRequest : public RpcServiceRequest {
public:
DeleteScheduleRequest();
~DeleteScheduleRequest();
std::string getScheduleName() const;
void setScheduleName(const std::string &scheduleName);
std::string getRequestId() const;
void setRequestId(const std::string &requestId);
std::string getFlowName() const;
void setFlowName(const std::string &flowName);
private:
std::string scheduleName_;
std::string requestId_;
std::string flowName_;
};
} // namespace Model
} // namespace Fnf
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FNF_MODEL_DELETESCHEDULEREQUEST_H_

86
fnf/include/alibabacloud/fnf/model/DescribeExecutionRequest.h
View File

@@ -1,57 +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_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);
int getWaitTimeSeconds()const;
void setWaitTimeSeconds(int waitTimeSeconds);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getFlowName()const;
void setFlowName(const std::string& flowName);
private:
std::string executionName_;
int waitTimeSeconds_;
std::string requestId_;
std::string flowName_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_DESCRIBEEXECUTIONREQUEST_H_
*/
#ifndef ALIBABACLOUD_FNF_MODEL_DESCRIBEEXECUTIONREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_DESCRIBEEXECUTIONREQUEST_H_
#include <alibabacloud/fnf/FnfExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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);
int getWaitTimeSeconds() const;
void setWaitTimeSeconds(int waitTimeSeconds);
std::string getRequestId() const;
void setRequestId(const std::string &requestId);
std::string getFlowName() const;
void setFlowName(const std::string &flowName);
private:
std::string executionName_;
int waitTimeSeconds_;
std::string requestId_;
std::string flowName_;
};
} // namespace Model
} // namespace Fnf
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FNF_MODEL_DESCRIBEEXECUTIONREQUEST_H_

74
fnf/include/alibabacloud/fnf/model/DescribeFlowRequest.h
View File

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

2
fnf/include/alibabacloud/fnf/model/DescribeFlowResult.h
View File

@@ -42,6 +42,7 @@ namespace AlibabaCloud
std::string getCreatedTime()const;
std::string getDefinition()const;
std::string getLastModifiedTime()const;
std::string getExecutionMode()const;
std::string getId()const;
std::string getExternalStorageLocation()const;
std::string getRoleArn()const;
@@ -55,6 +56,7 @@ namespace AlibabaCloud
std::string createdTime_;
std::string definition_;
std::string lastModifiedTime_;
std::string executionMode_;
std::string id_;
std::string externalStorageLocation_;
std::string roleArn_;

80
fnf/include/alibabacloud/fnf/model/DescribeScheduleRequest.h
View File

@@ -1,54 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FNF_MODEL_DESCRIBESCHEDULEREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_DESCRIBESCHEDULEREQUEST_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 DescribeScheduleRequest : public RpcServiceRequest
{
public:
DescribeScheduleRequest();
~DescribeScheduleRequest();
std::string getScheduleName()const;
void setScheduleName(const std::string& scheduleName);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getFlowName()const;
void setFlowName(const std::string& flowName);
private:
std::string scheduleName_;
std::string requestId_;
std::string flowName_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_DESCRIBESCHEDULEREQUEST_H_
*/
#ifndef ALIBABACLOUD_FNF_MODEL_DESCRIBESCHEDULEREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_DESCRIBESCHEDULEREQUEST_H_
#include <alibabacloud/fnf/FnfExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Fnf {
namespace Model {
class ALIBABACLOUD_FNF_EXPORT DescribeScheduleRequest : public RpcServiceRequest {
public:
DescribeScheduleRequest();
~DescribeScheduleRequest();
std::string getScheduleName() const;
void setScheduleName(const std::string &scheduleName);
std::string getRequestId() const;
void setRequestId(const std::string &requestId);
std::string getFlowName() const;
void setFlowName(const std::string &flowName);
private:
std::string scheduleName_;
std::string requestId_;
std::string flowName_;
};
} // namespace Model
} // namespace Fnf
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FNF_MODEL_DESCRIBESCHEDULEREQUEST_H_

92
fnf/include/alibabacloud/fnf/model/GetExecutionHistoryRequest.h
View File

@@ -1,60 +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_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_
*/
#ifndef ALIBABACLOUD_FNF_MODEL_GETEXECUTIONHISTORYREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_GETEXECUTIONHISTORYREQUEST_H_
#include <alibabacloud/fnf/FnfExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Fnf
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FNF_MODEL_GETEXECUTIONHISTORYREQUEST_H_

4
fnf/include/alibabacloud/fnf/model/GetExecutionHistoryResult.h
View File

@@ -36,9 +36,9 @@ namespace AlibabaCloud
{
std::string type;
long eventId;
std::string stepName;
std::string eventDetail;
std::string time;
std::string eventDetail;
std::string stepName;
long scheduleEventId;
};

110
fnf/include/alibabacloud/fnf/model/ListExecutionsRequest.h
View File

@@ -1,69 +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_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 getStartedTimeBegin()const;
void setStartedTimeBegin(const std::string& startedTimeBegin);
std::string getExecutionNamePrefix()const;
void setExecutionNamePrefix(const std::string& executionNamePrefix);
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);
std::string getStartedTimeEnd()const;
void setStartedTimeEnd(const std::string& startedTimeEnd);
std::string getStatus()const;
void setStatus(const std::string& status);
private:
std::string startedTimeBegin_;
std::string executionNamePrefix_;
std::string nextToken_;
std::string requestId_;
int limit_;
std::string flowName_;
std::string startedTimeEnd_;
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_LISTEXECUTIONSREQUEST_H_
*/
#ifndef ALIBABACLOUD_FNF_MODEL_LISTEXECUTIONSREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_LISTEXECUTIONSREQUEST_H_
#include <alibabacloud/fnf/FnfExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Fnf {
namespace Model {
class ALIBABACLOUD_FNF_EXPORT ListExecutionsRequest : public RpcServiceRequest {
public:
ListExecutionsRequest();
~ListExecutionsRequest();
std::string getStartedTimeBegin() const;
void setStartedTimeBegin(const std::string &startedTimeBegin);
std::string getExecutionNamePrefix() const;
void setExecutionNamePrefix(const std::string &executionNamePrefix);
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);
std::string getStartedTimeEnd() const;
void setStartedTimeEnd(const std::string &startedTimeEnd);
std::string getStatus() const;
void setStatus(const std::string &status);
private:
std::string startedTimeBegin_;
std::string executionNamePrefix_;
std::string nextToken_;
std::string requestId_;
int limit_;
std::string flowName_;
std::string startedTimeEnd_;
std::string status_;
};
} // namespace Model
} // namespace Fnf
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FNF_MODEL_LISTEXECUTIONSREQUEST_H_

80
fnf/include/alibabacloud/fnf/model/ListFlowsRequest.h
View File

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

1
fnf/include/alibabacloud/fnf/model/ListFlowsResult.h
View File

@@ -39,6 +39,7 @@ namespace AlibabaCloud
std::string createdTime;
std::string definition;
std::string lastModifiedTime;
std::string executionMode;
std::string id;
std::string externalStorageLocation;
std::string roleArn;

86
fnf/include/alibabacloud/fnf/model/ListSchedulesRequest.h
View File

@@ -1,57 +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_LISTSCHEDULESREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_LISTSCHEDULESREQUEST_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 ListSchedulesRequest : public RpcServiceRequest
{
public:
ListSchedulesRequest();
~ListSchedulesRequest();
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_LISTSCHEDULESREQUEST_H_
*/
#ifndef ALIBABACLOUD_FNF_MODEL_LISTSCHEDULESREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_LISTSCHEDULESREQUEST_H_
#include <alibabacloud/fnf/FnfExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Fnf {
namespace Model {
class ALIBABACLOUD_FNF_EXPORT ListSchedulesRequest : public RpcServiceRequest {
public:
ListSchedulesRequest();
~ListSchedulesRequest();
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_;
};
} // namespace Model
} // namespace Fnf
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FNF_MODEL_LISTSCHEDULESREQUEST_H_

86
fnf/include/alibabacloud/fnf/model/ReportTaskFailedRequest.h
View File

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

80
fnf/include/alibabacloud/fnf/model/ReportTaskSucceededRequest.h
View File

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

92
fnf/include/alibabacloud/fnf/model/StartExecutionRequest.h
View File

@@ -1,60 +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_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 getCallbackFnFTaskToken()const;
void setCallbackFnFTaskToken(const std::string& callbackFnFTaskToken);
std::string getExecutionName()const;
void setExecutionName(const std::string& executionName);
std::string getInput()const;
void setInput(const std::string& input);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
std::string getFlowName()const;
void setFlowName(const std::string& flowName);
private:
std::string callbackFnFTaskToken_;
std::string executionName_;
std::string input_;
std::string requestId_;
std::string flowName_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_STARTEXECUTIONREQUEST_H_
*/
#ifndef ALIBABACLOUD_FNF_MODEL_STARTEXECUTIONREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_STARTEXECUTIONREQUEST_H_
#include <alibabacloud/fnf/FnfExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Fnf {
namespace Model {
class ALIBABACLOUD_FNF_EXPORT StartExecutionRequest : public RpcServiceRequest {
public:
StartExecutionRequest();
~StartExecutionRequest();
std::string getCallbackFnFTaskToken() const;
void setCallbackFnFTaskToken(const std::string &callbackFnFTaskToken);
std::string getExecutionName() const;
void setExecutionName(const std::string &executionName);
std::string getInput() const;
void setInput(const std::string &input);
std::string getRequestId() const;
void setRequestId(const std::string &requestId);
std::string getFlowName() const;
void setFlowName(const std::string &flowName);
private:
std::string callbackFnFTaskToken_;
std::string executionName_;
std::string input_;
std::string requestId_;
std::string flowName_;
};
} // namespace Model
} // namespace Fnf
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FNF_MODEL_STARTEXECUTIONREQUEST_H_

51
fnf/include/alibabacloud/fnf/model/StartSyncExecutionRequest.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_STARTSYNCEXECUTIONREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_STARTSYNCEXECUTIONREQUEST_H_
#include <alibabacloud/fnf/FnfExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Fnf {
namespace Model {
class ALIBABACLOUD_FNF_EXPORT StartSyncExecutionRequest : public RpcServiceRequest {
public:
StartSyncExecutionRequest();
~StartSyncExecutionRequest();
std::string getExecutionName() const;
void setExecutionName(const std::string &executionName);
std::string getInput() const;
void setInput(const std::string &input);
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 input_;
std::string requestId_;
std::string flowName_;
};
} // namespace Model
} // namespace Fnf
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FNF_MODEL_STARTSYNCEXECUTIONREQUEST_H_

65
fnf/include/alibabacloud/fnf/model/StartSyncExecutionResult.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_STARTSYNCEXECUTIONRESULT_H_
#define ALIBABACLOUD_FNF_MODEL_STARTSYNCEXECUTIONRESULT_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 StartSyncExecutionResult : public ServiceResult
{
public:
StartSyncExecutionResult();
explicit StartSyncExecutionResult(const std::string &payload);
~StartSyncExecutionResult();
std::string getStatus()const;
std::string getStoppedTime()const;
std::string getFlowName()const;
std::string getOutput()const;
std::string getStartedTime()const;
std::string getErrorCode()const;
std::string getErrorMessage()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
std::string stoppedTime_;
std::string flowName_;
std::string output_;
std::string startedTime_;
std::string errorCode_;
std::string errorMessage_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_STARTSYNCEXECUTIONRESULT_H_

92
fnf/include/alibabacloud/fnf/model/StopExecutionRequest.h
View File

@@ -1,60 +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_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 getCause()const;
void setCause(const std::string& cause);
std::string getError()const;
void setError(const std::string& error);
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 cause_;
std::string error_;
std::string requestId_;
std::string flowName_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_STOPEXECUTIONREQUEST_H_
*/
#ifndef ALIBABACLOUD_FNF_MODEL_STOPEXECUTIONREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_STOPEXECUTIONREQUEST_H_
#include <alibabacloud/fnf/FnfExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 getCause() const;
void setCause(const std::string &cause);
std::string getError() const;
void setError(const std::string &error);
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 cause_;
std::string error_;
std::string requestId_;
std::string flowName_;
};
} // namespace Model
} // namespace Fnf
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FNF_MODEL_STOPEXECUTIONREQUEST_H_

104
fnf/include/alibabacloud/fnf/model/UpdateFlowRequest.h
View File

@@ -1,66 +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_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 getDescription()const;
void setDescription(const std::string& description);
std::string getType()const;
void setType(const std::string& type);
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 getDefinition()const;
void setDefinition(const std::string& definition);
std::string getExternalStorageLocation()const;
void setExternalStorageLocation(const std::string& externalStorageLocation);
private:
std::string description_;
std::string type_;
std::string requestId_;
std::string roleArn_;
std::string name_;
std::string definition_;
std::string externalStorageLocation_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_UPDATEFLOWREQUEST_H_
*/
#ifndef ALIBABACLOUD_FNF_MODEL_UPDATEFLOWREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_UPDATEFLOWREQUEST_H_
#include <alibabacloud/fnf/FnfExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Fnf {
namespace Model {
class ALIBABACLOUD_FNF_EXPORT UpdateFlowRequest : public RpcServiceRequest {
public:
UpdateFlowRequest();
~UpdateFlowRequest();
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getType() const;
void setType(const std::string &type);
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 getDefinition() const;
void setDefinition(const std::string &definition);
std::string getExternalStorageLocation() const;
void setExternalStorageLocation(const std::string &externalStorageLocation);
private:
std::string description_;
std::string type_;
std::string requestId_;
std::string roleArn_;
std::string name_;
std::string definition_;
std::string externalStorageLocation_;
};
} // namespace Model
} // namespace Fnf
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FNF_MODEL_UPDATEFLOWREQUEST_H_

104
fnf/include/alibabacloud/fnf/model/UpdateScheduleRequest.h
View File

@@ -1,66 +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_UPDATESCHEDULEREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_UPDATESCHEDULEREQUEST_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 UpdateScheduleRequest : public RpcServiceRequest
{
public:
UpdateScheduleRequest();
~UpdateScheduleRequest();
std::string getScheduleName()const;
void setScheduleName(const std::string& scheduleName);
std::string getCronExpression()const;
void setCronExpression(const std::string& cronExpression);
std::string getPayload()const;
void setPayload(const std::string& payload);
std::string getRequestId()const;
void setRequestId(const std::string& requestId);
bool getEnable()const;
void setEnable(bool enable);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getFlowName()const;
void setFlowName(const std::string& flowName);
private:
std::string scheduleName_;
std::string cronExpression_;
std::string payload_;
std::string requestId_;
bool enable_;
std::string description_;
std::string flowName_;
};
}
}
}
#endif // !ALIBABACLOUD_FNF_MODEL_UPDATESCHEDULEREQUEST_H_
*/
#ifndef ALIBABACLOUD_FNF_MODEL_UPDATESCHEDULEREQUEST_H_
#define ALIBABACLOUD_FNF_MODEL_UPDATESCHEDULEREQUEST_H_
#include <alibabacloud/fnf/FnfExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Fnf {
namespace Model {
class ALIBABACLOUD_FNF_EXPORT UpdateScheduleRequest : public RpcServiceRequest {
public:
UpdateScheduleRequest();
~UpdateScheduleRequest();
std::string getScheduleName() const;
void setScheduleName(const std::string &scheduleName);
std::string getCronExpression() const;
void setCronExpression(const std::string &cronExpression);
std::string getPayload() const;
void setPayload(const std::string &payload);
std::string getRequestId() const;
void setRequestId(const std::string &requestId);
bool getEnable() const;
void setEnable(bool enable);
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getFlowName() const;
void setFlowName(const std::string &flowName);
private:
std::string scheduleName_;
std::string cronExpression_;
std::string payload_;
std::string requestId_;
bool enable_;
std::string description_;
std::string flowName_;
};
} // namespace Model
} // namespace Fnf
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_FNF_MODEL_UPDATESCHEDULEREQUEST_H_

36
fnf/src/FnfClient.cc
View File

@@ -555,6 +555,42 @@ FnfClient::StartExecutionOutcomeCallable FnfClient::startExecutionCallable(const
return task->get_future();
}
FnfClient::StartSyncExecutionOutcome FnfClient::startSyncExecution(const StartSyncExecutionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StartSyncExecutionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StartSyncExecutionOutcome(StartSyncExecutionResult(outcome.result()));
else
return StartSyncExecutionOutcome(outcome.error());
}
void FnfClient::startSyncExecutionAsync(const StartSyncExecutionRequest& request, const StartSyncExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, startSyncExecution(request), context);
};
asyncExecute(new Runnable(fn));
}
FnfClient::StartSyncExecutionOutcomeCallable FnfClient::startSyncExecutionCallable(const StartSyncExecutionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StartSyncExecutionOutcome()>>(
[this, request]()
{
return this->startSyncExecution(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
FnfClient::StopExecutionOutcome FnfClient::stopExecution(const StopExecutionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

127
fnf/src/model/CreateFlowRequest.cc
View File

@@ -1,106 +1,99 @@
/*
* 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")
{
setMethod(HttpRequest::Method::Post);
}
CreateFlowRequest::~CreateFlowRequest()
{}
std::string CreateFlowRequest::getDescription()const
{
return description_;
*/
#include <alibabacloud/fnf/model/CreateFlowRequest.h>
using AlibabaCloud::Fnf::Model::CreateFlowRequest;
CreateFlowRequest::CreateFlowRequest()
: RpcServiceRequest("fnf", "2019-03-15", "CreateFlow") {
setMethod(HttpRequest::Method::Post);
}
void CreateFlowRequest::setDescription(const std::string& description)
{
description_ = description;
setBodyParameter("Description", description);
CreateFlowRequest::~CreateFlowRequest() {}
std::string CreateFlowRequest::getDescription() const {
return description_;
}
std::string CreateFlowRequest::getType()const
{
return type_;
void CreateFlowRequest::setDescription(const std::string &description) {
description_ = description;
setBodyParameter(std::string("Description"), description);
}
void CreateFlowRequest::setType(const std::string& type)
{
type_ = type;
setBodyParameter("Type", type);
std::string CreateFlowRequest::getType() const {
return type_;
}
std::string CreateFlowRequest::getRequestId()const
{
return requestId_;
void CreateFlowRequest::setType(const std::string &type) {
type_ = type;
setBodyParameter(std::string("Type"), type);
}
void CreateFlowRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setParameter("RequestId", requestId);
std::string CreateFlowRequest::getRequestId() const {
return requestId_;
}
std::string CreateFlowRequest::getRoleArn()const
{
return roleArn_;
void CreateFlowRequest::setRequestId(const std::string &requestId) {
requestId_ = requestId;
setParameter(std::string("RequestId"), requestId);
}
void CreateFlowRequest::setRoleArn(const std::string& roleArn)
{
roleArn_ = roleArn;
setBodyParameter("RoleArn", roleArn);
std::string CreateFlowRequest::getRoleArn() const {
return roleArn_;
}
std::string CreateFlowRequest::getName()const
{
return name_;
void CreateFlowRequest::setRoleArn(const std::string &roleArn) {
roleArn_ = roleArn;
setBodyParameter(std::string("RoleArn"), roleArn);
}
void CreateFlowRequest::setName(const std::string& name)
{
name_ = name;
setBodyParameter("Name", name);
std::string CreateFlowRequest::getName() const {
return name_;
}
std::string CreateFlowRequest::getDefinition()const
{
return definition_;
void CreateFlowRequest::setName(const std::string &name) {
name_ = name;
setBodyParameter(std::string("Name"), name);
}
void CreateFlowRequest::setDefinition(const std::string& definition)
{
definition_ = definition;
setBodyParameter("Definition", definition);
std::string CreateFlowRequest::getDefinition() const {
return definition_;
}
std::string CreateFlowRequest::getExternalStorageLocation()const
{
return externalStorageLocation_;
void CreateFlowRequest::setDefinition(const std::string &definition) {
definition_ = definition;
setBodyParameter(std::string("Definition"), definition);
}
void CreateFlowRequest::setExternalStorageLocation(const std::string& externalStorageLocation)
{
externalStorageLocation_ = externalStorageLocation;
setBodyParameter("ExternalStorageLocation", externalStorageLocation);
std::string CreateFlowRequest::getExternalStorageLocation() const {
return externalStorageLocation_;
}
void CreateFlowRequest::setExternalStorageLocation(const std::string &externalStorageLocation) {
externalStorageLocation_ = externalStorageLocation;
setBodyParameter(std::string("ExternalStorageLocation"), externalStorageLocation);
}
std::string CreateFlowRequest::getExecutionMode() const {
return executionMode_;
}
void CreateFlowRequest::setExecutionMode(const std::string &executionMode) {
executionMode_ = executionMode;
setBodyParameter(std::string("ExecutionMode"), executionMode);
}

27
fnf/src/model/CreateFlowResult.cc
View File

@@ -39,24 +39,26 @@ void CreateFlowResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
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["Definition"].isNull())
definition_ = value["Definition"].asString();
if(!value["RoleArn"].isNull())
roleArn_ = value["RoleArn"].asString();
if(!value["Description"].isNull())
description_ = value["Description"].asString();
if(!value["ExternalStorageLocation"].isNull())
externalStorageLocation_ = value["ExternalStorageLocation"].asString();
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["CreatedTime"].isNull())
createdTime_ = value["CreatedTime"].asString();
if(!value["LastModifiedTime"].isNull())
lastModifiedTime_ = value["LastModifiedTime"].asString();
if(!value["ExternalStorageLocation"].isNull())
externalStorageLocation_ = value["ExternalStorageLocation"].asString();
if(!value["Id"].isNull())
id_ = value["Id"].asString();
if(!value["ExecutionMode"].isNull())
executionMode_ = value["ExecutionMode"].asString();
}
@@ -85,6 +87,11 @@ std::string CreateFlowResult::getLastModifiedTime()const
return lastModifiedTime_;
}
std::string CreateFlowResult::getExecutionMode()const
{
return executionMode_;
}
std::string CreateFlowResult::getId()const
{
return id_;

118
fnf/src/model/CreateScheduleRequest.cc
View File

@@ -1,106 +1,90 @@
/*
* 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/CreateScheduleRequest.h>
using AlibabaCloud::Fnf::Model::CreateScheduleRequest;
CreateScheduleRequest::CreateScheduleRequest() :
RpcServiceRequest("fnf", "2019-03-15", "CreateSchedule")
{
setMethod(HttpRequest::Method::Post);
}
CreateScheduleRequest::~CreateScheduleRequest()
{}
std::string CreateScheduleRequest::getScheduleName()const
{
return scheduleName_;
*/
#include <alibabacloud/fnf/model/CreateScheduleRequest.h>
using AlibabaCloud::Fnf::Model::CreateScheduleRequest;
CreateScheduleRequest::CreateScheduleRequest()
: RpcServiceRequest("fnf", "2019-03-15", "CreateSchedule") {
setMethod(HttpRequest::Method::Post);
}
void CreateScheduleRequest::setScheduleName(const std::string& scheduleName)
{
scheduleName_ = scheduleName;
setBodyParameter("ScheduleName", scheduleName);
CreateScheduleRequest::~CreateScheduleRequest() {}
std::string CreateScheduleRequest::getScheduleName() const {
return scheduleName_;
}
std::string CreateScheduleRequest::getCronExpression()const
{
return cronExpression_;
void CreateScheduleRequest::setScheduleName(const std::string &scheduleName) {
scheduleName_ = scheduleName;
setBodyParameter(std::string("ScheduleName"), scheduleName);
}
void CreateScheduleRequest::setCronExpression(const std::string& cronExpression)
{
cronExpression_ = cronExpression;
setBodyParameter("CronExpression", cronExpression);
std::string CreateScheduleRequest::getCronExpression() const {
return cronExpression_;
}
std::string CreateScheduleRequest::getPayload()const
{
return payload_;
void CreateScheduleRequest::setCronExpression(const std::string &cronExpression) {
cronExpression_ = cronExpression;
setBodyParameter(std::string("CronExpression"), cronExpression);
}
void CreateScheduleRequest::setPayload(const std::string& payload)
{
payload_ = payload;
setBodyParameter("Payload", payload);
std::string CreateScheduleRequest::getPayload() const {
return payload_;
}
std::string CreateScheduleRequest::getRequestId()const
{
return requestId_;
void CreateScheduleRequest::setPayload(const std::string &payload) {
payload_ = payload;
setBodyParameter(std::string("Payload"), payload);
}
void CreateScheduleRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setParameter("RequestId", requestId);
std::string CreateScheduleRequest::getRequestId() const {
return requestId_;
}
bool CreateScheduleRequest::getEnable()const
{
return enable_;
void CreateScheduleRequest::setRequestId(const std::string &requestId) {
requestId_ = requestId;
setParameter(std::string("RequestId"), requestId);
}
void CreateScheduleRequest::setEnable(bool enable)
{
enable_ = enable;
setBodyParameter("Enable", enable ? "true" : "false");
bool CreateScheduleRequest::getEnable() const {
return enable_;
}
std::string CreateScheduleRequest::getDescription()const
{
return description_;
void CreateScheduleRequest::setEnable(bool enable) {
enable_ = enable;
setBodyParameter(std::string("Enable"), enable ? "true" : "false");
}
void CreateScheduleRequest::setDescription(const std::string& description)
{
description_ = description;
setBodyParameter("Description", description);
std::string CreateScheduleRequest::getDescription() const {
return description_;
}
std::string CreateScheduleRequest::getFlowName()const
{
return flowName_;
void CreateScheduleRequest::setDescription(const std::string &description) {
description_ = description;
setBodyParameter(std::string("Description"), description);
}
void CreateScheduleRequest::setFlowName(const std::string& flowName)
{
flowName_ = flowName;
setBodyParameter("FlowName", flowName);
std::string CreateScheduleRequest::getFlowName() const {
return flowName_;
}
void CreateScheduleRequest::setFlowName(const std::string &flowName) {
flowName_ = flowName;
setBodyParameter(std::string("FlowName"), flowName);
}

12
fnf/src/model/CreateScheduleResult.cc
View File

@@ -39,22 +39,22 @@ void CreateScheduleResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ScheduleName"].isNull())
scheduleName_ = value["ScheduleName"].asString();
if(!value["Description"].isNull())
description_ = value["Description"].asString();
if(!value["ScheduleId"].isNull())
scheduleId_ = value["ScheduleId"].asString();
if(!value["Payload"].isNull())
payload_ = value["Payload"].asString();
if(!value["CronExpression"].isNull())
cronExpression_ = value["CronExpression"].asString();
if(!value["Enable"].isNull())
enable_ = value["Enable"].asString() == "true";
if(!value["ScheduleName"].isNull())
scheduleName_ = value["ScheduleName"].asString();
if(!value["CreatedTime"].isNull())
createdTime_ = value["CreatedTime"].asString();
if(!value["LastModifiedTime"].isNull())
lastModifiedTime_ = value["LastModifiedTime"].asString();
if(!value["CronExpression"].isNull())
cronExpression_ = value["CronExpression"].asString();
if(!value["Enable"].isNull())
enable_ = value["Enable"].asString() == "true";
}

58
fnf/src/model/DeleteFlowRequest.cc
View File

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

70
fnf/src/model/DeleteScheduleRequest.cc
View File

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

82
fnf/src/model/DescribeExecutionRequest.cc
View File

@@ -1,73 +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.
*/
#include <alibabacloud/fnf/model/DescribeExecutionRequest.h>
using AlibabaCloud::Fnf::Model::DescribeExecutionRequest;
DescribeExecutionRequest::DescribeExecutionRequest() :
RpcServiceRequest("fnf", "2019-03-15", "DescribeExecution")
{
setMethod(HttpRequest::Method::Get);
}
DescribeExecutionRequest::~DescribeExecutionRequest()
{}
std::string DescribeExecutionRequest::getExecutionName()const
{
return executionName_;
*/
#include <alibabacloud/fnf/model/DescribeExecutionRequest.h>
using AlibabaCloud::Fnf::Model::DescribeExecutionRequest;
DescribeExecutionRequest::DescribeExecutionRequest()
: RpcServiceRequest("fnf", "2019-03-15", "DescribeExecution") {
setMethod(HttpRequest::Method::Get);
}
void DescribeExecutionRequest::setExecutionName(const std::string& executionName)
{
executionName_ = executionName;
setParameter("ExecutionName", executionName);
DescribeExecutionRequest::~DescribeExecutionRequest() {}
std::string DescribeExecutionRequest::getExecutionName() const {
return executionName_;
}
int DescribeExecutionRequest::getWaitTimeSeconds()const
{
return waitTimeSeconds_;
void DescribeExecutionRequest::setExecutionName(const std::string &executionName) {
executionName_ = executionName;
setParameter(std::string("ExecutionName"), executionName);
}
void DescribeExecutionRequest::setWaitTimeSeconds(int waitTimeSeconds)
{
waitTimeSeconds_ = waitTimeSeconds;
setParameter("WaitTimeSeconds", std::to_string(waitTimeSeconds));
int DescribeExecutionRequest::getWaitTimeSeconds() const {
return waitTimeSeconds_;
}
std::string DescribeExecutionRequest::getRequestId()const
{
return requestId_;
void DescribeExecutionRequest::setWaitTimeSeconds(int waitTimeSeconds) {
waitTimeSeconds_ = waitTimeSeconds;
setParameter(std::string("WaitTimeSeconds"), std::to_string(waitTimeSeconds));
}
void DescribeExecutionRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setParameter("RequestId", requestId);
std::string DescribeExecutionRequest::getRequestId() const {
return requestId_;
}
std::string DescribeExecutionRequest::getFlowName()const
{
return flowName_;
void DescribeExecutionRequest::setRequestId(const std::string &requestId) {
requestId_ = requestId;
setParameter(std::string("RequestId"), requestId);
}
void DescribeExecutionRequest::setFlowName(const std::string& flowName)
{
flowName_ = flowName;
setParameter("FlowName", flowName);
std::string DescribeExecutionRequest::getFlowName() const {
return flowName_;
}
void DescribeExecutionRequest::setFlowName(const std::string &flowName) {
flowName_ = flowName;
setParameter(std::string("FlowName"), flowName);
}

24
fnf/src/model/DescribeExecutionResult.cc
View File

@@ -39,26 +39,26 @@ void DescribeExecutionResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
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();
if(!value["StartedTime"].isNull())
startedTime_ = value["StartedTime"].asString();
if(!value["FlowDefinition"].isNull())
flowDefinition_ = value["FlowDefinition"].asString();
if(!value["ExternalInputUri"].isNull())
externalInputUri_ = value["ExternalInputUri"].asString();
if(!value["Output"].isNull())
output_ = value["Output"].asString();
if(!value["FlowName"].isNull())
flowName_ = value["FlowName"].asString();
if(!value["ExternalOutputUri"].isNull())
externalOutputUri_ = value["ExternalOutputUri"].asString();
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["Input"].isNull())
input_ = value["Input"].asString();
}

58
fnf/src/model/DescribeFlowRequest.cc
View File

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

27
fnf/src/model/DescribeFlowResult.cc
View File

@@ -39,24 +39,26 @@ void DescribeFlowResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
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["Definition"].isNull())
definition_ = value["Definition"].asString();
if(!value["RoleArn"].isNull())
roleArn_ = value["RoleArn"].asString();
if(!value["Description"].isNull())
description_ = value["Description"].asString();
if(!value["ExternalStorageLocation"].isNull())
externalStorageLocation_ = value["ExternalStorageLocation"].asString();
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["CreatedTime"].isNull())
createdTime_ = value["CreatedTime"].asString();
if(!value["LastModifiedTime"].isNull())
lastModifiedTime_ = value["LastModifiedTime"].asString();
if(!value["ExternalStorageLocation"].isNull())
externalStorageLocation_ = value["ExternalStorageLocation"].asString();
if(!value["Id"].isNull())
id_ = value["Id"].asString();
if(!value["ExecutionMode"].isNull())
executionMode_ = value["ExecutionMode"].asString();
}
@@ -85,6 +87,11 @@ std::string DescribeFlowResult::getLastModifiedTime()const
return lastModifiedTime_;
}
std::string DescribeFlowResult::getExecutionMode()const
{
return executionMode_;
}
std::string DescribeFlowResult::getId()const
{
return id_;

70
fnf/src/model/DescribeScheduleRequest.cc
View File

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

12
fnf/src/model/DescribeScheduleResult.cc
View File

@@ -39,22 +39,22 @@ void DescribeScheduleResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ScheduleName"].isNull())
scheduleName_ = value["ScheduleName"].asString();
if(!value["Description"].isNull())
description_ = value["Description"].asString();
if(!value["ScheduleId"].isNull())
scheduleId_ = value["ScheduleId"].asString();
if(!value["Payload"].isNull())
payload_ = value["Payload"].asString();
if(!value["CronExpression"].isNull())
cronExpression_ = value["CronExpression"].asString();
if(!value["Enable"].isNull())
enable_ = value["Enable"].asString() == "true";
if(!value["ScheduleName"].isNull())
scheduleName_ = value["ScheduleName"].asString();
if(!value["CreatedTime"].isNull())
createdTime_ = value["CreatedTime"].asString();
if(!value["LastModifiedTime"].isNull())
lastModifiedTime_ = value["LastModifiedTime"].asString();
if(!value["CronExpression"].isNull())
cronExpression_ = value["CronExpression"].asString();
if(!value["Enable"].isNull())
enable_ = value["Enable"].asString() == "true";
}

94
fnf/src/model/GetExecutionHistoryRequest.cc
View File

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

8
fnf/src/model/GetExecutionHistoryResult.cc
View File

@@ -43,18 +43,18 @@ void GetExecutionHistoryResult::parse(const std::string &payload)
for (auto valueEventsEventsItem : allEventsNode)
{
EventsItem eventsObject;
if(!valueEventsEventsItem["StepName"].isNull())
eventsObject.stepName = valueEventsEventsItem["StepName"].asString();
if(!valueEventsEventsItem["Type"].isNull())
eventsObject.type = valueEventsEventsItem["Type"].asString();
if(!valueEventsEventsItem["EventId"].isNull())
eventsObject.eventId = std::stol(valueEventsEventsItem["EventId"].asString());
if(!valueEventsEventsItem["Time"].isNull())
eventsObject.time = valueEventsEventsItem["Time"].asString();
if(!valueEventsEventsItem["ScheduleEventId"].isNull())
eventsObject.scheduleEventId = std::stol(valueEventsEventsItem["ScheduleEventId"].asString());
if(!valueEventsEventsItem["EventDetail"].isNull())
eventsObject.eventDetail = valueEventsEventsItem["EventDetail"].asString();
if(!valueEventsEventsItem["Time"].isNull())
eventsObject.time = valueEventsEventsItem["Time"].asString();
if(!valueEventsEventsItem["StepName"].isNull())
eventsObject.stepName = valueEventsEventsItem["StepName"].asString();
events_.push_back(eventsObject);
}
if(!value["NextToken"].isNull())

130
fnf/src/model/ListExecutionsRequest.cc
View File

@@ -1,117 +1,99 @@
/*
* 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")
{
setMethod(HttpRequest::Method::Get);
}
ListExecutionsRequest::~ListExecutionsRequest()
{}
std::string ListExecutionsRequest::getStartedTimeBegin()const
{
return startedTimeBegin_;
*/
#include <alibabacloud/fnf/model/ListExecutionsRequest.h>
using AlibabaCloud::Fnf::Model::ListExecutionsRequest;
ListExecutionsRequest::ListExecutionsRequest()
: RpcServiceRequest("fnf", "2019-03-15", "ListExecutions") {
setMethod(HttpRequest::Method::Get);
}
void ListExecutionsRequest::setStartedTimeBegin(const std::string& startedTimeBegin)
{
startedTimeBegin_ = startedTimeBegin;
setParameter("StartedTimeBegin", startedTimeBegin);
ListExecutionsRequest::~ListExecutionsRequest() {}
std::string ListExecutionsRequest::getStartedTimeBegin() const {
return startedTimeBegin_;
}
std::string ListExecutionsRequest::getExecutionNamePrefix()const
{
return executionNamePrefix_;
void ListExecutionsRequest::setStartedTimeBegin(const std::string &startedTimeBegin) {
startedTimeBegin_ = startedTimeBegin;
setParameter(std::string("StartedTimeBegin"), startedTimeBegin);
}
void ListExecutionsRequest::setExecutionNamePrefix(const std::string& executionNamePrefix)
{
executionNamePrefix_ = executionNamePrefix;
setParameter("ExecutionNamePrefix", executionNamePrefix);
std::string ListExecutionsRequest::getExecutionNamePrefix() const {
return executionNamePrefix_;
}
std::string ListExecutionsRequest::getNextToken()const
{
return nextToken_;
void ListExecutionsRequest::setExecutionNamePrefix(const std::string &executionNamePrefix) {
executionNamePrefix_ = executionNamePrefix;
setParameter(std::string("ExecutionNamePrefix"), executionNamePrefix);
}
void ListExecutionsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
std::string ListExecutionsRequest::getNextToken() const {
return nextToken_;
}
std::string ListExecutionsRequest::getRequestId()const
{
return requestId_;
void ListExecutionsRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
void ListExecutionsRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setParameter("RequestId", requestId);
std::string ListExecutionsRequest::getRequestId() const {
return requestId_;
}
int ListExecutionsRequest::getLimit()const
{
return limit_;
void ListExecutionsRequest::setRequestId(const std::string &requestId) {
requestId_ = requestId;
setParameter(std::string("RequestId"), requestId);
}
void ListExecutionsRequest::setLimit(int limit)
{
limit_ = limit;
setParameter("Limit", std::to_string(limit));
int ListExecutionsRequest::getLimit() const {
return limit_;
}
std::string ListExecutionsRequest::getFlowName()const
{
return flowName_;
void ListExecutionsRequest::setLimit(int limit) {
limit_ = limit;
setParameter(std::string("Limit"), std::to_string(limit));
}
void ListExecutionsRequest::setFlowName(const std::string& flowName)
{
flowName_ = flowName;
setParameter("FlowName", flowName);
std::string ListExecutionsRequest::getFlowName() const {
return flowName_;
}
std::string ListExecutionsRequest::getStartedTimeEnd()const
{
return startedTimeEnd_;
void ListExecutionsRequest::setFlowName(const std::string &flowName) {
flowName_ = flowName;
setParameter(std::string("FlowName"), flowName);
}
void ListExecutionsRequest::setStartedTimeEnd(const std::string& startedTimeEnd)
{
startedTimeEnd_ = startedTimeEnd;
setParameter("StartedTimeEnd", startedTimeEnd);
std::string ListExecutionsRequest::getStartedTimeEnd() const {
return startedTimeEnd_;
}
std::string ListExecutionsRequest::getStatus()const
{
return status_;
void ListExecutionsRequest::setStartedTimeEnd(const std::string &startedTimeEnd) {
startedTimeEnd_ = startedTimeEnd;
setParameter(std::string("StartedTimeEnd"), startedTimeEnd);
}
void ListExecutionsRequest::setStatus(const std::string& status)
{
status_ = status;
setParameter("Status", status);
std::string ListExecutionsRequest::getStatus() const {
return status_;
}
void ListExecutionsRequest::setStatus(const std::string &status) {
status_ = status;
setParameter(std::string("Status"), status);
}

24
fnf/src/model/ListExecutionsResult.cc
View File

@@ -43,26 +43,26 @@ void ListExecutionsResult::parse(const std::string &payload)
for (auto valueExecutionsExecutionsItem : allExecutionsNode)
{
ExecutionsItem executionsObject;
if(!valueExecutionsExecutionsItem["Name"].isNull())
executionsObject.name = valueExecutionsExecutionsItem["Name"].asString();
if(!valueExecutionsExecutionsItem["FlowName"].isNull())
executionsObject.flowName = valueExecutionsExecutionsItem["FlowName"].asString();
if(!valueExecutionsExecutionsItem["FlowDefinition"].isNull())
executionsObject.flowDefinition = valueExecutionsExecutionsItem["FlowDefinition"].asString();
if(!valueExecutionsExecutionsItem["Input"].isNull())
executionsObject.input = valueExecutionsExecutionsItem["Input"].asString();
if(!valueExecutionsExecutionsItem["Output"].isNull())
executionsObject.output = valueExecutionsExecutionsItem["Output"].asString();
if(!valueExecutionsExecutionsItem["Status"].isNull())
executionsObject.status = valueExecutionsExecutionsItem["Status"].asString();
if(!valueExecutionsExecutionsItem["StartedTime"].isNull())
executionsObject.startedTime = valueExecutionsExecutionsItem["StartedTime"].asString();
if(!valueExecutionsExecutionsItem["StoppedTime"].isNull())
executionsObject.stoppedTime = valueExecutionsExecutionsItem["StoppedTime"].asString();
if(!valueExecutionsExecutionsItem["StartedTime"].isNull())
executionsObject.startedTime = valueExecutionsExecutionsItem["StartedTime"].asString();
if(!valueExecutionsExecutionsItem["FlowDefinition"].isNull())
executionsObject.flowDefinition = valueExecutionsExecutionsItem["FlowDefinition"].asString();
if(!valueExecutionsExecutionsItem["ExternalInputUri"].isNull())
executionsObject.externalInputUri = valueExecutionsExecutionsItem["ExternalInputUri"].asString();
if(!valueExecutionsExecutionsItem["Output"].isNull())
executionsObject.output = valueExecutionsExecutionsItem["Output"].asString();
if(!valueExecutionsExecutionsItem["FlowName"].isNull())
executionsObject.flowName = valueExecutionsExecutionsItem["FlowName"].asString();
if(!valueExecutionsExecutionsItem["ExternalOutputUri"].isNull())
executionsObject.externalOutputUri = valueExecutionsExecutionsItem["ExternalOutputUri"].asString();
if(!valueExecutionsExecutionsItem["Name"].isNull())
executionsObject.name = valueExecutionsExecutionsItem["Name"].asString();
if(!valueExecutionsExecutionsItem["Input"].isNull())
executionsObject.input = valueExecutionsExecutionsItem["Input"].asString();
executions_.push_back(executionsObject);
}
if(!value["NextToken"].isNull())

70
fnf/src/model/ListFlowsRequest.cc
View File

@@ -1,62 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/fnf/model/ListFlowsRequest.h>
using AlibabaCloud::Fnf::Model::ListFlowsRequest;
ListFlowsRequest::ListFlowsRequest() :
RpcServiceRequest("fnf", "2019-03-15", "ListFlows")
{
setMethod(HttpRequest::Method::Get);
}
ListFlowsRequest::~ListFlowsRequest()
{}
std::string ListFlowsRequest::getNextToken()const
{
return nextToken_;
*/
#include <alibabacloud/fnf/model/ListFlowsRequest.h>
using AlibabaCloud::Fnf::Model::ListFlowsRequest;
ListFlowsRequest::ListFlowsRequest()
: RpcServiceRequest("fnf", "2019-03-15", "ListFlows") {
setMethod(HttpRequest::Method::Get);
}
void ListFlowsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
ListFlowsRequest::~ListFlowsRequest() {}
std::string ListFlowsRequest::getNextToken() const {
return nextToken_;
}
std::string ListFlowsRequest::getRequestId()const
{
return requestId_;
void ListFlowsRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
void ListFlowsRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setParameter("RequestId", requestId);
std::string ListFlowsRequest::getRequestId() const {
return requestId_;
}
int ListFlowsRequest::getLimit()const
{
return limit_;
void ListFlowsRequest::setRequestId(const std::string &requestId) {
requestId_ = requestId;
setParameter(std::string("RequestId"), requestId);
}
void ListFlowsRequest::setLimit(int limit)
{
limit_ = limit;
setParameter("Limit", std::to_string(limit));
int ListFlowsRequest::getLimit() const {
return limit_;
}
void ListFlowsRequest::setLimit(int limit) {
limit_ = limit;
setParameter(std::string("Limit"), std::to_string(limit));
}

22
fnf/src/model/ListFlowsResult.cc
View File

@@ -43,24 +43,26 @@ void ListFlowsResult::parse(const std::string &payload)
for (auto valueFlowsFlowsItem : allFlowsNode)
{
FlowsItem flowsObject;
if(!valueFlowsFlowsItem["Name"].isNull())
flowsObject.name = valueFlowsFlowsItem["Name"].asString();
if(!valueFlowsFlowsItem["Description"].isNull())
flowsObject.description = valueFlowsFlowsItem["Description"].asString();
if(!valueFlowsFlowsItem["Definition"].isNull())
flowsObject.definition = valueFlowsFlowsItem["Definition"].asString();
if(!valueFlowsFlowsItem["Id"].isNull())
flowsObject.id = valueFlowsFlowsItem["Id"].asString();
if(!valueFlowsFlowsItem["Type"].isNull())
flowsObject.type = valueFlowsFlowsItem["Type"].asString();
if(!valueFlowsFlowsItem["Definition"].isNull())
flowsObject.definition = valueFlowsFlowsItem["Definition"].asString();
if(!valueFlowsFlowsItem["RoleArn"].isNull())
flowsObject.roleArn = valueFlowsFlowsItem["RoleArn"].asString();
if(!valueFlowsFlowsItem["Description"].isNull())
flowsObject.description = valueFlowsFlowsItem["Description"].asString();
if(!valueFlowsFlowsItem["ExternalStorageLocation"].isNull())
flowsObject.externalStorageLocation = valueFlowsFlowsItem["ExternalStorageLocation"].asString();
if(!valueFlowsFlowsItem["Name"].isNull())
flowsObject.name = valueFlowsFlowsItem["Name"].asString();
if(!valueFlowsFlowsItem["CreatedTime"].isNull())
flowsObject.createdTime = valueFlowsFlowsItem["CreatedTime"].asString();
if(!valueFlowsFlowsItem["LastModifiedTime"].isNull())
flowsObject.lastModifiedTime = valueFlowsFlowsItem["LastModifiedTime"].asString();
if(!valueFlowsFlowsItem["ExternalStorageLocation"].isNull())
flowsObject.externalStorageLocation = valueFlowsFlowsItem["ExternalStorageLocation"].asString();
if(!valueFlowsFlowsItem["Id"].isNull())
flowsObject.id = valueFlowsFlowsItem["Id"].asString();
if(!valueFlowsFlowsItem["ExecutionMode"].isNull())
flowsObject.executionMode = valueFlowsFlowsItem["ExecutionMode"].asString();
flows_.push_back(flowsObject);
}
if(!value["NextToken"].isNull())

82
fnf/src/model/ListSchedulesRequest.cc
View File

@@ -1,73 +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.
*/
#include <alibabacloud/fnf/model/ListSchedulesRequest.h>
using AlibabaCloud::Fnf::Model::ListSchedulesRequest;
ListSchedulesRequest::ListSchedulesRequest() :
RpcServiceRequest("fnf", "2019-03-15", "ListSchedules")
{
setMethod(HttpRequest::Method::Get);
}
ListSchedulesRequest::~ListSchedulesRequest()
{}
std::string ListSchedulesRequest::getNextToken()const
{
return nextToken_;
*/
#include <alibabacloud/fnf/model/ListSchedulesRequest.h>
using AlibabaCloud::Fnf::Model::ListSchedulesRequest;
ListSchedulesRequest::ListSchedulesRequest()
: RpcServiceRequest("fnf", "2019-03-15", "ListSchedules") {
setMethod(HttpRequest::Method::Get);
}
void ListSchedulesRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
ListSchedulesRequest::~ListSchedulesRequest() {}
std::string ListSchedulesRequest::getNextToken() const {
return nextToken_;
}
std::string ListSchedulesRequest::getRequestId()const
{
return requestId_;
void ListSchedulesRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
void ListSchedulesRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setParameter("RequestId", requestId);
std::string ListSchedulesRequest::getRequestId() const {
return requestId_;
}
int ListSchedulesRequest::getLimit()const
{
return limit_;
void ListSchedulesRequest::setRequestId(const std::string &requestId) {
requestId_ = requestId;
setParameter(std::string("RequestId"), requestId);
}
void ListSchedulesRequest::setLimit(int limit)
{
limit_ = limit;
setParameter("Limit", std::to_string(limit));
int ListSchedulesRequest::getLimit() const {
return limit_;
}
std::string ListSchedulesRequest::getFlowName()const
{
return flowName_;
void ListSchedulesRequest::setLimit(int limit) {
limit_ = limit;
setParameter(std::string("Limit"), std::to_string(limit));
}
void ListSchedulesRequest::setFlowName(const std::string& flowName)
{
flowName_ = flowName;
setParameter("FlowName", flowName);
std::string ListSchedulesRequest::getFlowName() const {
return flowName_;
}
void ListSchedulesRequest::setFlowName(const std::string &flowName) {
flowName_ = flowName;
setParameter(std::string("FlowName"), flowName);
}

12
fnf/src/model/ListSchedulesResult.cc
View File

@@ -43,22 +43,22 @@ void ListSchedulesResult::parse(const std::string &payload)
for (auto valueSchedulesSchedulesItem : allSchedulesNode)
{
SchedulesItem schedulesObject;
if(!valueSchedulesSchedulesItem["ScheduleName"].isNull())
schedulesObject.scheduleName = valueSchedulesSchedulesItem["ScheduleName"].asString();
if(!valueSchedulesSchedulesItem["Description"].isNull())
schedulesObject.description = valueSchedulesSchedulesItem["Description"].asString();
if(!valueSchedulesSchedulesItem["ScheduleId"].isNull())
schedulesObject.scheduleId = valueSchedulesSchedulesItem["ScheduleId"].asString();
if(!valueSchedulesSchedulesItem["Payload"].isNull())
schedulesObject.payload = valueSchedulesSchedulesItem["Payload"].asString();
if(!valueSchedulesSchedulesItem["CronExpression"].isNull())
schedulesObject.cronExpression = valueSchedulesSchedulesItem["CronExpression"].asString();
if(!valueSchedulesSchedulesItem["Enable"].isNull())
schedulesObject.enable = valueSchedulesSchedulesItem["Enable"].asString() == "true";
if(!valueSchedulesSchedulesItem["ScheduleName"].isNull())
schedulesObject.scheduleName = valueSchedulesSchedulesItem["ScheduleName"].asString();
if(!valueSchedulesSchedulesItem["CreatedTime"].isNull())
schedulesObject.createdTime = valueSchedulesSchedulesItem["CreatedTime"].asString();
if(!valueSchedulesSchedulesItem["LastModifiedTime"].isNull())
schedulesObject.lastModifiedTime = valueSchedulesSchedulesItem["LastModifiedTime"].asString();
if(!valueSchedulesSchedulesItem["CronExpression"].isNull())
schedulesObject.cronExpression = valueSchedulesSchedulesItem["CronExpression"].asString();
if(!valueSchedulesSchedulesItem["Enable"].isNull())
schedulesObject.enable = valueSchedulesSchedulesItem["Enable"].asString() == "true";
schedules_.push_back(schedulesObject);
}
if(!value["NextToken"].isNull())

82
fnf/src/model/ReportTaskFailedRequest.cc
View File

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

70
fnf/src/model/ReportTaskSucceededRequest.cc
View File

@@ -1,62 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/fnf/model/ReportTaskSucceededRequest.h>
using AlibabaCloud::Fnf::Model::ReportTaskSucceededRequest;
ReportTaskSucceededRequest::ReportTaskSucceededRequest() :
RpcServiceRequest("fnf", "2019-03-15", "ReportTaskSucceeded")
{
setMethod(HttpRequest::Method::Post);
}
ReportTaskSucceededRequest::~ReportTaskSucceededRequest()
{}
std::string ReportTaskSucceededRequest::getOutput()const
{
return output_;
*/
#include <alibabacloud/fnf/model/ReportTaskSucceededRequest.h>
using AlibabaCloud::Fnf::Model::ReportTaskSucceededRequest;
ReportTaskSucceededRequest::ReportTaskSucceededRequest()
: RpcServiceRequest("fnf", "2019-03-15", "ReportTaskSucceeded") {
setMethod(HttpRequest::Method::Post);
}
void ReportTaskSucceededRequest::setOutput(const std::string& output)
{
output_ = output;
setBodyParameter("Output", output);
ReportTaskSucceededRequest::~ReportTaskSucceededRequest() {}
std::string ReportTaskSucceededRequest::getOutput() const {
return output_;
}
std::string ReportTaskSucceededRequest::getRequestId()const
{
return requestId_;
void ReportTaskSucceededRequest::setOutput(const std::string &output) {
output_ = output;
setBodyParameter(std::string("Output"), output);
}
void ReportTaskSucceededRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setParameter("RequestId", requestId);
std::string ReportTaskSucceededRequest::getRequestId() const {
return requestId_;
}
std::string ReportTaskSucceededRequest::getTaskToken()const
{
return taskToken_;
void ReportTaskSucceededRequest::setRequestId(const std::string &requestId) {
requestId_ = requestId;
setParameter(std::string("RequestId"), requestId);
}
void ReportTaskSucceededRequest::setTaskToken(const std::string& taskToken)
{
taskToken_ = taskToken;
setParameter("TaskToken", taskToken);
std::string ReportTaskSucceededRequest::getTaskToken() const {
return taskToken_;
}
void ReportTaskSucceededRequest::setTaskToken(const std::string &taskToken) {
taskToken_ = taskToken;
setParameter(std::string("TaskToken"), taskToken);
}

94
fnf/src/model/StartExecutionRequest.cc
View File

@@ -1,84 +1,72 @@
/*
* 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")
{
setMethod(HttpRequest::Method::Post);
}
StartExecutionRequest::~StartExecutionRequest()
{}
std::string StartExecutionRequest::getCallbackFnFTaskToken()const
{
return callbackFnFTaskToken_;
*/
#include <alibabacloud/fnf/model/StartExecutionRequest.h>
using AlibabaCloud::Fnf::Model::StartExecutionRequest;
StartExecutionRequest::StartExecutionRequest()
: RpcServiceRequest("fnf", "2019-03-15", "StartExecution") {
setMethod(HttpRequest::Method::Post);
}
void StartExecutionRequest::setCallbackFnFTaskToken(const std::string& callbackFnFTaskToken)
{
callbackFnFTaskToken_ = callbackFnFTaskToken;
setBodyParameter("CallbackFnFTaskToken", callbackFnFTaskToken);
StartExecutionRequest::~StartExecutionRequest() {}
std::string StartExecutionRequest::getCallbackFnFTaskToken() const {
return callbackFnFTaskToken_;
}
std::string StartExecutionRequest::getExecutionName()const
{
return executionName_;
void StartExecutionRequest::setCallbackFnFTaskToken(const std::string &callbackFnFTaskToken) {
callbackFnFTaskToken_ = callbackFnFTaskToken;
setBodyParameter(std::string("CallbackFnFTaskToken"), callbackFnFTaskToken);
}
void StartExecutionRequest::setExecutionName(const std::string& executionName)
{
executionName_ = executionName;
setBodyParameter("ExecutionName", executionName);
std::string StartExecutionRequest::getExecutionName() const {
return executionName_;
}
std::string StartExecutionRequest::getInput()const
{
return input_;
void StartExecutionRequest::setExecutionName(const std::string &executionName) {
executionName_ = executionName;
setBodyParameter(std::string("ExecutionName"), executionName);
}
void StartExecutionRequest::setInput(const std::string& input)
{
input_ = input;
setBodyParameter("Input", input);
std::string StartExecutionRequest::getInput() const {
return input_;
}
std::string StartExecutionRequest::getRequestId()const
{
return requestId_;
void StartExecutionRequest::setInput(const std::string &input) {
input_ = input;
setBodyParameter(std::string("Input"), input);
}
void StartExecutionRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setParameter("RequestId", requestId);
std::string StartExecutionRequest::getRequestId() const {
return requestId_;
}
std::string StartExecutionRequest::getFlowName()const
{
return flowName_;
void StartExecutionRequest::setRequestId(const std::string &requestId) {
requestId_ = requestId;
setParameter(std::string("RequestId"), requestId);
}
void StartExecutionRequest::setFlowName(const std::string& flowName)
{
flowName_ = flowName;
setBodyParameter("FlowName", flowName);
std::string StartExecutionRequest::getFlowName() const {
return flowName_;
}
void StartExecutionRequest::setFlowName(const std::string &flowName) {
flowName_ = flowName;
setBodyParameter(std::string("FlowName"), flowName);
}

24
fnf/src/model/StartExecutionResult.cc
View File

@@ -39,26 +39,26 @@ void StartExecutionResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
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();
if(!value["StartedTime"].isNull())
startedTime_ = value["StartedTime"].asString();
if(!value["FlowDefinition"].isNull())
flowDefinition_ = value["FlowDefinition"].asString();
if(!value["ExternalInputUri"].isNull())
externalInputUri_ = value["ExternalInputUri"].asString();
if(!value["Output"].isNull())
output_ = value["Output"].asString();
if(!value["FlowName"].isNull())
flowName_ = value["FlowName"].asString();
if(!value["ExternalOutputUri"].isNull())
externalOutputUri_ = value["ExternalOutputUri"].asString();
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["Input"].isNull())
input_ = value["Input"].asString();
}

63
fnf/src/model/StartSyncExecutionRequest.cc 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.
*/
#include <alibabacloud/fnf/model/StartSyncExecutionRequest.h>
using AlibabaCloud::Fnf::Model::StartSyncExecutionRequest;
StartSyncExecutionRequest::StartSyncExecutionRequest()
: RpcServiceRequest("fnf", "2019-03-15", "StartSyncExecution") {
setMethod(HttpRequest::Method::Post);
}
StartSyncExecutionRequest::~StartSyncExecutionRequest() {}
std::string StartSyncExecutionRequest::getExecutionName() const {
return executionName_;
}
void StartSyncExecutionRequest::setExecutionName(const std::string &executionName) {
executionName_ = executionName;
setBodyParameter(std::string("ExecutionName"), executionName);
}
std::string StartSyncExecutionRequest::getInput() const {
return input_;
}
void StartSyncExecutionRequest::setInput(const std::string &input) {
input_ = input;
setBodyParameter(std::string("Input"), input);
}
std::string StartSyncExecutionRequest::getRequestId() const {
return requestId_;
}
void StartSyncExecutionRequest::setRequestId(const std::string &requestId) {
requestId_ = requestId;
setParameter(std::string("RequestId"), requestId);
}
std::string StartSyncExecutionRequest::getFlowName() const {
return flowName_;
}
void StartSyncExecutionRequest::setFlowName(const std::string &flowName) {
flowName_ = flowName;
setBodyParameter(std::string("FlowName"), flowName);
}

100
fnf/src/model/StartSyncExecutionResult.cc Normal file
View File

@@ -0,0 +1,100 @@
/*
* 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/StartSyncExecutionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Fnf;
using namespace AlibabaCloud::Fnf::Model;
StartSyncExecutionResult::StartSyncExecutionResult() :
ServiceResult()
{}
StartSyncExecutionResult::StartSyncExecutionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
StartSyncExecutionResult::~StartSyncExecutionResult()
{}
void StartSyncExecutionResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["FlowName"].isNull())
flowName_ = value["FlowName"].asString();
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["ErrorCode"].isNull())
errorCode_ = value["ErrorCode"].asString();
if(!value["ErrorMessage"].isNull())
errorMessage_ = value["ErrorMessage"].asString();
if(!value["Output"].isNull())
output_ = value["Output"].asString();
if(!value["StartedTime"].isNull())
startedTime_ = value["StartedTime"].asString();
if(!value["StoppedTime"].isNull())
stoppedTime_ = value["StoppedTime"].asString();
}
std::string StartSyncExecutionResult::getStatus()const
{
return status_;
}
std::string StartSyncExecutionResult::getStoppedTime()const
{
return stoppedTime_;
}
std::string StartSyncExecutionResult::getFlowName()const
{
return flowName_;
}
std::string StartSyncExecutionResult::getOutput()const
{
return output_;
}
std::string StartSyncExecutionResult::getStartedTime()const
{
return startedTime_;
}
std::string StartSyncExecutionResult::getErrorCode()const
{
return errorCode_;
}
std::string StartSyncExecutionResult::getErrorMessage()const
{
return errorMessage_;
}
std::string StartSyncExecutionResult::getName()const
{
return name_;
}

94
fnf/src/model/StopExecutionRequest.cc
View File

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

24
fnf/src/model/StopExecutionResult.cc
View File

@@ -39,26 +39,26 @@ void StopExecutionResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
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();
if(!value["StartedTime"].isNull())
startedTime_ = value["StartedTime"].asString();
if(!value["FlowDefinition"].isNull())
flowDefinition_ = value["FlowDefinition"].asString();
if(!value["ExternalInputUri"].isNull())
externalInputUri_ = value["ExternalInputUri"].asString();
if(!value["Output"].isNull())
output_ = value["Output"].asString();
if(!value["FlowName"].isNull())
flowName_ = value["FlowName"].asString();
if(!value["ExternalOutputUri"].isNull())
externalOutputUri_ = value["ExternalOutputUri"].asString();
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["Input"].isNull())
input_ = value["Input"].asString();
}

118
fnf/src/model/UpdateFlowRequest.cc
View File

@@ -1,106 +1,90 @@
/*
* 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")
{
setMethod(HttpRequest::Method::Post);
}
UpdateFlowRequest::~UpdateFlowRequest()
{}
std::string UpdateFlowRequest::getDescription()const
{
return description_;
*/
#include <alibabacloud/fnf/model/UpdateFlowRequest.h>
using AlibabaCloud::Fnf::Model::UpdateFlowRequest;
UpdateFlowRequest::UpdateFlowRequest()
: RpcServiceRequest("fnf", "2019-03-15", "UpdateFlow") {
setMethod(HttpRequest::Method::Post);
}
void UpdateFlowRequest::setDescription(const std::string& description)
{
description_ = description;
setBodyParameter("Description", description);
UpdateFlowRequest::~UpdateFlowRequest() {}
std::string UpdateFlowRequest::getDescription() const {
return description_;
}
std::string UpdateFlowRequest::getType()const
{
return type_;
void UpdateFlowRequest::setDescription(const std::string &description) {
description_ = description;
setBodyParameter(std::string("Description"), description);
}
void UpdateFlowRequest::setType(const std::string& type)
{
type_ = type;
setBodyParameter("Type", type);
std::string UpdateFlowRequest::getType() const {
return type_;
}
std::string UpdateFlowRequest::getRequestId()const
{
return requestId_;
void UpdateFlowRequest::setType(const std::string &type) {
type_ = type;
setBodyParameter(std::string("Type"), type);
}
void UpdateFlowRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setParameter("RequestId", requestId);
std::string UpdateFlowRequest::getRequestId() const {
return requestId_;
}
std::string UpdateFlowRequest::getRoleArn()const
{
return roleArn_;
void UpdateFlowRequest::setRequestId(const std::string &requestId) {
requestId_ = requestId;
setParameter(std::string("RequestId"), requestId);
}
void UpdateFlowRequest::setRoleArn(const std::string& roleArn)
{
roleArn_ = roleArn;
setBodyParameter("RoleArn", roleArn);
std::string UpdateFlowRequest::getRoleArn() const {
return roleArn_;
}
std::string UpdateFlowRequest::getName()const
{
return name_;
void UpdateFlowRequest::setRoleArn(const std::string &roleArn) {
roleArn_ = roleArn;
setBodyParameter(std::string("RoleArn"), roleArn);
}
void UpdateFlowRequest::setName(const std::string& name)
{
name_ = name;
setBodyParameter("Name", name);
std::string UpdateFlowRequest::getName() const {
return name_;
}
std::string UpdateFlowRequest::getDefinition()const
{
return definition_;
void UpdateFlowRequest::setName(const std::string &name) {
name_ = name;
setBodyParameter(std::string("Name"), name);
}
void UpdateFlowRequest::setDefinition(const std::string& definition)
{
definition_ = definition;
setBodyParameter("Definition", definition);
std::string UpdateFlowRequest::getDefinition() const {
return definition_;
}
std::string UpdateFlowRequest::getExternalStorageLocation()const
{
return externalStorageLocation_;
void UpdateFlowRequest::setDefinition(const std::string &definition) {
definition_ = definition;
setBodyParameter(std::string("Definition"), definition);
}
void UpdateFlowRequest::setExternalStorageLocation(const std::string& externalStorageLocation)
{
externalStorageLocation_ = externalStorageLocation;
setBodyParameter("ExternalStorageLocation", externalStorageLocation);
std::string UpdateFlowRequest::getExternalStorageLocation() const {
return externalStorageLocation_;
}
void UpdateFlowRequest::setExternalStorageLocation(const std::string &externalStorageLocation) {
externalStorageLocation_ = externalStorageLocation;
setBodyParameter(std::string("ExternalStorageLocation"), externalStorageLocation);
}

20
fnf/src/model/UpdateFlowResult.cc
View File

@@ -39,24 +39,24 @@ void UpdateFlowResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
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["Definition"].isNull())
definition_ = value["Definition"].asString();
if(!value["RoleArn"].isNull())
roleArn_ = value["RoleArn"].asString();
if(!value["Description"].isNull())
description_ = value["Description"].asString();
if(!value["ExternalStorageLocation"].isNull())
externalStorageLocation_ = value["ExternalStorageLocation"].asString();
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["CreatedTime"].isNull())
createdTime_ = value["CreatedTime"].asString();
if(!value["LastModifiedTime"].isNull())
lastModifiedTime_ = value["LastModifiedTime"].asString();
if(!value["ExternalStorageLocation"].isNull())
externalStorageLocation_ = value["ExternalStorageLocation"].asString();
if(!value["Id"].isNull())
id_ = value["Id"].asString();
}

118
fnf/src/model/UpdateScheduleRequest.cc
View File

@@ -1,106 +1,90 @@
/*
* 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/UpdateScheduleRequest.h>
using AlibabaCloud::Fnf::Model::UpdateScheduleRequest;
UpdateScheduleRequest::UpdateScheduleRequest() :
RpcServiceRequest("fnf", "2019-03-15", "UpdateSchedule")
{
setMethod(HttpRequest::Method::Post);
}
UpdateScheduleRequest::~UpdateScheduleRequest()
{}
std::string UpdateScheduleRequest::getScheduleName()const
{
return scheduleName_;
*/
#include <alibabacloud/fnf/model/UpdateScheduleRequest.h>
using AlibabaCloud::Fnf::Model::UpdateScheduleRequest;
UpdateScheduleRequest::UpdateScheduleRequest()
: RpcServiceRequest("fnf", "2019-03-15", "UpdateSchedule") {
setMethod(HttpRequest::Method::Post);
}
void UpdateScheduleRequest::setScheduleName(const std::string& scheduleName)
{
scheduleName_ = scheduleName;
setBodyParameter("ScheduleName", scheduleName);
UpdateScheduleRequest::~UpdateScheduleRequest() {}
std::string UpdateScheduleRequest::getScheduleName() const {
return scheduleName_;
}
std::string UpdateScheduleRequest::getCronExpression()const
{
return cronExpression_;
void UpdateScheduleRequest::setScheduleName(const std::string &scheduleName) {
scheduleName_ = scheduleName;
setBodyParameter(std::string("ScheduleName"), scheduleName);
}
void UpdateScheduleRequest::setCronExpression(const std::string& cronExpression)
{
cronExpression_ = cronExpression;
setBodyParameter("CronExpression", cronExpression);
std::string UpdateScheduleRequest::getCronExpression() const {
return cronExpression_;
}
std::string UpdateScheduleRequest::getPayload()const
{
return payload_;
void UpdateScheduleRequest::setCronExpression(const std::string &cronExpression) {
cronExpression_ = cronExpression;
setBodyParameter(std::string("CronExpression"), cronExpression);
}
void UpdateScheduleRequest::setPayload(const std::string& payload)
{
payload_ = payload;
setBodyParameter("Payload", payload);
std::string UpdateScheduleRequest::getPayload() const {
return payload_;
}
std::string UpdateScheduleRequest::getRequestId()const
{
return requestId_;
void UpdateScheduleRequest::setPayload(const std::string &payload) {
payload_ = payload;
setBodyParameter(std::string("Payload"), payload);
}
void UpdateScheduleRequest::setRequestId(const std::string& requestId)
{
requestId_ = requestId;
setParameter("RequestId", requestId);
std::string UpdateScheduleRequest::getRequestId() const {
return requestId_;
}
bool UpdateScheduleRequest::getEnable()const
{
return enable_;
void UpdateScheduleRequest::setRequestId(const std::string &requestId) {
requestId_ = requestId;
setParameter(std::string("RequestId"), requestId);
}
void UpdateScheduleRequest::setEnable(bool enable)
{
enable_ = enable;
setBodyParameter("Enable", enable ? "true" : "false");
bool UpdateScheduleRequest::getEnable() const {
return enable_;
}
std::string UpdateScheduleRequest::getDescription()const
{
return description_;
void UpdateScheduleRequest::setEnable(bool enable) {
enable_ = enable;
setBodyParameter(std::string("Enable"), enable ? "true" : "false");
}
void UpdateScheduleRequest::setDescription(const std::string& description)
{
description_ = description;
setBodyParameter("Description", description);
std::string UpdateScheduleRequest::getDescription() const {
return description_;
}
std::string UpdateScheduleRequest::getFlowName()const
{
return flowName_;
void UpdateScheduleRequest::setDescription(const std::string &description) {
description_ = description;
setBodyParameter(std::string("Description"), description);
}
void UpdateScheduleRequest::setFlowName(const std::string& flowName)
{
flowName_ = flowName;
setBodyParameter("FlowName", flowName);
std::string UpdateScheduleRequest::getFlowName() const {
return flowName_;
}
void UpdateScheduleRequest::setFlowName(const std::string &flowName) {
flowName_ = flowName;
setBodyParameter(std::string("FlowName"), flowName);
}

12
fnf/src/model/UpdateScheduleResult.cc
View File

@@ -39,22 +39,22 @@ void UpdateScheduleResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ScheduleName"].isNull())
scheduleName_ = value["ScheduleName"].asString();
if(!value["Description"].isNull())
description_ = value["Description"].asString();
if(!value["ScheduleId"].isNull())
scheduleId_ = value["ScheduleId"].asString();
if(!value["Payload"].isNull())
payload_ = value["Payload"].asString();
if(!value["CronExpression"].isNull())
cronExpression_ = value["CronExpression"].asString();
if(!value["Enable"].isNull())
enable_ = value["Enable"].asString() == "true";
if(!value["ScheduleName"].isNull())
scheduleName_ = value["ScheduleName"].asString();
if(!value["CreatedTime"].isNull())
createdTime_ = value["CreatedTime"].asString();
if(!value["LastModifiedTime"].isNull())
lastModifiedTime_ = value["LastModifiedTime"].asString();
if(!value["CronExpression"].isNull())
cronExpression_ = value["CronExpression"].asString();
if(!value["Enable"].isNull())
enable_ = value["Enable"].asString() == "true";
}