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

Counters and Parameters are changed to Map in ListExections and StartExecution.

Browse Source
This commit is contained in:
sdk-team
2020-04-01 16:07:28 +08:00
parent 773c9d68dd
commit 2efc5c0610
106 changed files with 8469 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

182
oos/CMakeLists.txt Normal file
View File

@@ -0,0 +1,182 @@
#
# 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.
#
set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
set(oos_public_header
include/alibabacloud/oos/OosClient.h
include/alibabacloud/oos/OosExport.h )
set(oos_public_header_model
include/alibabacloud/oos/model/CancelExecutionRequest.h
include/alibabacloud/oos/model/CancelExecutionResult.h
include/alibabacloud/oos/model/CreateTemplateRequest.h
include/alibabacloud/oos/model/CreateTemplateResult.h
include/alibabacloud/oos/model/DeleteExecutionsRequest.h
include/alibabacloud/oos/model/DeleteExecutionsResult.h
include/alibabacloud/oos/model/DeleteTemplateRequest.h
include/alibabacloud/oos/model/DeleteTemplateResult.h
include/alibabacloud/oos/model/DeleteTemplatesRequest.h
include/alibabacloud/oos/model/DeleteTemplatesResult.h
include/alibabacloud/oos/model/DescribeRegionsRequest.h
include/alibabacloud/oos/model/DescribeRegionsResult.h
include/alibabacloud/oos/model/GenerateExecutionPolicyRequest.h
include/alibabacloud/oos/model/GenerateExecutionPolicyResult.h
include/alibabacloud/oos/model/GetExecutionTemplateRequest.h
include/alibabacloud/oos/model/GetExecutionTemplateResult.h
include/alibabacloud/oos/model/GetTemplateRequest.h
include/alibabacloud/oos/model/GetTemplateResult.h
include/alibabacloud/oos/model/ListActionsRequest.h
include/alibabacloud/oos/model/ListActionsResult.h
include/alibabacloud/oos/model/ListExecutionLogsRequest.h
include/alibabacloud/oos/model/ListExecutionLogsResult.h
include/alibabacloud/oos/model/ListExecutionRiskyTasksRequest.h
include/alibabacloud/oos/model/ListExecutionRiskyTasksResult.h
include/alibabacloud/oos/model/ListExecutionsRequest.h
include/alibabacloud/oos/model/ListExecutionsResult.h
include/alibabacloud/oos/model/ListTagKeysRequest.h
include/alibabacloud/oos/model/ListTagKeysResult.h
include/alibabacloud/oos/model/ListTagResourcesRequest.h
include/alibabacloud/oos/model/ListTagResourcesResult.h
include/alibabacloud/oos/model/ListTagValuesRequest.h
include/alibabacloud/oos/model/ListTagValuesResult.h
include/alibabacloud/oos/model/ListTaskExecutionsRequest.h
include/alibabacloud/oos/model/ListTaskExecutionsResult.h
include/alibabacloud/oos/model/ListTemplatesRequest.h
include/alibabacloud/oos/model/ListTemplatesResult.h
include/alibabacloud/oos/model/NotifyExecutionRequest.h
include/alibabacloud/oos/model/NotifyExecutionResult.h
include/alibabacloud/oos/model/StartExecutionRequest.h
include/alibabacloud/oos/model/StartExecutionResult.h
include/alibabacloud/oos/model/TagResourcesRequest.h
include/alibabacloud/oos/model/TagResourcesResult.h
include/alibabacloud/oos/model/TriggerExecutionRequest.h
include/alibabacloud/oos/model/TriggerExecutionResult.h
include/alibabacloud/oos/model/UntagResourcesRequest.h
include/alibabacloud/oos/model/UntagResourcesResult.h
include/alibabacloud/oos/model/UpdateTemplateRequest.h
include/alibabacloud/oos/model/UpdateTemplateResult.h
include/alibabacloud/oos/model/ValidateTemplateContentRequest.h
include/alibabacloud/oos/model/ValidateTemplateContentResult.h )
set(oos_src
src/OosClient.cc
src/model/CancelExecutionRequest.cc
src/model/CancelExecutionResult.cc
src/model/CreateTemplateRequest.cc
src/model/CreateTemplateResult.cc
src/model/DeleteExecutionsRequest.cc
src/model/DeleteExecutionsResult.cc
src/model/DeleteTemplateRequest.cc
src/model/DeleteTemplateResult.cc
src/model/DeleteTemplatesRequest.cc
src/model/DeleteTemplatesResult.cc
src/model/DescribeRegionsRequest.cc
src/model/DescribeRegionsResult.cc
src/model/GenerateExecutionPolicyRequest.cc
src/model/GenerateExecutionPolicyResult.cc
src/model/GetExecutionTemplateRequest.cc
src/model/GetExecutionTemplateResult.cc
src/model/GetTemplateRequest.cc
src/model/GetTemplateResult.cc
src/model/ListActionsRequest.cc
src/model/ListActionsResult.cc
src/model/ListExecutionLogsRequest.cc
src/model/ListExecutionLogsResult.cc
src/model/ListExecutionRiskyTasksRequest.cc
src/model/ListExecutionRiskyTasksResult.cc
src/model/ListExecutionsRequest.cc
src/model/ListExecutionsResult.cc
src/model/ListTagKeysRequest.cc
src/model/ListTagKeysResult.cc
src/model/ListTagResourcesRequest.cc
src/model/ListTagResourcesResult.cc
src/model/ListTagValuesRequest.cc
src/model/ListTagValuesResult.cc
src/model/ListTaskExecutionsRequest.cc
src/model/ListTaskExecutionsResult.cc
src/model/ListTemplatesRequest.cc
src/model/ListTemplatesResult.cc
src/model/NotifyExecutionRequest.cc
src/model/NotifyExecutionResult.cc
src/model/StartExecutionRequest.cc
src/model/StartExecutionResult.cc
src/model/TagResourcesRequest.cc
src/model/TagResourcesResult.cc
src/model/TriggerExecutionRequest.cc
src/model/TriggerExecutionResult.cc
src/model/UntagResourcesRequest.cc
src/model/UntagResourcesResult.cc
src/model/UpdateTemplateRequest.cc
src/model/UpdateTemplateResult.cc
src/model/ValidateTemplateContentRequest.cc
src/model/ValidateTemplateContentResult.cc )
add_library(oos ${LIB_TYPE}
${oos_public_header}
${oos_public_header_model}
${oos_src})
set_target_properties(oos
PROPERTIES
LINKER_LANGUAGE CXX
ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}oos
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(oos
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_OOS_LIBRARY)
endif()
target_include_directories(oos
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(oos
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(oos
jsoncpp)
target_include_directories(oos
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(oos
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(oos
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(oos
PRIVATE /usr/include/jsoncpp)
target_link_libraries(oos
jsoncpp)
endif()
install(FILES ${oos_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/oos)
install(FILES ${oos_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/oos/model)
install(TARGETS oos
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

246
oos/include/alibabacloud/oos/OosClient.h Normal file
View File

@@ -0,0 +1,246 @@
/*
* 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_OOS_OOSCLIENT_H_
#define ALIBABACLOUD_OOS_OOSCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "OosExport.h"
#include "model/CancelExecutionRequest.h"
#include "model/CancelExecutionResult.h"
#include "model/CreateTemplateRequest.h"
#include "model/CreateTemplateResult.h"
#include "model/DeleteExecutionsRequest.h"
#include "model/DeleteExecutionsResult.h"
#include "model/DeleteTemplateRequest.h"
#include "model/DeleteTemplateResult.h"
#include "model/DeleteTemplatesRequest.h"
#include "model/DeleteTemplatesResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/GenerateExecutionPolicyRequest.h"
#include "model/GenerateExecutionPolicyResult.h"
#include "model/GetExecutionTemplateRequest.h"
#include "model/GetExecutionTemplateResult.h"
#include "model/GetTemplateRequest.h"
#include "model/GetTemplateResult.h"
#include "model/ListActionsRequest.h"
#include "model/ListActionsResult.h"
#include "model/ListExecutionLogsRequest.h"
#include "model/ListExecutionLogsResult.h"
#include "model/ListExecutionRiskyTasksRequest.h"
#include "model/ListExecutionRiskyTasksResult.h"
#include "model/ListExecutionsRequest.h"
#include "model/ListExecutionsResult.h"
#include "model/ListTagKeysRequest.h"
#include "model/ListTagKeysResult.h"
#include "model/ListTagResourcesRequest.h"
#include "model/ListTagResourcesResult.h"
#include "model/ListTagValuesRequest.h"
#include "model/ListTagValuesResult.h"
#include "model/ListTaskExecutionsRequest.h"
#include "model/ListTaskExecutionsResult.h"
#include "model/ListTemplatesRequest.h"
#include "model/ListTemplatesResult.h"
#include "model/NotifyExecutionRequest.h"
#include "model/NotifyExecutionResult.h"
#include "model/StartExecutionRequest.h"
#include "model/StartExecutionResult.h"
#include "model/TagResourcesRequest.h"
#include "model/TagResourcesResult.h"
#include "model/TriggerExecutionRequest.h"
#include "model/TriggerExecutionResult.h"
#include "model/UntagResourcesRequest.h"
#include "model/UntagResourcesResult.h"
#include "model/UpdateTemplateRequest.h"
#include "model/UpdateTemplateResult.h"
#include "model/ValidateTemplateContentRequest.h"
#include "model/ValidateTemplateContentResult.h"
namespace AlibabaCloud
{
namespace Oos
{
class ALIBABACLOUD_OOS_EXPORT OosClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::CancelExecutionResult> CancelExecutionOutcome;
typedef std::future<CancelExecutionOutcome> CancelExecutionOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::CancelExecutionRequest&, const CancelExecutionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelExecutionAsyncHandler;
typedef Outcome<Error, Model::CreateTemplateResult> CreateTemplateOutcome;
typedef std::future<CreateTemplateOutcome> CreateTemplateOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::CreateTemplateRequest&, const CreateTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTemplateAsyncHandler;
typedef Outcome<Error, Model::DeleteExecutionsResult> DeleteExecutionsOutcome;
typedef std::future<DeleteExecutionsOutcome> DeleteExecutionsOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::DeleteExecutionsRequest&, const DeleteExecutionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteExecutionsAsyncHandler;
typedef Outcome<Error, Model::DeleteTemplateResult> DeleteTemplateOutcome;
typedef std::future<DeleteTemplateOutcome> DeleteTemplateOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::DeleteTemplateRequest&, const DeleteTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTemplateAsyncHandler;
typedef Outcome<Error, Model::DeleteTemplatesResult> DeleteTemplatesOutcome;
typedef std::future<DeleteTemplatesOutcome> DeleteTemplatesOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::DeleteTemplatesRequest&, const DeleteTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTemplatesAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::GenerateExecutionPolicyResult> GenerateExecutionPolicyOutcome;
typedef std::future<GenerateExecutionPolicyOutcome> GenerateExecutionPolicyOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::GenerateExecutionPolicyRequest&, const GenerateExecutionPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateExecutionPolicyAsyncHandler;
typedef Outcome<Error, Model::GetExecutionTemplateResult> GetExecutionTemplateOutcome;
typedef std::future<GetExecutionTemplateOutcome> GetExecutionTemplateOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::GetExecutionTemplateRequest&, const GetExecutionTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetExecutionTemplateAsyncHandler;
typedef Outcome<Error, Model::GetTemplateResult> GetTemplateOutcome;
typedef std::future<GetTemplateOutcome> GetTemplateOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::GetTemplateRequest&, const GetTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTemplateAsyncHandler;
typedef Outcome<Error, Model::ListActionsResult> ListActionsOutcome;
typedef std::future<ListActionsOutcome> ListActionsOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListActionsRequest&, const ListActionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListActionsAsyncHandler;
typedef Outcome<Error, Model::ListExecutionLogsResult> ListExecutionLogsOutcome;
typedef std::future<ListExecutionLogsOutcome> ListExecutionLogsOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListExecutionLogsRequest&, const ListExecutionLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListExecutionLogsAsyncHandler;
typedef Outcome<Error, Model::ListExecutionRiskyTasksResult> ListExecutionRiskyTasksOutcome;
typedef std::future<ListExecutionRiskyTasksOutcome> ListExecutionRiskyTasksOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListExecutionRiskyTasksRequest&, const ListExecutionRiskyTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListExecutionRiskyTasksAsyncHandler;
typedef Outcome<Error, Model::ListExecutionsResult> ListExecutionsOutcome;
typedef std::future<ListExecutionsOutcome> ListExecutionsOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListExecutionsRequest&, const ListExecutionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListExecutionsAsyncHandler;
typedef Outcome<Error, Model::ListTagKeysResult> ListTagKeysOutcome;
typedef std::future<ListTagKeysOutcome> ListTagKeysOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListTagKeysRequest&, const ListTagKeysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagKeysAsyncHandler;
typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
typedef Outcome<Error, Model::ListTagValuesResult> ListTagValuesOutcome;
typedef std::future<ListTagValuesOutcome> ListTagValuesOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListTagValuesRequest&, const ListTagValuesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagValuesAsyncHandler;
typedef Outcome<Error, Model::ListTaskExecutionsResult> ListTaskExecutionsOutcome;
typedef std::future<ListTaskExecutionsOutcome> ListTaskExecutionsOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListTaskExecutionsRequest&, const ListTaskExecutionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTaskExecutionsAsyncHandler;
typedef Outcome<Error, Model::ListTemplatesResult> ListTemplatesOutcome;
typedef std::future<ListTemplatesOutcome> ListTemplatesOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListTemplatesRequest&, const ListTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTemplatesAsyncHandler;
typedef Outcome<Error, Model::NotifyExecutionResult> NotifyExecutionOutcome;
typedef std::future<NotifyExecutionOutcome> NotifyExecutionOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::NotifyExecutionRequest&, const NotifyExecutionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> NotifyExecutionAsyncHandler;
typedef Outcome<Error, Model::StartExecutionResult> StartExecutionOutcome;
typedef std::future<StartExecutionOutcome> StartExecutionOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::StartExecutionRequest&, const StartExecutionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartExecutionAsyncHandler;
typedef Outcome<Error, Model::TagResourcesResult> TagResourcesOutcome;
typedef std::future<TagResourcesOutcome> TagResourcesOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::TagResourcesRequest&, const TagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagResourcesAsyncHandler;
typedef Outcome<Error, Model::TriggerExecutionResult> TriggerExecutionOutcome;
typedef std::future<TriggerExecutionOutcome> TriggerExecutionOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::TriggerExecutionRequest&, const TriggerExecutionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TriggerExecutionAsyncHandler;
typedef Outcome<Error, Model::UntagResourcesResult> UntagResourcesOutcome;
typedef std::future<UntagResourcesOutcome> UntagResourcesOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::UntagResourcesRequest&, const UntagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UntagResourcesAsyncHandler;
typedef Outcome<Error, Model::UpdateTemplateResult> UpdateTemplateOutcome;
typedef std::future<UpdateTemplateOutcome> UpdateTemplateOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::UpdateTemplateRequest&, const UpdateTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateTemplateAsyncHandler;
typedef Outcome<Error, Model::ValidateTemplateContentResult> ValidateTemplateContentOutcome;
typedef std::future<ValidateTemplateContentOutcome> ValidateTemplateContentOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ValidateTemplateContentRequest&, const ValidateTemplateContentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ValidateTemplateContentAsyncHandler;
OosClient(const Credentials &credentials, const ClientConfiguration &configuration);
OosClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
OosClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~OosClient();
CancelExecutionOutcome cancelExecution(const Model::CancelExecutionRequest &request)const;
void cancelExecutionAsync(const Model::CancelExecutionRequest& request, const CancelExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CancelExecutionOutcomeCallable cancelExecutionCallable(const Model::CancelExecutionRequest& request) const;
CreateTemplateOutcome createTemplate(const Model::CreateTemplateRequest &request)const;
void createTemplateAsync(const Model::CreateTemplateRequest& request, const CreateTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateTemplateOutcomeCallable createTemplateCallable(const Model::CreateTemplateRequest& request) const;
DeleteExecutionsOutcome deleteExecutions(const Model::DeleteExecutionsRequest &request)const;
void deleteExecutionsAsync(const Model::DeleteExecutionsRequest& request, const DeleteExecutionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteExecutionsOutcomeCallable deleteExecutionsCallable(const Model::DeleteExecutionsRequest& request) const;
DeleteTemplateOutcome deleteTemplate(const Model::DeleteTemplateRequest &request)const;
void deleteTemplateAsync(const Model::DeleteTemplateRequest& request, const DeleteTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteTemplateOutcomeCallable deleteTemplateCallable(const Model::DeleteTemplateRequest& request) const;
DeleteTemplatesOutcome deleteTemplates(const Model::DeleteTemplatesRequest &request)const;
void deleteTemplatesAsync(const Model::DeleteTemplatesRequest& request, const DeleteTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteTemplatesOutcomeCallable deleteTemplatesCallable(const Model::DeleteTemplatesRequest& request) const;
DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
GenerateExecutionPolicyOutcome generateExecutionPolicy(const Model::GenerateExecutionPolicyRequest &request)const;
void generateExecutionPolicyAsync(const Model::GenerateExecutionPolicyRequest& request, const GenerateExecutionPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GenerateExecutionPolicyOutcomeCallable generateExecutionPolicyCallable(const Model::GenerateExecutionPolicyRequest& request) const;
GetExecutionTemplateOutcome getExecutionTemplate(const Model::GetExecutionTemplateRequest &request)const;
void getExecutionTemplateAsync(const Model::GetExecutionTemplateRequest& request, const GetExecutionTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetExecutionTemplateOutcomeCallable getExecutionTemplateCallable(const Model::GetExecutionTemplateRequest& request) const;
GetTemplateOutcome getTemplate(const Model::GetTemplateRequest &request)const;
void getTemplateAsync(const Model::GetTemplateRequest& request, const GetTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetTemplateOutcomeCallable getTemplateCallable(const Model::GetTemplateRequest& request) const;
ListActionsOutcome listActions(const Model::ListActionsRequest &request)const;
void listActionsAsync(const Model::ListActionsRequest& request, const ListActionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListActionsOutcomeCallable listActionsCallable(const Model::ListActionsRequest& request) const;
ListExecutionLogsOutcome listExecutionLogs(const Model::ListExecutionLogsRequest &request)const;
void listExecutionLogsAsync(const Model::ListExecutionLogsRequest& request, const ListExecutionLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListExecutionLogsOutcomeCallable listExecutionLogsCallable(const Model::ListExecutionLogsRequest& request) const;
ListExecutionRiskyTasksOutcome listExecutionRiskyTasks(const Model::ListExecutionRiskyTasksRequest &request)const;
void listExecutionRiskyTasksAsync(const Model::ListExecutionRiskyTasksRequest& request, const ListExecutionRiskyTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListExecutionRiskyTasksOutcomeCallable listExecutionRiskyTasksCallable(const Model::ListExecutionRiskyTasksRequest& request) const;
ListExecutionsOutcome listExecutions(const Model::ListExecutionsRequest &request)const;
void listExecutionsAsync(const Model::ListExecutionsRequest& request, const ListExecutionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListExecutionsOutcomeCallable listExecutionsCallable(const Model::ListExecutionsRequest& request) const;
ListTagKeysOutcome listTagKeys(const Model::ListTagKeysRequest &request)const;
void listTagKeysAsync(const Model::ListTagKeysRequest& request, const ListTagKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTagKeysOutcomeCallable listTagKeysCallable(const Model::ListTagKeysRequest& request) const;
ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
ListTagValuesOutcome listTagValues(const Model::ListTagValuesRequest &request)const;
void listTagValuesAsync(const Model::ListTagValuesRequest& request, const ListTagValuesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTagValuesOutcomeCallable listTagValuesCallable(const Model::ListTagValuesRequest& request) const;
ListTaskExecutionsOutcome listTaskExecutions(const Model::ListTaskExecutionsRequest &request)const;
void listTaskExecutionsAsync(const Model::ListTaskExecutionsRequest& request, const ListTaskExecutionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTaskExecutionsOutcomeCallable listTaskExecutionsCallable(const Model::ListTaskExecutionsRequest& request) const;
ListTemplatesOutcome listTemplates(const Model::ListTemplatesRequest &request)const;
void listTemplatesAsync(const Model::ListTemplatesRequest& request, const ListTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTemplatesOutcomeCallable listTemplatesCallable(const Model::ListTemplatesRequest& request) const;
NotifyExecutionOutcome notifyExecution(const Model::NotifyExecutionRequest &request)const;
void notifyExecutionAsync(const Model::NotifyExecutionRequest& request, const NotifyExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
NotifyExecutionOutcomeCallable notifyExecutionCallable(const Model::NotifyExecutionRequest& request) const;
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;
TagResourcesOutcome tagResources(const Model::TagResourcesRequest &request)const;
void tagResourcesAsync(const Model::TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TagResourcesOutcomeCallable tagResourcesCallable(const Model::TagResourcesRequest& request) const;
TriggerExecutionOutcome triggerExecution(const Model::TriggerExecutionRequest &request)const;
void triggerExecutionAsync(const Model::TriggerExecutionRequest& request, const TriggerExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TriggerExecutionOutcomeCallable triggerExecutionCallable(const Model::TriggerExecutionRequest& request) const;
UntagResourcesOutcome untagResources(const Model::UntagResourcesRequest &request)const;
void untagResourcesAsync(const Model::UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UntagResourcesOutcomeCallable untagResourcesCallable(const Model::UntagResourcesRequest& request) const;
UpdateTemplateOutcome updateTemplate(const Model::UpdateTemplateRequest &request)const;
void updateTemplateAsync(const Model::UpdateTemplateRequest& request, const UpdateTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateTemplateOutcomeCallable updateTemplateCallable(const Model::UpdateTemplateRequest& request) const;
ValidateTemplateContentOutcome validateTemplateContent(const Model::ValidateTemplateContentRequest &request)const;
void validateTemplateContentAsync(const Model::ValidateTemplateContentRequest& request, const ValidateTemplateContentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ValidateTemplateContentOutcomeCallable validateTemplateContentCallable(const Model::ValidateTemplateContentRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_OOS_OOSCLIENT_H_

32
oos/include/alibabacloud/oos/OosExport.h Normal file
View File

@@ -0,0 +1,32 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_OOSEXPORT_H_
#define ALIBABACLOUD_OOS_OOSEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_OOS_LIBRARY)
# define ALIBABACLOUD_OOS_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_OOS_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_OOS_EXPORT
#endif
#endif // !ALIBABACLOUD_OOS_OOSEXPORT_H_

51
oos/include/alibabacloud/oos/model/CancelExecutionRequest.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_OOS_MODEL_CANCELEXECUTIONREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_CANCELEXECUTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT CancelExecutionRequest : public RpcServiceRequest
{
public:
CancelExecutionRequest();
~CancelExecutionRequest();
std::string getExecutionId()const;
void setExecutionId(const std::string& executionId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string executionId_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_CANCELEXECUTIONREQUEST_H_

49
oos/include/alibabacloud/oos/model/CancelExecutionResult.h Normal file
View File

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

57
oos/include/alibabacloud/oos/model/CreateTemplateRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_CREATETEMPLATEREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_CREATETEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT CreateTemplateRequest : public RpcServiceRequest
{
public:
CreateTemplateRequest();
~CreateTemplateRequest();
std::string getContent()const;
void setContent(const std::string& content);
std::map<std::string, std::string> getTags()const;
void setTags(const std::map<std::string, std::string>& tags);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
private:
std::string content_;
std::map<std::string, std::string> tags_;
std::string regionId_;
std::string templateName_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_CREATETEMPLATEREQUEST_H_

67
oos/include/alibabacloud/oos/model/CreateTemplateResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* 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_OOS_MODEL_CREATETEMPLATERESULT_H_
#define ALIBABACLOUD_OOS_MODEL_CREATETEMPLATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT CreateTemplateResult : public ServiceResult
{
public:
struct _Template
{
std::string createdBy;
std::string description;
std::string templateFormat;
std::string updatedDate;
std::string templateVersion;
std::string hash;
std::string updatedBy;
bool hasTrigger;
std::string createdDate;
std::string templateName;
std::string templateId;
std::string tags;
std::string shareType;
};
CreateTemplateResult();
explicit CreateTemplateResult(const std::string &payload);
~CreateTemplateResult();
_Template get_Template()const;
protected:
void parse(const std::string &payload);
private:
_Template _template_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_CREATETEMPLATERESULT_H_

51
oos/include/alibabacloud/oos/model/DeleteExecutionsRequest.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_OOS_MODEL_DELETEEXECUTIONSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_DELETEEXECUTIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT DeleteExecutionsRequest : public RpcServiceRequest
{
public:
DeleteExecutionsRequest();
~DeleteExecutionsRequest();
std::string getExecutionIds()const;
void setExecutionIds(const std::string& executionIds);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string executionIds_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_DELETEEXECUTIONSREQUEST_H_

49
oos/include/alibabacloud/oos/model/DeleteExecutionsResult.h Normal file
View File

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

54
oos/include/alibabacloud/oos/model/DeleteTemplateRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_DELETETEMPLATEREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_DELETETEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT DeleteTemplateRequest : public RpcServiceRequest
{
public:
DeleteTemplateRequest();
~DeleteTemplateRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getAutoDeleteExecutions()const;
void setAutoDeleteExecutions(bool autoDeleteExecutions);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
private:
std::string regionId_;
bool autoDeleteExecutions_;
std::string templateName_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_DELETETEMPLATEREQUEST_H_

49
oos/include/alibabacloud/oos/model/DeleteTemplateResult.h Normal file
View File

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

54
oos/include/alibabacloud/oos/model/DeleteTemplatesRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_DELETETEMPLATESREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_DELETETEMPLATESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT DeleteTemplatesRequest : public RpcServiceRequest
{
public:
DeleteTemplatesRequest();
~DeleteTemplatesRequest();
std::string getTemplateNames()const;
void setTemplateNames(const std::string& templateNames);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getAutoDeleteExecutions()const;
void setAutoDeleteExecutions(bool autoDeleteExecutions);
private:
std::string templateNames_;
std::string regionId_;
bool autoDeleteExecutions_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_DELETETEMPLATESREQUEST_H_

49
oos/include/alibabacloud/oos/model/DeleteTemplatesResult.h Normal file
View File

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

51
oos/include/alibabacloud/oos/model/DescribeRegionsRequest.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_OOS_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT DescribeRegionsRequest : public RpcServiceRequest
{
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getAcceptLanguage()const;
void setAcceptLanguage(const std::string& acceptLanguage);
private:
std::string regionId_;
std::string acceptLanguage_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_DESCRIBEREGIONSREQUEST_H_

57
oos/include/alibabacloud/oos/model/DescribeRegionsResult.h Normal file
View File

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

51
oos/include/alibabacloud/oos/model/GenerateExecutionPolicyRequest.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_OOS_MODEL_GENERATEEXECUTIONPOLICYREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_GENERATEEXECUTIONPOLICYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT GenerateExecutionPolicyRequest : public RpcServiceRequest
{
public:
GenerateExecutionPolicyRequest();
~GenerateExecutionPolicyRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
private:
std::string regionId_;
std::string templateName_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_GENERATEEXECUTIONPOLICYREQUEST_H_

51
oos/include/alibabacloud/oos/model/GenerateExecutionPolicyResult.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_OOS_MODEL_GENERATEEXECUTIONPOLICYRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_GENERATEEXECUTIONPOLICYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT GenerateExecutionPolicyResult : public ServiceResult
{
public:
GenerateExecutionPolicyResult();
explicit GenerateExecutionPolicyResult(const std::string &payload);
~GenerateExecutionPolicyResult();
std::string getPolicy()const;
protected:
void parse(const std::string &payload);
private:
std::string policy_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_GENERATEEXECUTIONPOLICYRESULT_H_

51
oos/include/alibabacloud/oos/model/GetExecutionTemplateRequest.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_OOS_MODEL_GETEXECUTIONTEMPLATEREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_GETEXECUTIONTEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT GetExecutionTemplateRequest : public RpcServiceRequest
{
public:
GetExecutionTemplateRequest();
~GetExecutionTemplateRequest();
std::string getExecutionId()const;
void setExecutionId(const std::string& executionId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string executionId_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_GETEXECUTIONTEMPLATEREQUEST_H_

68
oos/include/alibabacloud/oos/model/GetExecutionTemplateResult.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* 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_OOS_MODEL_GETEXECUTIONTEMPLATERESULT_H_
#define ALIBABACLOUD_OOS_MODEL_GETEXECUTIONTEMPLATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT GetExecutionTemplateResult : public ServiceResult
{
public:
struct _Template
{
std::string updatedBy;
std::string createdBy;
std::string description;
std::string templateFormat;
std::string updatedDate;
std::string createdDate;
std::string templateName;
std::string templateVersion;
std::string hash;
std::string templateId;
std::string tags;
std::string shareType;
};
GetExecutionTemplateResult();
explicit GetExecutionTemplateResult(const std::string &payload);
~GetExecutionTemplateResult();
_Template get_Template()const;
std::string getContent()const;
protected:
void parse(const std::string &payload);
private:
_Template _template_;
std::string content_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_GETEXECUTIONTEMPLATERESULT_H_

54
oos/include/alibabacloud/oos/model/GetTemplateRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_GETTEMPLATEREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_GETTEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT GetTemplateRequest : public RpcServiceRequest
{
public:
GetTemplateRequest();
~GetTemplateRequest();
std::string getTemplateVersion()const;
void setTemplateVersion(const std::string& templateVersion);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
private:
std::string templateVersion_;
std::string regionId_;
std::string templateName_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_GETTEMPLATEREQUEST_H_

69
oos/include/alibabacloud/oos/model/GetTemplateResult.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_GETTEMPLATERESULT_H_
#define ALIBABACLOUD_OOS_MODEL_GETTEMPLATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT GetTemplateResult : public ServiceResult
{
public:
struct _Template
{
std::string createdBy;
std::string description;
std::string templateFormat;
std::string updatedDate;
std::string templateVersion;
std::string hash;
std::string updatedBy;
bool hasTrigger;
std::string createdDate;
std::string templateName;
std::string templateId;
std::string tags;
std::string shareType;
};
GetTemplateResult();
explicit GetTemplateResult(const std::string &payload);
~GetTemplateResult();
_Template get_Template()const;
std::string getContent()const;
protected:
void parse(const std::string &payload);
private:
_Template _template_;
std::string content_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_GETTEMPLATERESULT_H_

57
oos/include/alibabacloud/oos/model/ListActionsRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTACTIONSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTACTIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListActionsRequest : public RpcServiceRequest
{
public:
ListActionsRequest();
~ListActionsRequest();
std::string getOOSActionName()const;
void setOOSActionName(const std::string& oOSActionName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
private:
std::string oOSActionName_;
std::string regionId_;
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTACTIONSREQUEST_H_

64
oos/include/alibabacloud/oos/model/ListActionsResult.h Normal file
View File

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

63
oos/include/alibabacloud/oos/model/ListExecutionLogsRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONLOGSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONLOGSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListExecutionLogsRequest : public RpcServiceRequest
{
public:
ListExecutionLogsRequest();
~ListExecutionLogsRequest();
std::string getExecutionId()const;
void setExecutionId(const std::string& executionId);
std::string getLogType()const;
void setLogType(const std::string& logType);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getTaskExecutionId()const;
void setTaskExecutionId(const std::string& taskExecutionId);
private:
std::string executionId_;
std::string logType_;
std::string regionId_;
std::string nextToken_;
int maxResults_;
std::string taskExecutionId_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONLOGSREQUEST_H_

64
oos/include/alibabacloud/oos/model/ListExecutionLogsResult.h Normal file
View File

@@ -0,0 +1,64 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONLOGSRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONLOGSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListExecutionLogsResult : public ServiceResult
{
public:
struct ExecutionLog
{
std::string message;
std::string logType;
std::string timestamp;
std::string taskExecutionId;
};
ListExecutionLogsResult();
explicit ListExecutionLogsResult(const std::string &payload);
~ListExecutionLogsResult();
std::string getNextToken()const;
std::vector<ExecutionLog> getExecutionLogs()const;
int getMaxResults()const;
bool getIsTruncated()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::vector<ExecutionLog> executionLogs_;
int maxResults_;
bool isTruncated_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONLOGSRESULT_H_

51
oos/include/alibabacloud/oos/model/ListExecutionRiskyTasksRequest.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_OOS_MODEL_LISTEXECUTIONRISKYTASKSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONRISKYTASKSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListExecutionRiskyTasksRequest : public RpcServiceRequest
{
public:
ListExecutionRiskyTasksRequest();
~ListExecutionRiskyTasksRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
private:
std::string regionId_;
std::string templateName_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONRISKYTASKSREQUEST_H_

58
oos/include/alibabacloud/oos/model/ListExecutionRiskyTasksResult.h Normal file
View File

@@ -0,0 +1,58 @@
/*
* 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_OOS_MODEL_LISTEXECUTIONRISKYTASKSRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONRISKYTASKSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListExecutionRiskyTasksResult : public ServiceResult
{
public:
struct RiskyTask
{
std::vector<std::string> task;
std::vector<std::string> _template;
std::string service;
std::string aPI;
};
ListExecutionRiskyTasksResult();
explicit ListExecutionRiskyTasksResult(const std::string &payload);
~ListExecutionRiskyTasksResult();
std::vector<RiskyTask> getRiskyTasks()const;
protected:
void parse(const std::string &payload);
private:
std::vector<RiskyTask> riskyTasks_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONRISKYTASKSRESULT_H_

102
oos/include/alibabacloud/oos/model/ListExecutionsRequest.h Normal file
View File

@@ -0,0 +1,102 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListExecutionsRequest : public RpcServiceRequest
{
public:
ListExecutionsRequest();
~ListExecutionsRequest();
std::string getExecutedBy()const;
void setExecutedBy(const std::string& executedBy);
bool getIncludeChildExecution()const;
void setIncludeChildExecution(bool includeChildExecution);
std::string getMode()const;
void setMode(const std::string& mode);
std::string getExecutionId()const;
void setExecutionId(const std::string& executionId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getRamRole()const;
void setRamRole(const std::string& ramRole);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
std::string getEndDateBefore()const;
void setEndDateBefore(const std::string& endDateBefore);
std::string getSortOrder()const;
void setSortOrder(const std::string& sortOrder);
std::string getStartDateAfter()const;
void setStartDateAfter(const std::string& startDateAfter);
std::string getStartDateBefore()const;
void setStartDateBefore(const std::string& startDateBefore);
std::map<std::string, std::string> getTags()const;
void setTags(const std::map<std::string, std::string>& tags);
std::string getParentExecutionId()const;
void setParentExecutionId(const std::string& parentExecutionId);
std::string getEndDateAfter()const;
void setEndDateAfter(const std::string& endDateAfter);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getSortField()const;
void setSortField(const std::string& sortField);
std::string getCategory()const;
void setCategory(const std::string& category);
std::string getStatus()const;
void setStatus(const std::string& status);
private:
std::string executedBy_;
bool includeChildExecution_;
std::string mode_;
std::string executionId_;
std::string regionId_;
std::string ramRole_;
std::string nextToken_;
std::string templateName_;
std::string endDateBefore_;
std::string sortOrder_;
std::string startDateAfter_;
std::string startDateBefore_;
std::map<std::string, std::string> tags_;
std::string parentExecutionId_;
std::string endDateAfter_;
int maxResults_;
std::string sortField_;
std::string category_;
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONSREQUEST_H_

89
oos/include/alibabacloud/oos/model/ListExecutionsResult.h Normal file
View File

@@ -0,0 +1,89 @@
/*
* 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_OOS_MODEL_LISTEXECUTIONSRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListExecutionsResult : public ServiceResult
{
public:
struct Execution
{
struct CurrentTask
{
std::string taskName;
std::string taskAction;
std::string taskExecutionId;
};
std::vector<Execution::CurrentTask> currentTasks;
std::string parentExecutionId;
std::string category;
std::string description;
std::string templateVersion;
std::string createDate;
std::string startDate;
std::string updateDate;
std::string templateName;
std::string templateId;
std::string executedBy;
std::string tags;
std::string status;
std::string parameters;
std::string statusReason;
bool isParent;
std::string mode;
std::string endDate;
std::string waitingStatus;
std::string statusMessage;
std::string safetyCheck;
std::string outputs;
std::string ramRole;
std::string counters;
std::string executionId;
};
ListExecutionsResult();
explicit ListExecutionsResult(const std::string &payload);
~ListExecutionsResult();
std::vector<Execution> getExecutions()const;
std::string getNextToken()const;
int getMaxResults()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Execution> executions_;
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONSRESULT_H_

57
oos/include/alibabacloud/oos/model/ListTagKeysRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTTAGKEYSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTAGKEYSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTagKeysRequest : public RpcServiceRequest
{
public:
ListTagKeysRequest();
~ListTagKeysRequest();
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
private:
std::string resourceType_;
std::string regionId_;
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTAGKEYSREQUEST_H_

55
oos/include/alibabacloud/oos/model/ListTagKeysResult.h Normal file
View File

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

60
oos/include/alibabacloud/oos/model/ListTagResourcesRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTTAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTAGRESOURCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTagResourcesRequest : public RpcServiceRequest
{
public:
ListTagResourcesRequest();
~ListTagResourcesRequest();
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::map<std::string, std::string> getTags()const;
void setTags(const std::map<std::string, std::string>& tags);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::map<std::string, std::string> getResourceIds()const;
void setResourceIds(const std::map<std::string, std::string>& resourceIds);
private:
std::string resourceType_;
std::map<std::string, std::string> tags_;
std::string regionId_;
std::string nextToken_;
std::map<std::string, std::string> resourceIds_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTAGRESOURCESREQUEST_H_

60
oos/include/alibabacloud/oos/model/ListTagResourcesResult.h Normal file
View File

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

60
oos/include/alibabacloud/oos/model/ListTagValuesRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTTAGVALUESREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTAGVALUESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTagValuesRequest : public RpcServiceRequest
{
public:
ListTagValuesRequest();
~ListTagValuesRequest();
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getKey()const;
void setKey(const std::string& key);
private:
std::string resourceType_;
std::string regionId_;
std::string nextToken_;
int maxResults_;
std::string key_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTAGVALUESREQUEST_H_

55
oos/include/alibabacloud/oos/model/ListTagValuesResult.h Normal file
View File

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

93
oos/include/alibabacloud/oos/model/ListTaskExecutionsRequest.h Normal file
View File

@@ -0,0 +1,93 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTTASKEXECUTIONSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTASKEXECUTIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTaskExecutionsRequest : public RpcServiceRequest
{
public:
ListTaskExecutionsRequest();
~ListTaskExecutionsRequest();
std::string getTaskName()const;
void setTaskName(const std::string& taskName);
bool getIncludeChildTaskExecution()const;
void setIncludeChildTaskExecution(bool includeChildTaskExecution);
std::string getExecutionId()const;
void setExecutionId(const std::string& executionId);
std::string getParentTaskExecutionId()const;
void setParentTaskExecutionId(const std::string& parentTaskExecutionId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::string getEndDateBefore()const;
void setEndDateBefore(const std::string& endDateBefore);
std::string getSortOrder()const;
void setSortOrder(const std::string& sortOrder);
std::string getStartDateAfter()const;
void setStartDateAfter(const std::string& startDateAfter);
std::string getStartDateBefore()const;
void setStartDateBefore(const std::string& startDateBefore);
std::string getEndDateAfter()const;
void setEndDateAfter(const std::string& endDateAfter);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getTaskExecutionId()const;
void setTaskExecutionId(const std::string& taskExecutionId);
std::string getSortField()const;
void setSortField(const std::string& sortField);
std::string getTaskAction()const;
void setTaskAction(const std::string& taskAction);
std::string getStatus()const;
void setStatus(const std::string& status);
private:
std::string taskName_;
bool includeChildTaskExecution_;
std::string executionId_;
std::string parentTaskExecutionId_;
std::string regionId_;
std::string nextToken_;
std::string endDateBefore_;
std::string sortOrder_;
std::string startDateAfter_;
std::string startDateBefore_;
std::string endDateAfter_;
int maxResults_;
std::string taskExecutionId_;
std::string sortField_;
std::string taskAction_;
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTASKEXECUTIONSREQUEST_H_

77
oos/include/alibabacloud/oos/model/ListTaskExecutionsResult.h Normal file
View File

@@ -0,0 +1,77 @@
/*
* 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_OOS_MODEL_LISTTASKEXECUTIONSRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTASKEXECUTIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTaskExecutionsResult : public ServiceResult
{
public:
struct TaskExecution
{
std::string status;
std::string loop;
int loopBatchNumber;
std::string taskAction;
std::string childExecutionId;
std::string extraData;
std::string properties;
std::string endDate;
std::string createDate;
std::string statusMessage;
std::string startDate;
std::string updateDate;
std::string loopItem;
std::string taskName;
std::string parentTaskExecutionId;
std::string outputs;
std::string taskExecutionId;
std::string templateId;
std::string executionId;
};
ListTaskExecutionsResult();
explicit ListTaskExecutionsResult(const std::string &payload);
~ListTaskExecutionsResult();
std::string getNextToken()const;
int getMaxResults()const;
std::vector<TaskExecution> getTaskExecutions()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
int maxResults_;
std::vector<TaskExecution> taskExecutions_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTASKEXECUTIONSRESULT_H_

87
oos/include/alibabacloud/oos/model/ListTemplatesRequest.h Normal file
View File

@@ -0,0 +1,87 @@
/*
* 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_OOS_MODEL_LISTTEMPLATESREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTEMPLATESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTemplatesRequest : public RpcServiceRequest
{
public:
ListTemplatesRequest();
~ListTemplatesRequest();
std::string getCreatedDateBefore()const;
void setCreatedDateBefore(const std::string& createdDateBefore);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getCreatedBy()const;
void setCreatedBy(const std::string& createdBy);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
std::string getSortOrder()const;
void setSortOrder(const std::string& sortOrder);
std::string getShareType()const;
void setShareType(const std::string& shareType);
bool getHasTrigger()const;
void setHasTrigger(bool hasTrigger);
std::string getCreatedDateAfter()const;
void setCreatedDateAfter(const std::string& createdDateAfter);
std::map<std::string, std::string> getTags()const;
void setTags(const std::map<std::string, std::string>& tags);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getTemplateFormat()const;
void setTemplateFormat(const std::string& templateFormat);
std::string getSortField()const;
void setSortField(const std::string& sortField);
std::string getCategory()const;
void setCategory(const std::string& category);
private:
std::string createdDateBefore_;
std::string regionId_;
std::string createdBy_;
std::string nextToken_;
std::string templateName_;
std::string sortOrder_;
std::string shareType_;
bool hasTrigger_;
std::string createdDateAfter_;
std::map<std::string, std::string> tags_;
int maxResults_;
std::string templateFormat_;
std::string sortField_;
std::string category_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTEMPLATESREQUEST_H_

74
oos/include/alibabacloud/oos/model/ListTemplatesResult.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTTEMPLATESRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTEMPLATESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTemplatesResult : public ServiceResult
{
public:
struct _Template
{
std::string createdBy;
std::string description;
std::string category;
std::string templateFormat;
std::string updatedDate;
int popularity;
std::string templateVersion;
std::string hash;
std::string updatedBy;
bool hasTrigger;
int totalExecutionCount;
std::string createdDate;
std::string templateName;
std::string templateId;
std::string tags;
std::string shareType;
};
ListTemplatesResult();
explicit ListTemplatesResult(const std::string &payload);
~ListTemplatesResult();
std::string getNextToken()const;
int getMaxResults()const;
std::vector<_Template> getTemplates()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
int maxResults_;
std::vector<_Template> templates_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTEMPLATESRESULT_H_

75
oos/include/alibabacloud/oos/model/NotifyExecutionRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* 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_OOS_MODEL_NOTIFYEXECUTIONREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_NOTIFYEXECUTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT NotifyExecutionRequest : public RpcServiceRequest
{
public:
NotifyExecutionRequest();
~NotifyExecutionRequest();
std::string getTaskName()const;
void setTaskName(const std::string& taskName);
std::string getExecutionId()const;
void setExecutionId(const std::string& executionId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNotifyType()const;
void setNotifyType(const std::string& notifyType);
std::string getExecutionStatus()const;
void setExecutionStatus(const std::string& executionStatus);
std::string getNotifyNote()const;
void setNotifyNote(const std::string& notifyNote);
std::string getLoopItem()const;
void setLoopItem(const std::string& loopItem);
std::string getTaskExecutionIds()const;
void setTaskExecutionIds(const std::string& taskExecutionIds);
std::string getTaskExecutionId()const;
void setTaskExecutionId(const std::string& taskExecutionId);
std::string getParameters()const;
void setParameters(const std::string& parameters);
private:
std::string taskName_;
std::string executionId_;
std::string regionId_;
std::string notifyType_;
std::string executionStatus_;
std::string notifyNote_;
std::string loopItem_;
std::string taskExecutionIds_;
std::string taskExecutionId_;
std::string parameters_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_NOTIFYEXECUTIONREQUEST_H_

49
oos/include/alibabacloud/oos/model/NotifyExecutionResult.h Normal file
View File

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

78
oos/include/alibabacloud/oos/model/StartExecutionRequest.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_STARTEXECUTIONREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_STARTEXECUTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT StartExecutionRequest : public RpcServiceRequest
{
public:
StartExecutionRequest();
~StartExecutionRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getMode()const;
void setMode(const std::string& mode);
std::string getTemplateVersion()const;
void setTemplateVersion(const std::string& templateVersion);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
std::string getLoopMode()const;
void setLoopMode(const std::string& loopMode);
std::string getSafetyCheck()const;
void setSafetyCheck(const std::string& safetyCheck);
std::map<std::string, std::string> getTags()const;
void setTags(const std::map<std::string, std::string>& tags);
std::string getParentExecutionId()const;
void setParentExecutionId(const std::string& parentExecutionId);
std::string getParameters()const;
void setParameters(const std::string& parameters);
private:
std::string clientToken_;
std::string description_;
std::string mode_;
std::string templateVersion_;
std::string regionId_;
std::string templateName_;
std::string loopMode_;
std::string safetyCheck_;
std::map<std::string, std::string> tags_;
std::string parentExecutionId_;
std::string parameters_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_STARTEXECUTIONREQUEST_H_

83
oos/include/alibabacloud/oos/model/StartExecutionResult.h Normal file
View File

@@ -0,0 +1,83 @@
/*
* 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_OOS_MODEL_STARTEXECUTIONRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_STARTEXECUTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT StartExecutionResult : public ServiceResult
{
public:
struct Execution
{
struct CurrentTask
{
std::string taskName;
std::string taskAction;
std::string taskExecutionId;
};
std::vector<CurrentTask> currentTasks;
std::string status;
std::string parentExecutionId;
std::string loopMode;
std::string parameters;
std::string description;
bool isParent;
std::string mode;
std::string templateVersion;
std::string endDate;
std::string createDate;
std::string statusMessage;
std::string startDate;
std::string updateDate;
std::string safetyCheck;
std::string outputs;
std::string ramRole;
std::string templateName;
std::string counters;
std::string templateId;
std::string executedBy;
std::string tags;
std::string executionId;
};
StartExecutionResult();
explicit StartExecutionResult(const std::string &payload);
~StartExecutionResult();
Execution getExecution()const;
protected:
void parse(const std::string &payload);
private:
Execution execution_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_STARTEXECUTIONRESULT_H_

57
oos/include/alibabacloud/oos/model/TagResourcesRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_TAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_TAGRESOURCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT TagResourcesRequest : public RpcServiceRequest
{
public:
TagResourcesRequest();
~TagResourcesRequest();
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::map<std::string, std::string> getTags()const;
void setTags(const std::map<std::string, std::string>& tags);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::map<std::string, std::string> getResourceIds()const;
void setResourceIds(const std::map<std::string, std::string>& resourceIds);
private:
std::string resourceType_;
std::map<std::string, std::string> tags_;
std::string regionId_;
std::map<std::string, std::string> resourceIds_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_TAGRESOURCESREQUEST_H_

49
oos/include/alibabacloud/oos/model/TagResourcesResult.h Normal file
View File

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

60
oos/include/alibabacloud/oos/model/TriggerExecutionRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_TRIGGEREXECUTIONREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_TRIGGEREXECUTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT TriggerExecutionRequest : public RpcServiceRequest
{
public:
TriggerExecutionRequest();
~TriggerExecutionRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getType()const;
void setType(const std::string& type);
std::string getContent()const;
void setContent(const std::string& content);
std::string getExecutionId()const;
void setExecutionId(const std::string& executionId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string clientToken_;
std::string type_;
std::string content_;
std::string executionId_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_TRIGGEREXECUTIONREQUEST_H_

49
oos/include/alibabacloud/oos/model/TriggerExecutionResult.h Normal file
View File

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

60
oos/include/alibabacloud/oos/model/UntagResourcesRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_UNTAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_UNTAGRESOURCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT UntagResourcesRequest : public RpcServiceRequest
{
public:
UntagResourcesRequest();
~UntagResourcesRequest();
bool getAll()const;
void setAll(bool all);
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::map<std::string, std::string> getTagKeys()const;
void setTagKeys(const std::map<std::string, std::string>& tagKeys);
std::map<std::string, std::string> getResourceIds()const;
void setResourceIds(const std::map<std::string, std::string>& resourceIds);
private:
bool all_;
std::string resourceType_;
std::string regionId_;
std::map<std::string, std::string> tagKeys_;
std::map<std::string, std::string> resourceIds_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_UNTAGRESOURCESREQUEST_H_

49
oos/include/alibabacloud/oos/model/UntagResourcesResult.h Normal file
View File

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

57
oos/include/alibabacloud/oos/model/UpdateTemplateRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_UPDATETEMPLATEREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_UPDATETEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT UpdateTemplateRequest : public RpcServiceRequest
{
public:
UpdateTemplateRequest();
~UpdateTemplateRequest();
std::string getContent()const;
void setContent(const std::string& content);
std::map<std::string, std::string> getTags()const;
void setTags(const std::map<std::string, std::string>& tags);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
private:
std::string content_;
std::map<std::string, std::string> tags_;
std::string regionId_;
std::string templateName_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_UPDATETEMPLATEREQUEST_H_

67
oos/include/alibabacloud/oos/model/UpdateTemplateResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* 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_OOS_MODEL_UPDATETEMPLATERESULT_H_
#define ALIBABACLOUD_OOS_MODEL_UPDATETEMPLATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT UpdateTemplateResult : public ServiceResult
{
public:
struct _Template
{
std::string createdBy;
std::string description;
std::string templateFormat;
std::string updatedDate;
std::string templateVersion;
std::string hash;
std::string updatedBy;
bool hasTrigger;
std::string createdDate;
std::string templateName;
std::string templateId;
std::string tags;
std::string shareType;
};
UpdateTemplateResult();
explicit UpdateTemplateResult(const std::string &payload);
~UpdateTemplateResult();
_Template get_Template()const;
protected:
void parse(const std::string &payload);
private:
_Template _template_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_UPDATETEMPLATERESULT_H_

51
oos/include/alibabacloud/oos/model/ValidateTemplateContentRequest.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_OOS_MODEL_VALIDATETEMPLATECONTENTREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_VALIDATETEMPLATECONTENTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ValidateTemplateContentRequest : public RpcServiceRequest
{
public:
ValidateTemplateContentRequest();
~ValidateTemplateContentRequest();
std::string getContent()const;
void setContent(const std::string& content);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string content_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_VALIDATETEMPLATECONTENTREQUEST_H_

65
oos/include/alibabacloud/oos/model/ValidateTemplateContentResult.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_OOS_MODEL_VALIDATETEMPLATECONTENTRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_VALIDATETEMPLATECONTENTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ValidateTemplateContentResult : public ServiceResult
{
public:
struct Task
{
std::string type;
std::string description;
std::string outputs;
std::string properties;
std::string name;
};
ValidateTemplateContentResult();
explicit ValidateTemplateContentResult(const std::string &payload);
~ValidateTemplateContentResult();
std::vector<Task> getTasks()const;
std::string getParameters()const;
std::string getRamRole()const;
std::string getOutputs()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Task> tasks_;
std::string parameters_;
std::string ramRole_;
std::string outputs_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_VALIDATETEMPLATECONTENTRESULT_H_

953
oos/src/OosClient.cc Normal file
View File

@@ -0,0 +1,953 @@
/*
* 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/oos/OosClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
namespace
{
const std::string SERVICE_NAME = "oos";
}
OosClient::OosClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "oos");
}
OosClient::OosClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "oos");
}
OosClient::OosClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "oos");
}
OosClient::~OosClient()
{}
OosClient::CancelExecutionOutcome OosClient::cancelExecution(const CancelExecutionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CancelExecutionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CancelExecutionOutcome(CancelExecutionResult(outcome.result()));
else
return CancelExecutionOutcome(outcome.error());
}
void OosClient::cancelExecutionAsync(const CancelExecutionRequest& request, const CancelExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, cancelExecution(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::CancelExecutionOutcomeCallable OosClient::cancelExecutionCallable(const CancelExecutionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CancelExecutionOutcome()>>(
[this, request]()
{
return this->cancelExecution(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::CreateTemplateOutcome OosClient::createTemplate(const CreateTemplateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateTemplateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateTemplateOutcome(CreateTemplateResult(outcome.result()));
else
return CreateTemplateOutcome(outcome.error());
}
void OosClient::createTemplateAsync(const CreateTemplateRequest& request, const CreateTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createTemplate(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::CreateTemplateOutcomeCallable OosClient::createTemplateCallable(const CreateTemplateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateTemplateOutcome()>>(
[this, request]()
{
return this->createTemplate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::DeleteExecutionsOutcome OosClient::deleteExecutions(const DeleteExecutionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteExecutionsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteExecutionsOutcome(DeleteExecutionsResult(outcome.result()));
else
return DeleteExecutionsOutcome(outcome.error());
}
void OosClient::deleteExecutionsAsync(const DeleteExecutionsRequest& request, const DeleteExecutionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteExecutions(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::DeleteExecutionsOutcomeCallable OosClient::deleteExecutionsCallable(const DeleteExecutionsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteExecutionsOutcome()>>(
[this, request]()
{
return this->deleteExecutions(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::DeleteTemplateOutcome OosClient::deleteTemplate(const DeleteTemplateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteTemplateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteTemplateOutcome(DeleteTemplateResult(outcome.result()));
else
return DeleteTemplateOutcome(outcome.error());
}
void OosClient::deleteTemplateAsync(const DeleteTemplateRequest& request, const DeleteTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteTemplate(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::DeleteTemplateOutcomeCallable OosClient::deleteTemplateCallable(const DeleteTemplateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteTemplateOutcome()>>(
[this, request]()
{
return this->deleteTemplate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::DeleteTemplatesOutcome OosClient::deleteTemplates(const DeleteTemplatesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteTemplatesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteTemplatesOutcome(DeleteTemplatesResult(outcome.result()));
else
return DeleteTemplatesOutcome(outcome.error());
}
void OosClient::deleteTemplatesAsync(const DeleteTemplatesRequest& request, const DeleteTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteTemplates(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::DeleteTemplatesOutcomeCallable OosClient::deleteTemplatesCallable(const DeleteTemplatesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteTemplatesOutcome()>>(
[this, request]()
{
return this->deleteTemplates(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::DescribeRegionsOutcome OosClient::describeRegions(const DescribeRegionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeRegionsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeRegionsOutcome(DescribeRegionsResult(outcome.result()));
else
return DescribeRegionsOutcome(outcome.error());
}
void OosClient::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeRegions(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::DescribeRegionsOutcomeCallable OosClient::describeRegionsCallable(const DescribeRegionsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeRegionsOutcome()>>(
[this, request]()
{
return this->describeRegions(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::GenerateExecutionPolicyOutcome OosClient::generateExecutionPolicy(const GenerateExecutionPolicyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GenerateExecutionPolicyOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GenerateExecutionPolicyOutcome(GenerateExecutionPolicyResult(outcome.result()));
else
return GenerateExecutionPolicyOutcome(outcome.error());
}
void OosClient::generateExecutionPolicyAsync(const GenerateExecutionPolicyRequest& request, const GenerateExecutionPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, generateExecutionPolicy(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::GenerateExecutionPolicyOutcomeCallable OosClient::generateExecutionPolicyCallable(const GenerateExecutionPolicyRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GenerateExecutionPolicyOutcome()>>(
[this, request]()
{
return this->generateExecutionPolicy(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::GetExecutionTemplateOutcome OosClient::getExecutionTemplate(const GetExecutionTemplateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetExecutionTemplateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetExecutionTemplateOutcome(GetExecutionTemplateResult(outcome.result()));
else
return GetExecutionTemplateOutcome(outcome.error());
}
void OosClient::getExecutionTemplateAsync(const GetExecutionTemplateRequest& request, const GetExecutionTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getExecutionTemplate(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::GetExecutionTemplateOutcomeCallable OosClient::getExecutionTemplateCallable(const GetExecutionTemplateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetExecutionTemplateOutcome()>>(
[this, request]()
{
return this->getExecutionTemplate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::GetTemplateOutcome OosClient::getTemplate(const GetTemplateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetTemplateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetTemplateOutcome(GetTemplateResult(outcome.result()));
else
return GetTemplateOutcome(outcome.error());
}
void OosClient::getTemplateAsync(const GetTemplateRequest& request, const GetTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getTemplate(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::GetTemplateOutcomeCallable OosClient::getTemplateCallable(const GetTemplateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetTemplateOutcome()>>(
[this, request]()
{
return this->getTemplate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::ListActionsOutcome OosClient::listActions(const ListActionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListActionsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListActionsOutcome(ListActionsResult(outcome.result()));
else
return ListActionsOutcome(outcome.error());
}
void OosClient::listActionsAsync(const ListActionsRequest& request, const ListActionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listActions(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::ListActionsOutcomeCallable OosClient::listActionsCallable(const ListActionsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListActionsOutcome()>>(
[this, request]()
{
return this->listActions(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::ListExecutionLogsOutcome OosClient::listExecutionLogs(const ListExecutionLogsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListExecutionLogsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListExecutionLogsOutcome(ListExecutionLogsResult(outcome.result()));
else
return ListExecutionLogsOutcome(outcome.error());
}
void OosClient::listExecutionLogsAsync(const ListExecutionLogsRequest& request, const ListExecutionLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listExecutionLogs(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::ListExecutionLogsOutcomeCallable OosClient::listExecutionLogsCallable(const ListExecutionLogsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListExecutionLogsOutcome()>>(
[this, request]()
{
return this->listExecutionLogs(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::ListExecutionRiskyTasksOutcome OosClient::listExecutionRiskyTasks(const ListExecutionRiskyTasksRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListExecutionRiskyTasksOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListExecutionRiskyTasksOutcome(ListExecutionRiskyTasksResult(outcome.result()));
else
return ListExecutionRiskyTasksOutcome(outcome.error());
}
void OosClient::listExecutionRiskyTasksAsync(const ListExecutionRiskyTasksRequest& request, const ListExecutionRiskyTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listExecutionRiskyTasks(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::ListExecutionRiskyTasksOutcomeCallable OosClient::listExecutionRiskyTasksCallable(const ListExecutionRiskyTasksRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListExecutionRiskyTasksOutcome()>>(
[this, request]()
{
return this->listExecutionRiskyTasks(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::ListExecutionsOutcome OosClient::listExecutions(const ListExecutionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListExecutionsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListExecutionsOutcome(ListExecutionsResult(outcome.result()));
else
return ListExecutionsOutcome(outcome.error());
}
void OosClient::listExecutionsAsync(const ListExecutionsRequest& request, const ListExecutionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listExecutions(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::ListExecutionsOutcomeCallable OosClient::listExecutionsCallable(const ListExecutionsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListExecutionsOutcome()>>(
[this, request]()
{
return this->listExecutions(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::ListTagKeysOutcome OosClient::listTagKeys(const ListTagKeysRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListTagKeysOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListTagKeysOutcome(ListTagKeysResult(outcome.result()));
else
return ListTagKeysOutcome(outcome.error());
}
void OosClient::listTagKeysAsync(const ListTagKeysRequest& request, const ListTagKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listTagKeys(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::ListTagKeysOutcomeCallable OosClient::listTagKeysCallable(const ListTagKeysRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListTagKeysOutcome()>>(
[this, request]()
{
return this->listTagKeys(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::ListTagResourcesOutcome OosClient::listTagResources(const ListTagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListTagResourcesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListTagResourcesOutcome(ListTagResourcesResult(outcome.result()));
else
return ListTagResourcesOutcome(outcome.error());
}
void OosClient::listTagResourcesAsync(const ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listTagResources(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::ListTagResourcesOutcomeCallable OosClient::listTagResourcesCallable(const ListTagResourcesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListTagResourcesOutcome()>>(
[this, request]()
{
return this->listTagResources(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::ListTagValuesOutcome OosClient::listTagValues(const ListTagValuesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListTagValuesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListTagValuesOutcome(ListTagValuesResult(outcome.result()));
else
return ListTagValuesOutcome(outcome.error());
}
void OosClient::listTagValuesAsync(const ListTagValuesRequest& request, const ListTagValuesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listTagValues(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::ListTagValuesOutcomeCallable OosClient::listTagValuesCallable(const ListTagValuesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListTagValuesOutcome()>>(
[this, request]()
{
return this->listTagValues(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::ListTaskExecutionsOutcome OosClient::listTaskExecutions(const ListTaskExecutionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListTaskExecutionsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListTaskExecutionsOutcome(ListTaskExecutionsResult(outcome.result()));
else
return ListTaskExecutionsOutcome(outcome.error());
}
void OosClient::listTaskExecutionsAsync(const ListTaskExecutionsRequest& request, const ListTaskExecutionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listTaskExecutions(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::ListTaskExecutionsOutcomeCallable OosClient::listTaskExecutionsCallable(const ListTaskExecutionsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListTaskExecutionsOutcome()>>(
[this, request]()
{
return this->listTaskExecutions(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::ListTemplatesOutcome OosClient::listTemplates(const ListTemplatesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListTemplatesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListTemplatesOutcome(ListTemplatesResult(outcome.result()));
else
return ListTemplatesOutcome(outcome.error());
}
void OosClient::listTemplatesAsync(const ListTemplatesRequest& request, const ListTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listTemplates(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::ListTemplatesOutcomeCallable OosClient::listTemplatesCallable(const ListTemplatesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListTemplatesOutcome()>>(
[this, request]()
{
return this->listTemplates(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::NotifyExecutionOutcome OosClient::notifyExecution(const NotifyExecutionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return NotifyExecutionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return NotifyExecutionOutcome(NotifyExecutionResult(outcome.result()));
else
return NotifyExecutionOutcome(outcome.error());
}
void OosClient::notifyExecutionAsync(const NotifyExecutionRequest& request, const NotifyExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, notifyExecution(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::NotifyExecutionOutcomeCallable OosClient::notifyExecutionCallable(const NotifyExecutionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<NotifyExecutionOutcome()>>(
[this, request]()
{
return this->notifyExecution(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::StartExecutionOutcome OosClient::startExecution(const StartExecutionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StartExecutionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StartExecutionOutcome(StartExecutionResult(outcome.result()));
else
return StartExecutionOutcome(outcome.error());
}
void OosClient::startExecutionAsync(const StartExecutionRequest& request, const StartExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, startExecution(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::StartExecutionOutcomeCallable OosClient::startExecutionCallable(const StartExecutionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StartExecutionOutcome()>>(
[this, request]()
{
return this->startExecution(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::TagResourcesOutcome OosClient::tagResources(const TagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return TagResourcesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return TagResourcesOutcome(TagResourcesResult(outcome.result()));
else
return TagResourcesOutcome(outcome.error());
}
void OosClient::tagResourcesAsync(const TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, tagResources(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::TagResourcesOutcomeCallable OosClient::tagResourcesCallable(const TagResourcesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<TagResourcesOutcome()>>(
[this, request]()
{
return this->tagResources(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::TriggerExecutionOutcome OosClient::triggerExecution(const TriggerExecutionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return TriggerExecutionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return TriggerExecutionOutcome(TriggerExecutionResult(outcome.result()));
else
return TriggerExecutionOutcome(outcome.error());
}
void OosClient::triggerExecutionAsync(const TriggerExecutionRequest& request, const TriggerExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, triggerExecution(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::TriggerExecutionOutcomeCallable OosClient::triggerExecutionCallable(const TriggerExecutionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<TriggerExecutionOutcome()>>(
[this, request]()
{
return this->triggerExecution(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::UntagResourcesOutcome OosClient::untagResources(const UntagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UntagResourcesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UntagResourcesOutcome(UntagResourcesResult(outcome.result()));
else
return UntagResourcesOutcome(outcome.error());
}
void OosClient::untagResourcesAsync(const UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, untagResources(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::UntagResourcesOutcomeCallable OosClient::untagResourcesCallable(const UntagResourcesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UntagResourcesOutcome()>>(
[this, request]()
{
return this->untagResources(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::UpdateTemplateOutcome OosClient::updateTemplate(const UpdateTemplateRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateTemplateOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateTemplateOutcome(UpdateTemplateResult(outcome.result()));
else
return UpdateTemplateOutcome(outcome.error());
}
void OosClient::updateTemplateAsync(const UpdateTemplateRequest& request, const UpdateTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateTemplate(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::UpdateTemplateOutcomeCallable OosClient::updateTemplateCallable(const UpdateTemplateRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateTemplateOutcome()>>(
[this, request]()
{
return this->updateTemplate(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OosClient::ValidateTemplateContentOutcome OosClient::validateTemplateContent(const ValidateTemplateContentRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ValidateTemplateContentOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ValidateTemplateContentOutcome(ValidateTemplateContentResult(outcome.result()));
else
return ValidateTemplateContentOutcome(outcome.error());
}
void OosClient::validateTemplateContentAsync(const ValidateTemplateContentRequest& request, const ValidateTemplateContentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, validateTemplateContent(request), context);
};
asyncExecute(new Runnable(fn));
}
OosClient::ValidateTemplateContentOutcomeCallable OosClient::validateTemplateContentCallable(const ValidateTemplateContentRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ValidateTemplateContentOutcome()>>(
[this, request]()
{
return this->validateTemplateContent(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

51
oos/src/model/CancelExecutionRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oos/model/CancelExecutionRequest.h>
using AlibabaCloud::Oos::Model::CancelExecutionRequest;
CancelExecutionRequest::CancelExecutionRequest() :
RpcServiceRequest("oos", "2019-06-01", "CancelExecution")
{
setMethod(HttpRequest::Method::Post);
}
CancelExecutionRequest::~CancelExecutionRequest()
{}
std::string CancelExecutionRequest::getExecutionId()const
{
return executionId_;
}
void CancelExecutionRequest::setExecutionId(const std::string& executionId)
{
executionId_ = executionId;
setParameter("ExecutionId", executionId);
}
std::string CancelExecutionRequest::getRegionId()const
{
return regionId_;
}
void CancelExecutionRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}

44
oos/src/model/CancelExecutionResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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/oos/model/CancelExecutionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
CancelExecutionResult::CancelExecutionResult() :
ServiceResult()
{}
CancelExecutionResult::CancelExecutionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CancelExecutionResult::~CancelExecutionResult()
{}
void CancelExecutionResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

73
oos/src/model/CreateTemplateRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oos/model/CreateTemplateRequest.h>
using AlibabaCloud::Oos::Model::CreateTemplateRequest;
CreateTemplateRequest::CreateTemplateRequest() :
RpcServiceRequest("oos", "2019-06-01", "CreateTemplate")
{
setMethod(HttpRequest::Method::Post);
}
CreateTemplateRequest::~CreateTemplateRequest()
{}
std::string CreateTemplateRequest::getContent()const
{
return content_;
}
void CreateTemplateRequest::setContent(const std::string& content)
{
content_ = content;
setParameter("Content", content);
}
std::map<std::string, std::string> CreateTemplateRequest::getTags()const
{
return tags_;
}
void CreateTemplateRequest::setTags(const std::map<std::string, std::string>& tags)
{
tags_ = tags;
setJsonParameters("Tags", tags);
}
std::string CreateTemplateRequest::getRegionId()const
{
return regionId_;
}
void CreateTemplateRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateTemplateRequest::getTemplateName()const
{
return templateName_;
}
void CreateTemplateRequest::setTemplateName(const std::string& templateName)
{
templateName_ = templateName;
setParameter("TemplateName", templateName);
}

76
oos/src/model/CreateTemplateResult.cc Normal file
View File

@@ -0,0 +1,76 @@
/*
* 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/oos/model/CreateTemplateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
CreateTemplateResult::CreateTemplateResult() :
ServiceResult()
{}
CreateTemplateResult::CreateTemplateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateTemplateResult::~CreateTemplateResult()
{}
void CreateTemplateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto _templateNode = value["Template"];
if(!_templateNode["TemplateName"].isNull())
_template_.templateName = _templateNode["TemplateName"].asString();
if(!_templateNode["TemplateId"].isNull())
_template_.templateId = _templateNode["TemplateId"].asString();
if(!_templateNode["CreatedDate"].isNull())
_template_.createdDate = _templateNode["CreatedDate"].asString();
if(!_templateNode["CreatedBy"].isNull())
_template_.createdBy = _templateNode["CreatedBy"].asString();
if(!_templateNode["UpdatedDate"].isNull())
_template_.updatedDate = _templateNode["UpdatedDate"].asString();
if(!_templateNode["UpdatedBy"].isNull())
_template_.updatedBy = _templateNode["UpdatedBy"].asString();
if(!_templateNode["Hash"].isNull())
_template_.hash = _templateNode["Hash"].asString();
if(!_templateNode["Description"].isNull())
_template_.description = _templateNode["Description"].asString();
if(!_templateNode["ShareType"].isNull())
_template_.shareType = _templateNode["ShareType"].asString();
if(!_templateNode["TemplateFormat"].isNull())
_template_.templateFormat = _templateNode["TemplateFormat"].asString();
if(!_templateNode["TemplateVersion"].isNull())
_template_.templateVersion = _templateNode["TemplateVersion"].asString();
if(!_templateNode["HasTrigger"].isNull())
_template_.hasTrigger = _templateNode["HasTrigger"].asString() == "true";
if(!_templateNode["Tags"].isNull())
_template_.tags = _templateNode["Tags"].asString();
}
CreateTemplateResult::_Template CreateTemplateResult::get_Template()const
{
return _template_;
}

51
oos/src/model/DeleteExecutionsRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oos/model/DeleteExecutionsRequest.h>
using AlibabaCloud::Oos::Model::DeleteExecutionsRequest;
DeleteExecutionsRequest::DeleteExecutionsRequest() :
RpcServiceRequest("oos", "2019-06-01", "DeleteExecutions")
{
setMethod(HttpRequest::Method::Post);
}
DeleteExecutionsRequest::~DeleteExecutionsRequest()
{}
std::string DeleteExecutionsRequest::getExecutionIds()const
{
return executionIds_;
}
void DeleteExecutionsRequest::setExecutionIds(const std::string& executionIds)
{
executionIds_ = executionIds;
setParameter("ExecutionIds", executionIds);
}
std::string DeleteExecutionsRequest::getRegionId()const
{
return regionId_;
}
void DeleteExecutionsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}

44
oos/src/model/DeleteExecutionsResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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/oos/model/DeleteExecutionsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
DeleteExecutionsResult::DeleteExecutionsResult() :
ServiceResult()
{}
DeleteExecutionsResult::DeleteExecutionsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteExecutionsResult::~DeleteExecutionsResult()
{}
void DeleteExecutionsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

62
oos/src/model/DeleteTemplateRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oos/model/DeleteTemplateRequest.h>
using AlibabaCloud::Oos::Model::DeleteTemplateRequest;
DeleteTemplateRequest::DeleteTemplateRequest() :
RpcServiceRequest("oos", "2019-06-01", "DeleteTemplate")
{
setMethod(HttpRequest::Method::Post);
}
DeleteTemplateRequest::~DeleteTemplateRequest()
{}
std::string DeleteTemplateRequest::getRegionId()const
{
return regionId_;
}
void DeleteTemplateRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
bool DeleteTemplateRequest::getAutoDeleteExecutions()const
{
return autoDeleteExecutions_;
}
void DeleteTemplateRequest::setAutoDeleteExecutions(bool autoDeleteExecutions)
{
autoDeleteExecutions_ = autoDeleteExecutions;
setParameter("AutoDeleteExecutions", autoDeleteExecutions ? "true" : "false");
}
std::string DeleteTemplateRequest::getTemplateName()const
{
return templateName_;
}
void DeleteTemplateRequest::setTemplateName(const std::string& templateName)
{
templateName_ = templateName;
setParameter("TemplateName", templateName);
}

44
oos/src/model/DeleteTemplateResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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/oos/model/DeleteTemplateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
DeleteTemplateResult::DeleteTemplateResult() :
ServiceResult()
{}
DeleteTemplateResult::DeleteTemplateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteTemplateResult::~DeleteTemplateResult()
{}
void DeleteTemplateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

62
oos/src/model/DeleteTemplatesRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oos/model/DeleteTemplatesRequest.h>
using AlibabaCloud::Oos::Model::DeleteTemplatesRequest;
DeleteTemplatesRequest::DeleteTemplatesRequest() :
RpcServiceRequest("oos", "2019-06-01", "DeleteTemplates")
{
setMethod(HttpRequest::Method::Post);
}
DeleteTemplatesRequest::~DeleteTemplatesRequest()
{}
std::string DeleteTemplatesRequest::getTemplateNames()const
{
return templateNames_;
}
void DeleteTemplatesRequest::setTemplateNames(const std::string& templateNames)
{
templateNames_ = templateNames;
setParameter("TemplateNames", templateNames);
}
std::string DeleteTemplatesRequest::getRegionId()const
{
return regionId_;
}
void DeleteTemplatesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
bool DeleteTemplatesRequest::getAutoDeleteExecutions()const
{
return autoDeleteExecutions_;
}
void DeleteTemplatesRequest::setAutoDeleteExecutions(bool autoDeleteExecutions)
{
autoDeleteExecutions_ = autoDeleteExecutions;
setParameter("AutoDeleteExecutions", autoDeleteExecutions ? "true" : "false");
}

44
oos/src/model/DeleteTemplatesResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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/oos/model/DeleteTemplatesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
DeleteTemplatesResult::DeleteTemplatesResult() :
ServiceResult()
{}
DeleteTemplatesResult::DeleteTemplatesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteTemplatesResult::~DeleteTemplatesResult()
{}
void DeleteTemplatesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

51
oos/src/model/DescribeRegionsRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oos/model/DescribeRegionsRequest.h>
using AlibabaCloud::Oos::Model::DescribeRegionsRequest;
DescribeRegionsRequest::DescribeRegionsRequest() :
RpcServiceRequest("oos", "2019-06-01", "DescribeRegions")
{
setMethod(HttpRequest::Method::Post);
}
DescribeRegionsRequest::~DescribeRegionsRequest()
{}
std::string DescribeRegionsRequest::getRegionId()const
{
return regionId_;
}
void DescribeRegionsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeRegionsRequest::getAcceptLanguage()const
{
return acceptLanguage_;
}
void DescribeRegionsRequest::setAcceptLanguage(const std::string& acceptLanguage)
{
acceptLanguage_ = acceptLanguage;
setParameter("AcceptLanguage", acceptLanguage);
}

61
oos/src/model/DescribeRegionsResult.cc Normal file
View File

@@ -0,0 +1,61 @@
/*
* 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/oos/model/DescribeRegionsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
DescribeRegionsResult::DescribeRegionsResult() :
ServiceResult()
{}
DescribeRegionsResult::DescribeRegionsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeRegionsResult::~DescribeRegionsResult()
{}
void DescribeRegionsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allRegionsNode = value["Regions"]["Region"];
for (auto valueRegionsRegion : allRegionsNode)
{
Region regionsObject;
if(!valueRegionsRegion["RegionId"].isNull())
regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
if(!valueRegionsRegion["RegionEndpoint"].isNull())
regionsObject.regionEndpoint = valueRegionsRegion["RegionEndpoint"].asString();
if(!valueRegionsRegion["LocalName"].isNull())
regionsObject.localName = valueRegionsRegion["LocalName"].asString();
regions_.push_back(regionsObject);
}
}
std::vector<DescribeRegionsResult::Region> DescribeRegionsResult::getRegions()const
{
return regions_;
}

51
oos/src/model/GenerateExecutionPolicyRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oos/model/GenerateExecutionPolicyRequest.h>
using AlibabaCloud::Oos::Model::GenerateExecutionPolicyRequest;
GenerateExecutionPolicyRequest::GenerateExecutionPolicyRequest() :
RpcServiceRequest("oos", "2019-06-01", "GenerateExecutionPolicy")
{
setMethod(HttpRequest::Method::Post);
}
GenerateExecutionPolicyRequest::~GenerateExecutionPolicyRequest()
{}
std::string GenerateExecutionPolicyRequest::getRegionId()const
{
return regionId_;
}
void GenerateExecutionPolicyRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string GenerateExecutionPolicyRequest::getTemplateName()const
{
return templateName_;
}
void GenerateExecutionPolicyRequest::setTemplateName(const std::string& templateName)
{
templateName_ = templateName;
setParameter("TemplateName", templateName);
}

51
oos/src/model/GenerateExecutionPolicyResult.cc Normal file
View File

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

51
oos/src/model/GetExecutionTemplateRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oos/model/GetExecutionTemplateRequest.h>
using AlibabaCloud::Oos::Model::GetExecutionTemplateRequest;
GetExecutionTemplateRequest::GetExecutionTemplateRequest() :
RpcServiceRequest("oos", "2019-06-01", "GetExecutionTemplate")
{
setMethod(HttpRequest::Method::Post);
}
GetExecutionTemplateRequest::~GetExecutionTemplateRequest()
{}
std::string GetExecutionTemplateRequest::getExecutionId()const
{
return executionId_;
}
void GetExecutionTemplateRequest::setExecutionId(const std::string& executionId)
{
executionId_ = executionId;
setParameter("ExecutionId", executionId);
}
std::string GetExecutionTemplateRequest::getRegionId()const
{
return regionId_;
}
void GetExecutionTemplateRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}

81
oos/src/model/GetExecutionTemplateResult.cc Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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/oos/model/GetExecutionTemplateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
GetExecutionTemplateResult::GetExecutionTemplateResult() :
ServiceResult()
{}
GetExecutionTemplateResult::GetExecutionTemplateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetExecutionTemplateResult::~GetExecutionTemplateResult()
{}
void GetExecutionTemplateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto _templateNode = value["Template"];
if(!_templateNode["TemplateName"].isNull())
_template_.templateName = _templateNode["TemplateName"].asString();
if(!_templateNode["TemplateId"].isNull())
_template_.templateId = _templateNode["TemplateId"].asString();
if(!_templateNode["CreatedDate"].isNull())
_template_.createdDate = _templateNode["CreatedDate"].asString();
if(!_templateNode["CreatedBy"].isNull())
_template_.createdBy = _templateNode["CreatedBy"].asString();
if(!_templateNode["UpdatedDate"].isNull())
_template_.updatedDate = _templateNode["UpdatedDate"].asString();
if(!_templateNode["UpdatedBy"].isNull())
_template_.updatedBy = _templateNode["UpdatedBy"].asString();
if(!_templateNode["Hash"].isNull())
_template_.hash = _templateNode["Hash"].asString();
if(!_templateNode["Description"].isNull())
_template_.description = _templateNode["Description"].asString();
if(!_templateNode["ShareType"].isNull())
_template_.shareType = _templateNode["ShareType"].asString();
if(!_templateNode["TemplateFormat"].isNull())
_template_.templateFormat = _templateNode["TemplateFormat"].asString();
if(!_templateNode["TemplateVersion"].isNull())
_template_.templateVersion = _templateNode["TemplateVersion"].asString();
if(!_templateNode["Tags"].isNull())
_template_.tags = _templateNode["Tags"].asString();
if(!value["Content"].isNull())
content_ = value["Content"].asString();
}
GetExecutionTemplateResult::_Template GetExecutionTemplateResult::get_Template()const
{
return _template_;
}
std::string GetExecutionTemplateResult::getContent()const
{
return content_;
}

62
oos/src/model/GetTemplateRequest.cc Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oos/model/GetTemplateRequest.h>
using AlibabaCloud::Oos::Model::GetTemplateRequest;
GetTemplateRequest::GetTemplateRequest() :
RpcServiceRequest("oos", "2019-06-01", "GetTemplate")
{
setMethod(HttpRequest::Method::Post);
}
GetTemplateRequest::~GetTemplateRequest()
{}
std::string GetTemplateRequest::getTemplateVersion()const
{
return templateVersion_;
}
void GetTemplateRequest::setTemplateVersion(const std::string& templateVersion)
{
templateVersion_ = templateVersion;
setParameter("TemplateVersion", templateVersion);
}
std::string GetTemplateRequest::getRegionId()const
{
return regionId_;
}
void GetTemplateRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string GetTemplateRequest::getTemplateName()const
{
return templateName_;
}
void GetTemplateRequest::setTemplateName(const std::string& templateName)
{
templateName_ = templateName;
setParameter("TemplateName", templateName);
}

83
oos/src/model/GetTemplateResult.cc Normal file
View File

@@ -0,0 +1,83 @@
/*
* 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/oos/model/GetTemplateResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
GetTemplateResult::GetTemplateResult() :
ServiceResult()
{}
GetTemplateResult::GetTemplateResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetTemplateResult::~GetTemplateResult()
{}
void GetTemplateResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto _templateNode = value["Template"];
if(!_templateNode["TemplateName"].isNull())
_template_.templateName = _templateNode["TemplateName"].asString();
if(!_templateNode["TemplateId"].isNull())
_template_.templateId = _templateNode["TemplateId"].asString();
if(!_templateNode["CreatedDate"].isNull())
_template_.createdDate = _templateNode["CreatedDate"].asString();
if(!_templateNode["CreatedBy"].isNull())
_template_.createdBy = _templateNode["CreatedBy"].asString();
if(!_templateNode["UpdatedDate"].isNull())
_template_.updatedDate = _templateNode["UpdatedDate"].asString();
if(!_templateNode["UpdatedBy"].isNull())
_template_.updatedBy = _templateNode["UpdatedBy"].asString();
if(!_templateNode["Hash"].isNull())
_template_.hash = _templateNode["Hash"].asString();
if(!_templateNode["Description"].isNull())
_template_.description = _templateNode["Description"].asString();
if(!_templateNode["ShareType"].isNull())
_template_.shareType = _templateNode["ShareType"].asString();
if(!_templateNode["TemplateFormat"].isNull())
_template_.templateFormat = _templateNode["TemplateFormat"].asString();
if(!_templateNode["TemplateVersion"].isNull())
_template_.templateVersion = _templateNode["TemplateVersion"].asString();
if(!_templateNode["HasTrigger"].isNull())
_template_.hasTrigger = _templateNode["HasTrigger"].asString() == "true";
if(!_templateNode["Tags"].isNull())
_template_.tags = _templateNode["Tags"].asString();
if(!value["Content"].isNull())
content_ = value["Content"].asString();
}
GetTemplateResult::_Template GetTemplateResult::get_Template()const
{
return _template_;
}
std::string GetTemplateResult::getContent()const
{
return content_;
}

73
oos/src/model/ListActionsRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oos/model/ListActionsRequest.h>
using AlibabaCloud::Oos::Model::ListActionsRequest;
ListActionsRequest::ListActionsRequest() :
RpcServiceRequest("oos", "2019-06-01", "ListActions")
{
setMethod(HttpRequest::Method::Post);
}
ListActionsRequest::~ListActionsRequest()
{}
std::string ListActionsRequest::getOOSActionName()const
{
return oOSActionName_;
}
void ListActionsRequest::setOOSActionName(const std::string& oOSActionName)
{
oOSActionName_ = oOSActionName;
setParameter("OOSActionName", oOSActionName);
}
std::string ListActionsRequest::getRegionId()const
{
return regionId_;
}
void ListActionsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ListActionsRequest::getNextToken()const
{
return nextToken_;
}
void ListActionsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
int ListActionsRequest::getMaxResults()const
{
return maxResults_;
}
void ListActionsRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}

81
oos/src/model/ListActionsResult.cc Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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/oos/model/ListActionsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
ListActionsResult::ListActionsResult() :
ServiceResult()
{}
ListActionsResult::ListActionsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListActionsResult::~ListActionsResult()
{}
void ListActionsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allActionsNode = value["Actions"]["Action"];
for (auto valueActionsAction : allActionsNode)
{
Action actionsObject;
if(!valueActionsAction["OOSActionName"].isNull())
actionsObject.oOSActionName = valueActionsAction["OOSActionName"].asString();
if(!valueActionsAction["Description"].isNull())
actionsObject.description = valueActionsAction["Description"].asString();
if(!valueActionsAction["ActionType"].isNull())
actionsObject.actionType = valueActionsAction["ActionType"].asString();
if(!valueActionsAction["CreatedDate"].isNull())
actionsObject.createdDate = valueActionsAction["CreatedDate"].asString();
if(!valueActionsAction["Properties"].isNull())
actionsObject.properties = valueActionsAction["Properties"].asString();
if(!valueActionsAction["TemplateVersion"].isNull())
actionsObject.templateVersion = valueActionsAction["TemplateVersion"].asString();
actions_.push_back(actionsObject);
}
if(!value["MaxResults"].isNull())
maxResults_ = std::stoi(value["MaxResults"].asString());
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::string ListActionsResult::getNextToken()const
{
return nextToken_;
}
std::vector<ListActionsResult::Action> ListActionsResult::getActions()const
{
return actions_;
}
int ListActionsResult::getMaxResults()const
{
return maxResults_;
}

95
oos/src/model/ListExecutionLogsRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oos/model/ListExecutionLogsRequest.h>
using AlibabaCloud::Oos::Model::ListExecutionLogsRequest;
ListExecutionLogsRequest::ListExecutionLogsRequest() :
RpcServiceRequest("oos", "2019-06-01", "ListExecutionLogs")
{
setMethod(HttpRequest::Method::Post);
}
ListExecutionLogsRequest::~ListExecutionLogsRequest()
{}
std::string ListExecutionLogsRequest::getExecutionId()const
{
return executionId_;
}
void ListExecutionLogsRequest::setExecutionId(const std::string& executionId)
{
executionId_ = executionId;
setParameter("ExecutionId", executionId);
}
std::string ListExecutionLogsRequest::getLogType()const
{
return logType_;
}
void ListExecutionLogsRequest::setLogType(const std::string& logType)
{
logType_ = logType;
setParameter("LogType", logType);
}
std::string ListExecutionLogsRequest::getRegionId()const
{
return regionId_;
}
void ListExecutionLogsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ListExecutionLogsRequest::getNextToken()const
{
return nextToken_;
}
void ListExecutionLogsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
int ListExecutionLogsRequest::getMaxResults()const
{
return maxResults_;
}
void ListExecutionLogsRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}
std::string ListExecutionLogsRequest::getTaskExecutionId()const
{
return taskExecutionId_;
}
void ListExecutionLogsRequest::setTaskExecutionId(const std::string& taskExecutionId)
{
taskExecutionId_ = taskExecutionId;
setParameter("TaskExecutionId", taskExecutionId);
}

84
oos/src/model/ListExecutionLogsResult.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* 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/oos/model/ListExecutionLogsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
ListExecutionLogsResult::ListExecutionLogsResult() :
ServiceResult()
{}
ListExecutionLogsResult::ListExecutionLogsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListExecutionLogsResult::~ListExecutionLogsResult()
{}
void ListExecutionLogsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allExecutionLogsNode = value["ExecutionLogs"]["ExecutionLog"];
for (auto valueExecutionLogsExecutionLog : allExecutionLogsNode)
{
ExecutionLog executionLogsObject;
if(!valueExecutionLogsExecutionLog["Timestamp"].isNull())
executionLogsObject.timestamp = valueExecutionLogsExecutionLog["Timestamp"].asString();
if(!valueExecutionLogsExecutionLog["Message"].isNull())
executionLogsObject.message = valueExecutionLogsExecutionLog["Message"].asString();
if(!valueExecutionLogsExecutionLog["TaskExecutionId"].isNull())
executionLogsObject.taskExecutionId = valueExecutionLogsExecutionLog["TaskExecutionId"].asString();
if(!valueExecutionLogsExecutionLog["LogType"].isNull())
executionLogsObject.logType = valueExecutionLogsExecutionLog["LogType"].asString();
executionLogs_.push_back(executionLogsObject);
}
if(!value["MaxResults"].isNull())
maxResults_ = std::stoi(value["MaxResults"].asString());
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
if(!value["IsTruncated"].isNull())
isTruncated_ = value["IsTruncated"].asString() == "true";
}
std::string ListExecutionLogsResult::getNextToken()const
{
return nextToken_;
}
std::vector<ListExecutionLogsResult::ExecutionLog> ListExecutionLogsResult::getExecutionLogs()const
{
return executionLogs_;
}
int ListExecutionLogsResult::getMaxResults()const
{
return maxResults_;
}
bool ListExecutionLogsResult::getIsTruncated()const
{
return isTruncated_;
}

51
oos/src/model/ListExecutionRiskyTasksRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oos/model/ListExecutionRiskyTasksRequest.h>
using AlibabaCloud::Oos::Model::ListExecutionRiskyTasksRequest;
ListExecutionRiskyTasksRequest::ListExecutionRiskyTasksRequest() :
RpcServiceRequest("oos", "2019-06-01", "ListExecutionRiskyTasks")
{
setMethod(HttpRequest::Method::Post);
}
ListExecutionRiskyTasksRequest::~ListExecutionRiskyTasksRequest()
{}
std::string ListExecutionRiskyTasksRequest::getRegionId()const
{
return regionId_;
}
void ListExecutionRiskyTasksRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ListExecutionRiskyTasksRequest::getTemplateName()const
{
return templateName_;
}
void ListExecutionRiskyTasksRequest::setTemplateName(const std::string& templateName)
{
templateName_ = templateName;
setParameter("TemplateName", templateName);
}

65
oos/src/model/ListExecutionRiskyTasksResult.cc 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.
*/
#include <alibabacloud/oos/model/ListExecutionRiskyTasksResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
ListExecutionRiskyTasksResult::ListExecutionRiskyTasksResult() :
ServiceResult()
{}
ListExecutionRiskyTasksResult::ListExecutionRiskyTasksResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListExecutionRiskyTasksResult::~ListExecutionRiskyTasksResult()
{}
void ListExecutionRiskyTasksResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allRiskyTasksNode = value["RiskyTasks"]["RiskyTask"];
for (auto valueRiskyTasksRiskyTask : allRiskyTasksNode)
{
RiskyTask riskyTasksObject;
if(!valueRiskyTasksRiskyTask["Service"].isNull())
riskyTasksObject.service = valueRiskyTasksRiskyTask["Service"].asString();
if(!valueRiskyTasksRiskyTask["API"].isNull())
riskyTasksObject.aPI = valueRiskyTasksRiskyTask["API"].asString();
auto allTask = value["Task"]["Task"];
for (auto value : allTask)
riskyTasksObject.task.push_back(value.asString());
auto all_Template = value["Template"]["Template"];
for (auto value : all_Template)
riskyTasksObject._template.push_back(value.asString());
riskyTasks_.push_back(riskyTasksObject);
}
}
std::vector<ListExecutionRiskyTasksResult::RiskyTask> ListExecutionRiskyTasksResult::getRiskyTasks()const
{
return riskyTasks_;
}

238
oos/src/model/ListExecutionsRequest.cc Normal file
View File

@@ -0,0 +1,238 @@
/*
* 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/oos/model/ListExecutionsRequest.h>
using AlibabaCloud::Oos::Model::ListExecutionsRequest;
ListExecutionsRequest::ListExecutionsRequest() :
RpcServiceRequest("oos", "2019-06-01", "ListExecutions")
{
setMethod(HttpRequest::Method::Post);
}
ListExecutionsRequest::~ListExecutionsRequest()
{}
std::string ListExecutionsRequest::getExecutedBy()const
{
return executedBy_;
}
void ListExecutionsRequest::setExecutedBy(const std::string& executedBy)
{
executedBy_ = executedBy;
setParameter("ExecutedBy", executedBy);
}
bool ListExecutionsRequest::getIncludeChildExecution()const
{
return includeChildExecution_;
}
void ListExecutionsRequest::setIncludeChildExecution(bool includeChildExecution)
{
includeChildExecution_ = includeChildExecution;
setParameter("IncludeChildExecution", includeChildExecution ? "true" : "false");
}
std::string ListExecutionsRequest::getMode()const
{
return mode_;
}
void ListExecutionsRequest::setMode(const std::string& mode)
{
mode_ = mode;
setParameter("Mode", mode);
}
std::string ListExecutionsRequest::getExecutionId()const
{
return executionId_;
}
void ListExecutionsRequest::setExecutionId(const std::string& executionId)
{
executionId_ = executionId;
setParameter("ExecutionId", executionId);
}
std::string ListExecutionsRequest::getRegionId()const
{
return regionId_;
}
void ListExecutionsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ListExecutionsRequest::getRamRole()const
{
return ramRole_;
}
void ListExecutionsRequest::setRamRole(const std::string& ramRole)
{
ramRole_ = ramRole;
setParameter("RamRole", ramRole);
}
std::string ListExecutionsRequest::getNextToken()const
{
return nextToken_;
}
void ListExecutionsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
std::string ListExecutionsRequest::getTemplateName()const
{
return templateName_;
}
void ListExecutionsRequest::setTemplateName(const std::string& templateName)
{
templateName_ = templateName;
setParameter("TemplateName", templateName);
}
std::string ListExecutionsRequest::getEndDateBefore()const
{
return endDateBefore_;
}
void ListExecutionsRequest::setEndDateBefore(const std::string& endDateBefore)
{
endDateBefore_ = endDateBefore;
setParameter("EndDateBefore", endDateBefore);
}
std::string ListExecutionsRequest::getSortOrder()const
{
return sortOrder_;
}
void ListExecutionsRequest::setSortOrder(const std::string& sortOrder)
{
sortOrder_ = sortOrder;
setParameter("SortOrder", sortOrder);
}
std::string ListExecutionsRequest::getStartDateAfter()const
{
return startDateAfter_;
}
void ListExecutionsRequest::setStartDateAfter(const std::string& startDateAfter)
{
startDateAfter_ = startDateAfter;
setParameter("StartDateAfter", startDateAfter);
}
std::string ListExecutionsRequest::getStartDateBefore()const
{
return startDateBefore_;
}
void ListExecutionsRequest::setStartDateBefore(const std::string& startDateBefore)
{
startDateBefore_ = startDateBefore;
setParameter("StartDateBefore", startDateBefore);
}
std::map<std::string, std::string> ListExecutionsRequest::getTags()const
{
return tags_;
}
void ListExecutionsRequest::setTags(const std::map<std::string, std::string>& tags)
{
tags_ = tags;
setJsonParameters("Tags", tags);
}
std::string ListExecutionsRequest::getParentExecutionId()const
{
return parentExecutionId_;
}
void ListExecutionsRequest::setParentExecutionId(const std::string& parentExecutionId)
{
parentExecutionId_ = parentExecutionId;
setParameter("ParentExecutionId", parentExecutionId);
}
std::string ListExecutionsRequest::getEndDateAfter()const
{
return endDateAfter_;
}
void ListExecutionsRequest::setEndDateAfter(const std::string& endDateAfter)
{
endDateAfter_ = endDateAfter;
setParameter("EndDateAfter", endDateAfter);
}
int ListExecutionsRequest::getMaxResults()const
{
return maxResults_;
}
void ListExecutionsRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}
std::string ListExecutionsRequest::getSortField()const
{
return sortField_;
}
void ListExecutionsRequest::setSortField(const std::string& sortField)
{
sortField_ = sortField;
setParameter("SortField", sortField);
}
std::string ListExecutionsRequest::getCategory()const
{
return category_;
}
void ListExecutionsRequest::setCategory(const std::string& category)
{
category_ = category;
setParameter("Category", category);
}
std::string ListExecutionsRequest::getStatus()const
{
return status_;
}
void ListExecutionsRequest::setStatus(const std::string& status)
{
status_ = status;
setParameter("Status", status);
}

129
oos/src/model/ListExecutionsResult.cc Normal file
View File

@@ -0,0 +1,129 @@
/*
* 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/oos/model/ListExecutionsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
ListExecutionsResult::ListExecutionsResult() :
ServiceResult()
{}
ListExecutionsResult::ListExecutionsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListExecutionsResult::~ListExecutionsResult()
{}
void ListExecutionsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allExecutionsNode = value["Executions"]["Execution"];
for (auto valueExecutionsExecution : allExecutionsNode)
{
Execution executionsObject;
if(!valueExecutionsExecution["ExecutionId"].isNull())
executionsObject.executionId = valueExecutionsExecution["ExecutionId"].asString();
if(!valueExecutionsExecution["TemplateName"].isNull())
executionsObject.templateName = valueExecutionsExecution["TemplateName"].asString();
if(!valueExecutionsExecution["TemplateId"].isNull())
executionsObject.templateId = valueExecutionsExecution["TemplateId"].asString();
if(!valueExecutionsExecution["TemplateVersion"].isNull())
executionsObject.templateVersion = valueExecutionsExecution["TemplateVersion"].asString();
if(!valueExecutionsExecution["Mode"].isNull())
executionsObject.mode = valueExecutionsExecution["Mode"].asString();
if(!valueExecutionsExecution["ExecutedBy"].isNull())
executionsObject.executedBy = valueExecutionsExecution["ExecutedBy"].asString();
if(!valueExecutionsExecution["StartDate"].isNull())
executionsObject.startDate = valueExecutionsExecution["StartDate"].asString();
if(!valueExecutionsExecution["EndDate"].isNull())
executionsObject.endDate = valueExecutionsExecution["EndDate"].asString();
if(!valueExecutionsExecution["CreateDate"].isNull())
executionsObject.createDate = valueExecutionsExecution["CreateDate"].asString();
if(!valueExecutionsExecution["UpdateDate"].isNull())
executionsObject.updateDate = valueExecutionsExecution["UpdateDate"].asString();
if(!valueExecutionsExecution["Status"].isNull())
executionsObject.status = valueExecutionsExecution["Status"].asString();
if(!valueExecutionsExecution["StatusMessage"].isNull())
executionsObject.statusMessage = valueExecutionsExecution["StatusMessage"].asString();
if(!valueExecutionsExecution["StatusReason"].isNull())
executionsObject.statusReason = valueExecutionsExecution["StatusReason"].asString();
if(!valueExecutionsExecution["WaitingStatus"].isNull())
executionsObject.waitingStatus = valueExecutionsExecution["WaitingStatus"].asString();
if(!valueExecutionsExecution["ParentExecutionId"].isNull())
executionsObject.parentExecutionId = valueExecutionsExecution["ParentExecutionId"].asString();
if(!valueExecutionsExecution["Parameters"].isNull())
executionsObject.parameters = valueExecutionsExecution["Parameters"].asString();
if(!valueExecutionsExecution["Outputs"].isNull())
executionsObject.outputs = valueExecutionsExecution["Outputs"].asString();
if(!valueExecutionsExecution["SafetyCheck"].isNull())
executionsObject.safetyCheck = valueExecutionsExecution["SafetyCheck"].asString();
if(!valueExecutionsExecution["IsParent"].isNull())
executionsObject.isParent = valueExecutionsExecution["IsParent"].asString() == "true";
if(!valueExecutionsExecution["RamRole"].isNull())
executionsObject.ramRole = valueExecutionsExecution["RamRole"].asString();
if(!valueExecutionsExecution["Counters"].isNull())
executionsObject.counters = valueExecutionsExecution["Counters"].asString();
if(!valueExecutionsExecution["Category"].isNull())
executionsObject.category = valueExecutionsExecution["Category"].asString();
if(!valueExecutionsExecution["Tags"].isNull())
executionsObject.tags = valueExecutionsExecution["Tags"].asString();
if(!valueExecutionsExecution["Description"].isNull())
executionsObject.description = valueExecutionsExecution["Description"].asString();
auto allCurrentTasksNode = allExecutionsNode["CurrentTasks"]["CurrentTask"];
for (auto allExecutionsNodeCurrentTasksCurrentTask : allCurrentTasksNode)
{
Execution::CurrentTask currentTasksObject;
if(!allExecutionsNodeCurrentTasksCurrentTask["TaskExecutionId"].isNull())
currentTasksObject.taskExecutionId = allExecutionsNodeCurrentTasksCurrentTask["TaskExecutionId"].asString();
if(!allExecutionsNodeCurrentTasksCurrentTask["TaskName"].isNull())
currentTasksObject.taskName = allExecutionsNodeCurrentTasksCurrentTask["TaskName"].asString();
if(!allExecutionsNodeCurrentTasksCurrentTask["TaskAction"].isNull())
currentTasksObject.taskAction = allExecutionsNodeCurrentTasksCurrentTask["TaskAction"].asString();
executionsObject.currentTasks.push_back(currentTasksObject);
}
executions_.push_back(executionsObject);
}
if(!value["MaxResults"].isNull())
maxResults_ = std::stoi(value["MaxResults"].asString());
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::vector<ListExecutionsResult::Execution> ListExecutionsResult::getExecutions()const
{
return executions_;
}
std::string ListExecutionsResult::getNextToken()const
{
return nextToken_;
}
int ListExecutionsResult::getMaxResults()const
{
return maxResults_;
}

73
oos/src/model/ListTagKeysRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oos/model/ListTagKeysRequest.h>
using AlibabaCloud::Oos::Model::ListTagKeysRequest;
ListTagKeysRequest::ListTagKeysRequest() :
RpcServiceRequest("oos", "2019-06-01", "ListTagKeys")
{
setMethod(HttpRequest::Method::Post);
}
ListTagKeysRequest::~ListTagKeysRequest()
{}
std::string ListTagKeysRequest::getResourceType()const
{
return resourceType_;
}
void ListTagKeysRequest::setResourceType(const std::string& resourceType)
{
resourceType_ = resourceType;
setParameter("ResourceType", resourceType);
}
std::string ListTagKeysRequest::getRegionId()const
{
return regionId_;
}
void ListTagKeysRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ListTagKeysRequest::getNextToken()const
{
return nextToken_;
}
void ListTagKeysRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
int ListTagKeysRequest::getMaxResults()const
{
return maxResults_;
}
void ListTagKeysRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}

66
oos/src/model/ListTagKeysResult.cc Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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/oos/model/ListTagKeysResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
ListTagKeysResult::ListTagKeysResult() :
ServiceResult()
{}
ListTagKeysResult::ListTagKeysResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListTagKeysResult::~ListTagKeysResult()
{}
void ListTagKeysResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allKeys = value["Keys"]["Key"];
for (const auto &item : allKeys)
keys_.push_back(item.asString());
if(!value["MaxResults"].isNull())
maxResults_ = std::stoi(value["MaxResults"].asString());
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::string ListTagKeysResult::getNextToken()const
{
return nextToken_;
}
std::vector<std::string> ListTagKeysResult::getKeys()const
{
return keys_;
}
int ListTagKeysResult::getMaxResults()const
{
return maxResults_;
}

84
oos/src/model/ListTagResourcesRequest.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* 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/oos/model/ListTagResourcesRequest.h>
using AlibabaCloud::Oos::Model::ListTagResourcesRequest;
ListTagResourcesRequest::ListTagResourcesRequest() :
RpcServiceRequest("oos", "2019-06-01", "ListTagResources")
{
setMethod(HttpRequest::Method::Post);
}
ListTagResourcesRequest::~ListTagResourcesRequest()
{}
std::string ListTagResourcesRequest::getResourceType()const
{
return resourceType_;
}
void ListTagResourcesRequest::setResourceType(const std::string& resourceType)
{
resourceType_ = resourceType;
setParameter("ResourceType", resourceType);
}
std::map<std::string, std::string> ListTagResourcesRequest::getTags()const
{
return tags_;
}
void ListTagResourcesRequest::setTags(const std::map<std::string, std::string>& tags)
{
tags_ = tags;
setJsonParameters("Tags", tags);
}
std::string ListTagResourcesRequest::getRegionId()const
{
return regionId_;
}
void ListTagResourcesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ListTagResourcesRequest::getNextToken()const
{
return nextToken_;
}
void ListTagResourcesRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
std::map<std::string, std::string> ListTagResourcesRequest::getResourceIds()const
{
return resourceIds_;
}
void ListTagResourcesRequest::setResourceIds(const std::map<std::string, std::string>& resourceIds)
{
resourceIds_ = resourceIds;
setJsonParameters("ResourceIds", resourceIds);
}

70
oos/src/model/ListTagResourcesResult.cc Normal file
View File

@@ -0,0 +1,70 @@
/*
* 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/oos/model/ListTagResourcesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
ListTagResourcesResult::ListTagResourcesResult() :
ServiceResult()
{}
ListTagResourcesResult::ListTagResourcesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListTagResourcesResult::~ListTagResourcesResult()
{}
void ListTagResourcesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allTagResourcesNode = value["TagResources"]["TagResource"];
for (auto valueTagResourcesTagResource : allTagResourcesNode)
{
TagResource tagResourcesObject;
if(!valueTagResourcesTagResource["TagKey"].isNull())
tagResourcesObject.tagKey = valueTagResourcesTagResource["TagKey"].asString();
if(!valueTagResourcesTagResource["TagValue"].isNull())
tagResourcesObject.tagValue = valueTagResourcesTagResource["TagValue"].asString();
if(!valueTagResourcesTagResource["ResourceId"].isNull())
tagResourcesObject.resourceId = valueTagResourcesTagResource["ResourceId"].asString();
if(!valueTagResourcesTagResource["ResourceType"].isNull())
tagResourcesObject.resourceType = valueTagResourcesTagResource["ResourceType"].asString();
tagResources_.push_back(tagResourcesObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::string ListTagResourcesResult::getNextToken()const
{
return nextToken_;
}
std::vector<ListTagResourcesResult::TagResource> ListTagResourcesResult::getTagResources()const
{
return tagResources_;
}

84
oos/src/model/ListTagValuesRequest.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* 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/oos/model/ListTagValuesRequest.h>
using AlibabaCloud::Oos::Model::ListTagValuesRequest;
ListTagValuesRequest::ListTagValuesRequest() :
RpcServiceRequest("oos", "2019-06-01", "ListTagValues")
{
setMethod(HttpRequest::Method::Post);
}
ListTagValuesRequest::~ListTagValuesRequest()
{}
std::string ListTagValuesRequest::getResourceType()const
{
return resourceType_;
}
void ListTagValuesRequest::setResourceType(const std::string& resourceType)
{
resourceType_ = resourceType;
setParameter("ResourceType", resourceType);
}
std::string ListTagValuesRequest::getRegionId()const
{
return regionId_;
}
void ListTagValuesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ListTagValuesRequest::getNextToken()const
{
return nextToken_;
}
void ListTagValuesRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
int ListTagValuesRequest::getMaxResults()const
{
return maxResults_;
}
void ListTagValuesRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}
std::string ListTagValuesRequest::getKey()const
{
return key_;
}
void ListTagValuesRequest::setKey(const std::string& key)
{
key_ = key;
setParameter("Key", key);
}

66
oos/src/model/ListTagValuesResult.cc Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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/oos/model/ListTagValuesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
ListTagValuesResult::ListTagValuesResult() :
ServiceResult()
{}
ListTagValuesResult::ListTagValuesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListTagValuesResult::~ListTagValuesResult()
{}
void ListTagValuesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allValues = value["Values"]["Value"];
for (const auto &item : allValues)
values_.push_back(item.asString());
if(!value["MaxResults"].isNull())
maxResults_ = std::stoi(value["MaxResults"].asString());
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::string ListTagValuesResult::getNextToken()const
{
return nextToken_;
}
int ListTagValuesResult::getMaxResults()const
{
return maxResults_;
}
std::vector<std::string> ListTagValuesResult::getValues()const
{
return values_;
}

205
oos/src/model/ListTaskExecutionsRequest.cc Normal file
View File

@@ -0,0 +1,205 @@
/*
* 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/oos/model/ListTaskExecutionsRequest.h>
using AlibabaCloud::Oos::Model::ListTaskExecutionsRequest;
ListTaskExecutionsRequest::ListTaskExecutionsRequest() :
RpcServiceRequest("oos", "2019-06-01", "ListTaskExecutions")
{
setMethod(HttpRequest::Method::Post);
}
ListTaskExecutionsRequest::~ListTaskExecutionsRequest()
{}
std::string ListTaskExecutionsRequest::getTaskName()const
{
return taskName_;
}
void ListTaskExecutionsRequest::setTaskName(const std::string& taskName)
{
taskName_ = taskName;
setParameter("TaskName", taskName);
}
bool ListTaskExecutionsRequest::getIncludeChildTaskExecution()const
{
return includeChildTaskExecution_;
}
void ListTaskExecutionsRequest::setIncludeChildTaskExecution(bool includeChildTaskExecution)
{
includeChildTaskExecution_ = includeChildTaskExecution;
setParameter("IncludeChildTaskExecution", includeChildTaskExecution ? "true" : "false");
}
std::string ListTaskExecutionsRequest::getExecutionId()const
{
return executionId_;
}
void ListTaskExecutionsRequest::setExecutionId(const std::string& executionId)
{
executionId_ = executionId;
setParameter("ExecutionId", executionId);
}
std::string ListTaskExecutionsRequest::getParentTaskExecutionId()const
{
return parentTaskExecutionId_;
}
void ListTaskExecutionsRequest::setParentTaskExecutionId(const std::string& parentTaskExecutionId)
{
parentTaskExecutionId_ = parentTaskExecutionId;
setParameter("ParentTaskExecutionId", parentTaskExecutionId);
}
std::string ListTaskExecutionsRequest::getRegionId()const
{
return regionId_;
}
void ListTaskExecutionsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ListTaskExecutionsRequest::getNextToken()const
{
return nextToken_;
}
void ListTaskExecutionsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
std::string ListTaskExecutionsRequest::getEndDateBefore()const
{
return endDateBefore_;
}
void ListTaskExecutionsRequest::setEndDateBefore(const std::string& endDateBefore)
{
endDateBefore_ = endDateBefore;
setParameter("EndDateBefore", endDateBefore);
}
std::string ListTaskExecutionsRequest::getSortOrder()const
{
return sortOrder_;
}
void ListTaskExecutionsRequest::setSortOrder(const std::string& sortOrder)
{
sortOrder_ = sortOrder;
setParameter("SortOrder", sortOrder);
}
std::string ListTaskExecutionsRequest::getStartDateAfter()const
{
return startDateAfter_;
}
void ListTaskExecutionsRequest::setStartDateAfter(const std::string& startDateAfter)
{
startDateAfter_ = startDateAfter;
setParameter("StartDateAfter", startDateAfter);
}
std::string ListTaskExecutionsRequest::getStartDateBefore()const
{
return startDateBefore_;
}
void ListTaskExecutionsRequest::setStartDateBefore(const std::string& startDateBefore)
{
startDateBefore_ = startDateBefore;
setParameter("StartDateBefore", startDateBefore);
}
std::string ListTaskExecutionsRequest::getEndDateAfter()const
{
return endDateAfter_;
}
void ListTaskExecutionsRequest::setEndDateAfter(const std::string& endDateAfter)
{
endDateAfter_ = endDateAfter;
setParameter("EndDateAfter", endDateAfter);
}
int ListTaskExecutionsRequest::getMaxResults()const
{
return maxResults_;
}
void ListTaskExecutionsRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}
std::string ListTaskExecutionsRequest::getTaskExecutionId()const
{
return taskExecutionId_;
}
void ListTaskExecutionsRequest::setTaskExecutionId(const std::string& taskExecutionId)
{
taskExecutionId_ = taskExecutionId;
setParameter("TaskExecutionId", taskExecutionId);
}
std::string ListTaskExecutionsRequest::getSortField()const
{
return sortField_;
}
void ListTaskExecutionsRequest::setSortField(const std::string& sortField)
{
sortField_ = sortField;
setParameter("SortField", sortField);
}
std::string ListTaskExecutionsRequest::getTaskAction()const
{
return taskAction_;
}
void ListTaskExecutionsRequest::setTaskAction(const std::string& taskAction)
{
taskAction_ = taskAction;
setParameter("TaskAction", taskAction);
}
std::string ListTaskExecutionsRequest::getStatus()const
{
return status_;
}
void ListTaskExecutionsRequest::setStatus(const std::string& status)
{
status_ = status;
setParameter("Status", status);
}

107
oos/src/model/ListTaskExecutionsResult.cc Normal file
View File

@@ -0,0 +1,107 @@
/*
* 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/oos/model/ListTaskExecutionsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
ListTaskExecutionsResult::ListTaskExecutionsResult() :
ServiceResult()
{}
ListTaskExecutionsResult::ListTaskExecutionsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListTaskExecutionsResult::~ListTaskExecutionsResult()
{}
void ListTaskExecutionsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allTaskExecutionsNode = value["TaskExecutions"]["TaskExecution"];
for (auto valueTaskExecutionsTaskExecution : allTaskExecutionsNode)
{
TaskExecution taskExecutionsObject;
if(!valueTaskExecutionsTaskExecution["ExecutionId"].isNull())
taskExecutionsObject.executionId = valueTaskExecutionsTaskExecution["ExecutionId"].asString();
if(!valueTaskExecutionsTaskExecution["TaskExecutionId"].isNull())
taskExecutionsObject.taskExecutionId = valueTaskExecutionsTaskExecution["TaskExecutionId"].asString();
if(!valueTaskExecutionsTaskExecution["TemplateId"].isNull())
taskExecutionsObject.templateId = valueTaskExecutionsTaskExecution["TemplateId"].asString();
if(!valueTaskExecutionsTaskExecution["StartDate"].isNull())
taskExecutionsObject.startDate = valueTaskExecutionsTaskExecution["StartDate"].asString();
if(!valueTaskExecutionsTaskExecution["EndDate"].isNull())
taskExecutionsObject.endDate = valueTaskExecutionsTaskExecution["EndDate"].asString();
if(!valueTaskExecutionsTaskExecution["CreateDate"].isNull())
taskExecutionsObject.createDate = valueTaskExecutionsTaskExecution["CreateDate"].asString();
if(!valueTaskExecutionsTaskExecution["UpdateDate"].isNull())
taskExecutionsObject.updateDate = valueTaskExecutionsTaskExecution["UpdateDate"].asString();
if(!valueTaskExecutionsTaskExecution["Status"].isNull())
taskExecutionsObject.status = valueTaskExecutionsTaskExecution["Status"].asString();
if(!valueTaskExecutionsTaskExecution["Properties"].isNull())
taskExecutionsObject.properties = valueTaskExecutionsTaskExecution["Properties"].asString();
if(!valueTaskExecutionsTaskExecution["Outputs"].isNull())
taskExecutionsObject.outputs = valueTaskExecutionsTaskExecution["Outputs"].asString();
if(!valueTaskExecutionsTaskExecution["TaskAction"].isNull())
taskExecutionsObject.taskAction = valueTaskExecutionsTaskExecution["TaskAction"].asString();
if(!valueTaskExecutionsTaskExecution["TaskName"].isNull())
taskExecutionsObject.taskName = valueTaskExecutionsTaskExecution["TaskName"].asString();
if(!valueTaskExecutionsTaskExecution["StatusMessage"].isNull())
taskExecutionsObject.statusMessage = valueTaskExecutionsTaskExecution["StatusMessage"].asString();
if(!valueTaskExecutionsTaskExecution["ChildExecutionId"].isNull())
taskExecutionsObject.childExecutionId = valueTaskExecutionsTaskExecution["ChildExecutionId"].asString();
if(!valueTaskExecutionsTaskExecution["ParentTaskExecutionId"].isNull())
taskExecutionsObject.parentTaskExecutionId = valueTaskExecutionsTaskExecution["ParentTaskExecutionId"].asString();
if(!valueTaskExecutionsTaskExecution["LoopItem"].isNull())
taskExecutionsObject.loopItem = valueTaskExecutionsTaskExecution["LoopItem"].asString();
if(!valueTaskExecutionsTaskExecution["Loop"].isNull())
taskExecutionsObject.loop = valueTaskExecutionsTaskExecution["Loop"].asString();
if(!valueTaskExecutionsTaskExecution["ExtraData"].isNull())
taskExecutionsObject.extraData = valueTaskExecutionsTaskExecution["ExtraData"].asString();
if(!valueTaskExecutionsTaskExecution["LoopBatchNumber"].isNull())
taskExecutionsObject.loopBatchNumber = std::stoi(valueTaskExecutionsTaskExecution["LoopBatchNumber"].asString());
taskExecutions_.push_back(taskExecutionsObject);
}
if(!value["MaxResults"].isNull())
maxResults_ = std::stoi(value["MaxResults"].asString());
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::string ListTaskExecutionsResult::getNextToken()const
{
return nextToken_;
}
int ListTaskExecutionsResult::getMaxResults()const
{
return maxResults_;
}
std::vector<ListTaskExecutionsResult::TaskExecution> ListTaskExecutionsResult::getTaskExecutions()const
{
return taskExecutions_;
}

183
oos/src/model/ListTemplatesRequest.cc Normal file
View File

@@ -0,0 +1,183 @@
/*
* 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/oos/model/ListTemplatesRequest.h>
using AlibabaCloud::Oos::Model::ListTemplatesRequest;
ListTemplatesRequest::ListTemplatesRequest() :
RpcServiceRequest("oos", "2019-06-01", "ListTemplates")
{
setMethod(HttpRequest::Method::Post);
}
ListTemplatesRequest::~ListTemplatesRequest()
{}
std::string ListTemplatesRequest::getCreatedDateBefore()const
{
return createdDateBefore_;
}
void ListTemplatesRequest::setCreatedDateBefore(const std::string& createdDateBefore)
{
createdDateBefore_ = createdDateBefore;
setParameter("CreatedDateBefore", createdDateBefore);
}
std::string ListTemplatesRequest::getRegionId()const
{
return regionId_;
}
void ListTemplatesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ListTemplatesRequest::getCreatedBy()const
{
return createdBy_;
}
void ListTemplatesRequest::setCreatedBy(const std::string& createdBy)
{
createdBy_ = createdBy;
setParameter("CreatedBy", createdBy);
}
std::string ListTemplatesRequest::getNextToken()const
{
return nextToken_;
}
void ListTemplatesRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
std::string ListTemplatesRequest::getTemplateName()const
{
return templateName_;
}
void ListTemplatesRequest::setTemplateName(const std::string& templateName)
{
templateName_ = templateName;
setParameter("TemplateName", templateName);
}
std::string ListTemplatesRequest::getSortOrder()const
{
return sortOrder_;
}
void ListTemplatesRequest::setSortOrder(const std::string& sortOrder)
{
sortOrder_ = sortOrder;
setParameter("SortOrder", sortOrder);
}
std::string ListTemplatesRequest::getShareType()const
{
return shareType_;
}
void ListTemplatesRequest::setShareType(const std::string& shareType)
{
shareType_ = shareType;
setParameter("ShareType", shareType);
}
bool ListTemplatesRequest::getHasTrigger()const
{
return hasTrigger_;
}
void ListTemplatesRequest::setHasTrigger(bool hasTrigger)
{
hasTrigger_ = hasTrigger;
setParameter("HasTrigger", hasTrigger ? "true" : "false");
}
std::string ListTemplatesRequest::getCreatedDateAfter()const
{
return createdDateAfter_;
}
void ListTemplatesRequest::setCreatedDateAfter(const std::string& createdDateAfter)
{
createdDateAfter_ = createdDateAfter;
setParameter("CreatedDateAfter", createdDateAfter);
}
std::map<std::string, std::string> ListTemplatesRequest::getTags()const
{
return tags_;
}
void ListTemplatesRequest::setTags(const std::map<std::string, std::string>& tags)
{
tags_ = tags;
setJsonParameters("Tags", tags);
}
int ListTemplatesRequest::getMaxResults()const
{
return maxResults_;
}
void ListTemplatesRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}
std::string ListTemplatesRequest::getTemplateFormat()const
{
return templateFormat_;
}
void ListTemplatesRequest::setTemplateFormat(const std::string& templateFormat)
{
templateFormat_ = templateFormat;
setParameter("TemplateFormat", templateFormat);
}
std::string ListTemplatesRequest::getSortField()const
{
return sortField_;
}
void ListTemplatesRequest::setSortField(const std::string& sortField)
{
sortField_ = sortField;
setParameter("SortField", sortField);
}
std::string ListTemplatesRequest::getCategory()const
{
return category_;
}
void ListTemplatesRequest::setCategory(const std::string& category)
{
category_ = category;
setParameter("Category", category);
}

101
oos/src/model/ListTemplatesResult.cc Normal file
View File

@@ -0,0 +1,101 @@
/*
* 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/oos/model/ListTemplatesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
ListTemplatesResult::ListTemplatesResult() :
ServiceResult()
{}
ListTemplatesResult::ListTemplatesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListTemplatesResult::~ListTemplatesResult()
{}
void ListTemplatesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allTemplatesNode = value["Templates"]["Template"];
for (auto valueTemplatesTemplate : allTemplatesNode)
{
_Template templatesObject;
if(!valueTemplatesTemplate["TemplateName"].isNull())
templatesObject.templateName = valueTemplatesTemplate["TemplateName"].asString();
if(!valueTemplatesTemplate["TemplateId"].isNull())
templatesObject.templateId = valueTemplatesTemplate["TemplateId"].asString();
if(!valueTemplatesTemplate["CreatedDate"].isNull())
templatesObject.createdDate = valueTemplatesTemplate["CreatedDate"].asString();
if(!valueTemplatesTemplate["CreatedBy"].isNull())
templatesObject.createdBy = valueTemplatesTemplate["CreatedBy"].asString();
if(!valueTemplatesTemplate["UpdatedDate"].isNull())
templatesObject.updatedDate = valueTemplatesTemplate["UpdatedDate"].asString();
if(!valueTemplatesTemplate["UpdatedBy"].isNull())
templatesObject.updatedBy = valueTemplatesTemplate["UpdatedBy"].asString();
if(!valueTemplatesTemplate["Hash"].isNull())
templatesObject.hash = valueTemplatesTemplate["Hash"].asString();
if(!valueTemplatesTemplate["Description"].isNull())
templatesObject.description = valueTemplatesTemplate["Description"].asString();
if(!valueTemplatesTemplate["ShareType"].isNull())
templatesObject.shareType = valueTemplatesTemplate["ShareType"].asString();
if(!valueTemplatesTemplate["TemplateFormat"].isNull())
templatesObject.templateFormat = valueTemplatesTemplate["TemplateFormat"].asString();
if(!valueTemplatesTemplate["TemplateVersion"].isNull())
templatesObject.templateVersion = valueTemplatesTemplate["TemplateVersion"].asString();
if(!valueTemplatesTemplate["HasTrigger"].isNull())
templatesObject.hasTrigger = valueTemplatesTemplate["HasTrigger"].asString() == "true";
if(!valueTemplatesTemplate["TotalExecutionCount"].isNull())
templatesObject.totalExecutionCount = std::stoi(valueTemplatesTemplate["TotalExecutionCount"].asString());
if(!valueTemplatesTemplate["Popularity"].isNull())
templatesObject.popularity = std::stoi(valueTemplatesTemplate["Popularity"].asString());
if(!valueTemplatesTemplate["Tags"].isNull())
templatesObject.tags = valueTemplatesTemplate["Tags"].asString();
if(!valueTemplatesTemplate["Category"].isNull())
templatesObject.category = valueTemplatesTemplate["Category"].asString();
templates_.push_back(templatesObject);
}
if(!value["MaxResults"].isNull())
maxResults_ = std::stoi(value["MaxResults"].asString());
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::string ListTemplatesResult::getNextToken()const
{
return nextToken_;
}
int ListTemplatesResult::getMaxResults()const
{
return maxResults_;
}
std::vector<ListTemplatesResult::_Template> ListTemplatesResult::getTemplates()const
{
return templates_;
}

139
oos/src/model/NotifyExecutionRequest.cc Normal file
View File

@@ -0,0 +1,139 @@
/*
* 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/oos/model/NotifyExecutionRequest.h>
using AlibabaCloud::Oos::Model::NotifyExecutionRequest;
NotifyExecutionRequest::NotifyExecutionRequest() :
RpcServiceRequest("oos", "2019-06-01", "NotifyExecution")
{
setMethod(HttpRequest::Method::Post);
}
NotifyExecutionRequest::~NotifyExecutionRequest()
{}
std::string NotifyExecutionRequest::getTaskName()const
{
return taskName_;
}
void NotifyExecutionRequest::setTaskName(const std::string& taskName)
{
taskName_ = taskName;
setParameter("TaskName", taskName);
}
std::string NotifyExecutionRequest::getExecutionId()const
{
return executionId_;
}
void NotifyExecutionRequest::setExecutionId(const std::string& executionId)
{
executionId_ = executionId;
setParameter("ExecutionId", executionId);
}
std::string NotifyExecutionRequest::getRegionId()const
{
return regionId_;
}
void NotifyExecutionRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string NotifyExecutionRequest::getNotifyType()const
{
return notifyType_;
}
void NotifyExecutionRequest::setNotifyType(const std::string& notifyType)
{
notifyType_ = notifyType;
setParameter("NotifyType", notifyType);
}
std::string NotifyExecutionRequest::getExecutionStatus()const
{
return executionStatus_;
}
void NotifyExecutionRequest::setExecutionStatus(const std::string& executionStatus)
{
executionStatus_ = executionStatus;
setParameter("ExecutionStatus", executionStatus);
}
std::string NotifyExecutionRequest::getNotifyNote()const
{
return notifyNote_;
}
void NotifyExecutionRequest::setNotifyNote(const std::string& notifyNote)
{
notifyNote_ = notifyNote;
setParameter("NotifyNote", notifyNote);
}
std::string NotifyExecutionRequest::getLoopItem()const
{
return loopItem_;
}
void NotifyExecutionRequest::setLoopItem(const std::string& loopItem)
{
loopItem_ = loopItem;
setParameter("LoopItem", loopItem);
}
std::string NotifyExecutionRequest::getTaskExecutionIds()const
{
return taskExecutionIds_;
}
void NotifyExecutionRequest::setTaskExecutionIds(const std::string& taskExecutionIds)
{
taskExecutionIds_ = taskExecutionIds;
setParameter("TaskExecutionIds", taskExecutionIds);
}
std::string NotifyExecutionRequest::getTaskExecutionId()const
{
return taskExecutionId_;
}
void NotifyExecutionRequest::setTaskExecutionId(const std::string& taskExecutionId)
{
taskExecutionId_ = taskExecutionId;
setParameter("TaskExecutionId", taskExecutionId);
}
std::string NotifyExecutionRequest::getParameters()const
{
return parameters_;
}
void NotifyExecutionRequest::setParameters(const std::string& parameters)
{
parameters_ = parameters;
setParameter("Parameters", parameters);
}

44
oos/src/model/NotifyExecutionResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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/oos/model/NotifyExecutionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
NotifyExecutionResult::NotifyExecutionResult() :
ServiceResult()
{}
NotifyExecutionResult::NotifyExecutionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
NotifyExecutionResult::~NotifyExecutionResult()
{}
void NotifyExecutionResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

150
oos/src/model/StartExecutionRequest.cc Normal file
View File

@@ -0,0 +1,150 @@
/*
* 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/oos/model/StartExecutionRequest.h>
using AlibabaCloud::Oos::Model::StartExecutionRequest;
StartExecutionRequest::StartExecutionRequest() :
RpcServiceRequest("oos", "2019-06-01", "StartExecution")
{
setMethod(HttpRequest::Method::Post);
}
StartExecutionRequest::~StartExecutionRequest()
{}
std::string StartExecutionRequest::getClientToken()const
{
return clientToken_;
}
void StartExecutionRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string StartExecutionRequest::getDescription()const
{
return description_;
}
void StartExecutionRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
std::string StartExecutionRequest::getMode()const
{
return mode_;
}
void StartExecutionRequest::setMode(const std::string& mode)
{
mode_ = mode;
setParameter("Mode", mode);
}
std::string StartExecutionRequest::getTemplateVersion()const
{
return templateVersion_;
}
void StartExecutionRequest::setTemplateVersion(const std::string& templateVersion)
{
templateVersion_ = templateVersion;
setParameter("TemplateVersion", templateVersion);
}
std::string StartExecutionRequest::getRegionId()const
{
return regionId_;
}
void StartExecutionRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string StartExecutionRequest::getTemplateName()const
{
return templateName_;
}
void StartExecutionRequest::setTemplateName(const std::string& templateName)
{
templateName_ = templateName;
setParameter("TemplateName", templateName);
}
std::string StartExecutionRequest::getLoopMode()const
{
return loopMode_;
}
void StartExecutionRequest::setLoopMode(const std::string& loopMode)
{
loopMode_ = loopMode;
setParameter("LoopMode", loopMode);
}
std::string StartExecutionRequest::getSafetyCheck()const
{
return safetyCheck_;
}
void StartExecutionRequest::setSafetyCheck(const std::string& safetyCheck)
{
safetyCheck_ = safetyCheck;
setParameter("SafetyCheck", safetyCheck);
}
std::map<std::string, std::string> StartExecutionRequest::getTags()const
{
return tags_;
}
void StartExecutionRequest::setTags(const std::map<std::string, std::string>& tags)
{
tags_ = tags;
setJsonParameters("Tags", tags);
}
std::string StartExecutionRequest::getParentExecutionId()const
{
return parentExecutionId_;
}
void StartExecutionRequest::setParentExecutionId(const std::string& parentExecutionId)
{
parentExecutionId_ = parentExecutionId;
setParameter("ParentExecutionId", parentExecutionId);
}
std::string StartExecutionRequest::getParameters()const
{
return parameters_;
}
void StartExecutionRequest::setParameters(const std::string& parameters)
{
parameters_ = parameters;
setParameter("Parameters", parameters);
}

106
oos/src/model/StartExecutionResult.cc Normal file
View File

@@ -0,0 +1,106 @@
/*
* 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/oos/model/StartExecutionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
StartExecutionResult::StartExecutionResult() :
ServiceResult()
{}
StartExecutionResult::StartExecutionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
StartExecutionResult::~StartExecutionResult()
{}
void StartExecutionResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto executionNode = value["Execution"];
if(!executionNode["ExecutionId"].isNull())
execution_.executionId = executionNode["ExecutionId"].asString();
if(!executionNode["TemplateName"].isNull())
execution_.templateName = executionNode["TemplateName"].asString();
if(!executionNode["TemplateId"].isNull())
execution_.templateId = executionNode["TemplateId"].asString();
if(!executionNode["TemplateVersion"].isNull())
execution_.templateVersion = executionNode["TemplateVersion"].asString();
if(!executionNode["Mode"].isNull())
execution_.mode = executionNode["Mode"].asString();
if(!executionNode["LoopMode"].isNull())
execution_.loopMode = executionNode["LoopMode"].asString();
if(!executionNode["ExecutedBy"].isNull())
execution_.executedBy = executionNode["ExecutedBy"].asString();
if(!executionNode["StartDate"].isNull())
execution_.startDate = executionNode["StartDate"].asString();
if(!executionNode["EndDate"].isNull())
execution_.endDate = executionNode["EndDate"].asString();
if(!executionNode["CreateDate"].isNull())
execution_.createDate = executionNode["CreateDate"].asString();
if(!executionNode["UpdateDate"].isNull())
execution_.updateDate = executionNode["UpdateDate"].asString();
if(!executionNode["Status"].isNull())
execution_.status = executionNode["Status"].asString();
if(!executionNode["StatusMessage"].isNull())
execution_.statusMessage = executionNode["StatusMessage"].asString();
if(!executionNode["ParentExecutionId"].isNull())
execution_.parentExecutionId = executionNode["ParentExecutionId"].asString();
if(!executionNode["Parameters"].isNull())
execution_.parameters = executionNode["Parameters"].asString();
if(!executionNode["Outputs"].isNull())
execution_.outputs = executionNode["Outputs"].asString();
if(!executionNode["SafetyCheck"].isNull())
execution_.safetyCheck = executionNode["SafetyCheck"].asString();
if(!executionNode["IsParent"].isNull())
execution_.isParent = executionNode["IsParent"].asString() == "true";
if(!executionNode["Counters"].isNull())
execution_.counters = executionNode["Counters"].asString();
if(!executionNode["RamRole"].isNull())
execution_.ramRole = executionNode["RamRole"].asString();
if(!executionNode["Tags"].isNull())
execution_.tags = executionNode["Tags"].asString();
if(!executionNode["Description"].isNull())
execution_.description = executionNode["Description"].asString();
auto allCurrentTasksNode = executionNode["CurrentTasks"]["CurrentTask"];
for (auto executionNodeCurrentTasksCurrentTask : allCurrentTasksNode)
{
Execution::CurrentTask currentTaskObject;
if(!executionNodeCurrentTasksCurrentTask["TaskExecutionId"].isNull())
currentTaskObject.taskExecutionId = executionNodeCurrentTasksCurrentTask["TaskExecutionId"].asString();
if(!executionNodeCurrentTasksCurrentTask["TaskName"].isNull())
currentTaskObject.taskName = executionNodeCurrentTasksCurrentTask["TaskName"].asString();
if(!executionNodeCurrentTasksCurrentTask["TaskAction"].isNull())
currentTaskObject.taskAction = executionNodeCurrentTasksCurrentTask["TaskAction"].asString();
execution_.currentTasks.push_back(currentTaskObject);
}
}
StartExecutionResult::Execution StartExecutionResult::getExecution()const
{
return execution_;
}

73
oos/src/model/TagResourcesRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oos/model/TagResourcesRequest.h>
using AlibabaCloud::Oos::Model::TagResourcesRequest;
TagResourcesRequest::TagResourcesRequest() :
RpcServiceRequest("oos", "2019-06-01", "TagResources")
{
setMethod(HttpRequest::Method::Post);
}
TagResourcesRequest::~TagResourcesRequest()
{}
std::string TagResourcesRequest::getResourceType()const
{
return resourceType_;
}
void TagResourcesRequest::setResourceType(const std::string& resourceType)
{
resourceType_ = resourceType;
setParameter("ResourceType", resourceType);
}
std::map<std::string, std::string> TagResourcesRequest::getTags()const
{
return tags_;
}
void TagResourcesRequest::setTags(const std::map<std::string, std::string>& tags)
{
tags_ = tags;
setJsonParameters("Tags", tags);
}
std::string TagResourcesRequest::getRegionId()const
{
return regionId_;
}
void TagResourcesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::map<std::string, std::string> TagResourcesRequest::getResourceIds()const
{
return resourceIds_;
}
void TagResourcesRequest::setResourceIds(const std::map<std::string, std::string>& resourceIds)
{
resourceIds_ = resourceIds;
setJsonParameters("ResourceIds", resourceIds);
}

44
oos/src/model/TagResourcesResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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/oos/model/TagResourcesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
TagResourcesResult::TagResourcesResult() :
ServiceResult()
{}
TagResourcesResult::TagResourcesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
TagResourcesResult::~TagResourcesResult()
{}
void TagResourcesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

84
oos/src/model/TriggerExecutionRequest.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* 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/oos/model/TriggerExecutionRequest.h>
using AlibabaCloud::Oos::Model::TriggerExecutionRequest;
TriggerExecutionRequest::TriggerExecutionRequest() :
RpcServiceRequest("oos", "2019-06-01", "TriggerExecution")
{
setMethod(HttpRequest::Method::Post);
}
TriggerExecutionRequest::~TriggerExecutionRequest()
{}
std::string TriggerExecutionRequest::getClientToken()const
{
return clientToken_;
}
void TriggerExecutionRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string TriggerExecutionRequest::getType()const
{
return type_;
}
void TriggerExecutionRequest::setType(const std::string& type)
{
type_ = type;
setParameter("Type", type);
}
std::string TriggerExecutionRequest::getContent()const
{
return content_;
}
void TriggerExecutionRequest::setContent(const std::string& content)
{
content_ = content;
setParameter("Content", content);
}
std::string TriggerExecutionRequest::getExecutionId()const
{
return executionId_;
}
void TriggerExecutionRequest::setExecutionId(const std::string& executionId)
{
executionId_ = executionId;
setParameter("ExecutionId", executionId);
}
std::string TriggerExecutionRequest::getRegionId()const
{
return regionId_;
}
void TriggerExecutionRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}

44
oos/src/model/TriggerExecutionResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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/oos/model/TriggerExecutionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
TriggerExecutionResult::TriggerExecutionResult() :
ServiceResult()
{}
TriggerExecutionResult::TriggerExecutionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
TriggerExecutionResult::~TriggerExecutionResult()
{}
void TriggerExecutionResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

84
oos/src/model/UntagResourcesRequest.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* 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/oos/model/UntagResourcesRequest.h>
using AlibabaCloud::Oos::Model::UntagResourcesRequest;
UntagResourcesRequest::UntagResourcesRequest() :
RpcServiceRequest("oos", "2019-06-01", "UntagResources")
{
setMethod(HttpRequest::Method::Post);
}
UntagResourcesRequest::~UntagResourcesRequest()
{}
bool UntagResourcesRequest::getAll()const
{
return all_;
}
void UntagResourcesRequest::setAll(bool all)
{
all_ = all;
setParameter("All", all ? "true" : "false");
}
std::string UntagResourcesRequest::getResourceType()const
{
return resourceType_;
}
void UntagResourcesRequest::setResourceType(const std::string& resourceType)
{
resourceType_ = resourceType;
setParameter("ResourceType", resourceType);
}
std::string UntagResourcesRequest::getRegionId()const
{
return regionId_;
}
void UntagResourcesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::map<std::string, std::string> UntagResourcesRequest::getTagKeys()const
{
return tagKeys_;
}
void UntagResourcesRequest::setTagKeys(const std::map<std::string, std::string>& tagKeys)
{
tagKeys_ = tagKeys;
setJsonParameters("TagKeys", tagKeys);
}
std::map<std::string, std::string> UntagResourcesRequest::getResourceIds()const
{
return resourceIds_;
}
void UntagResourcesRequest::setResourceIds(const std::map<std::string, std::string>& resourceIds)
{
resourceIds_ = resourceIds;
setJsonParameters("ResourceIds", resourceIds);
}

44
oos/src/model/UntagResourcesResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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/oos/model/UntagResourcesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Oos;
using namespace AlibabaCloud::Oos::Model;
UntagResourcesResult::UntagResourcesResult() :
ServiceResult()
{}
UntagResourcesResult::UntagResourcesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UntagResourcesResult::~UntagResourcesResult()
{}
void UntagResourcesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

Some files were not shown because too many files have changed in this diff Show More