diff --git a/CHANGELOG b/CHANGELOG index 763c18879..cf89a2a22 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,7 @@ +2020-05-14 Version: 1.36.412 +- Supported Grant Permission. +- Supported Revoke Permission. + 2020-05-14 Version: 1.36.411 - Add demo edition auth. diff --git a/VERSION b/VERSION index 3f739d814..86fa1951c 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.411 \ No newline at end of file +1.36.412 \ No newline at end of file diff --git a/schedulerx2/CMakeLists.txt b/schedulerx2/CMakeLists.txt new file mode 100644 index 000000000..933400443 --- /dev/null +++ b/schedulerx2/CMakeLists.txt @@ -0,0 +1,154 @@ +# +# 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(schedulerx2_public_header + include/alibabacloud/schedulerx2/Schedulerx2Client.h + include/alibabacloud/schedulerx2/Schedulerx2Export.h ) + +set(schedulerx2_public_header_model + include/alibabacloud/schedulerx2/model/CreateAppGroupRequest.h + include/alibabacloud/schedulerx2/model/CreateAppGroupResult.h + include/alibabacloud/schedulerx2/model/CreateJobRequest.h + include/alibabacloud/schedulerx2/model/CreateJobResult.h + include/alibabacloud/schedulerx2/model/DeleteJobRequest.h + include/alibabacloud/schedulerx2/model/DeleteJobResult.h + include/alibabacloud/schedulerx2/model/DeleteWorkflowRequest.h + include/alibabacloud/schedulerx2/model/DeleteWorkflowResult.h + include/alibabacloud/schedulerx2/model/DescribeRegionsRequest.h + include/alibabacloud/schedulerx2/model/DescribeRegionsResult.h + include/alibabacloud/schedulerx2/model/DisableJobRequest.h + include/alibabacloud/schedulerx2/model/DisableJobResult.h + include/alibabacloud/schedulerx2/model/DisableWorkflowRequest.h + include/alibabacloud/schedulerx2/model/DisableWorkflowResult.h + include/alibabacloud/schedulerx2/model/EnableJobRequest.h + include/alibabacloud/schedulerx2/model/EnableJobResult.h + include/alibabacloud/schedulerx2/model/EnableWorkflowRequest.h + include/alibabacloud/schedulerx2/model/EnableWorkflowResult.h + include/alibabacloud/schedulerx2/model/ExecuteJobRequest.h + include/alibabacloud/schedulerx2/model/ExecuteJobResult.h + include/alibabacloud/schedulerx2/model/ExecuteWorkflowRequest.h + include/alibabacloud/schedulerx2/model/ExecuteWorkflowResult.h + include/alibabacloud/schedulerx2/model/GetJobInfoRequest.h + include/alibabacloud/schedulerx2/model/GetJobInfoResult.h + include/alibabacloud/schedulerx2/model/GetJobInstanceRequest.h + include/alibabacloud/schedulerx2/model/GetJobInstanceResult.h + include/alibabacloud/schedulerx2/model/GetJobInstanceListRequest.h + include/alibabacloud/schedulerx2/model/GetJobInstanceListResult.h + include/alibabacloud/schedulerx2/model/GrantPermissionRequest.h + include/alibabacloud/schedulerx2/model/GrantPermissionResult.h + include/alibabacloud/schedulerx2/model/RevokePermissionRequest.h + include/alibabacloud/schedulerx2/model/RevokePermissionResult.h + include/alibabacloud/schedulerx2/model/StopInstanceRequest.h + include/alibabacloud/schedulerx2/model/StopInstanceResult.h + include/alibabacloud/schedulerx2/model/UpdateJobRequest.h + include/alibabacloud/schedulerx2/model/UpdateJobResult.h ) + +set(schedulerx2_src + src/Schedulerx2Client.cc + src/model/CreateAppGroupRequest.cc + src/model/CreateAppGroupResult.cc + src/model/CreateJobRequest.cc + src/model/CreateJobResult.cc + src/model/DeleteJobRequest.cc + src/model/DeleteJobResult.cc + src/model/DeleteWorkflowRequest.cc + src/model/DeleteWorkflowResult.cc + src/model/DescribeRegionsRequest.cc + src/model/DescribeRegionsResult.cc + src/model/DisableJobRequest.cc + src/model/DisableJobResult.cc + src/model/DisableWorkflowRequest.cc + src/model/DisableWorkflowResult.cc + src/model/EnableJobRequest.cc + src/model/EnableJobResult.cc + src/model/EnableWorkflowRequest.cc + src/model/EnableWorkflowResult.cc + src/model/ExecuteJobRequest.cc + src/model/ExecuteJobResult.cc + src/model/ExecuteWorkflowRequest.cc + src/model/ExecuteWorkflowResult.cc + src/model/GetJobInfoRequest.cc + src/model/GetJobInfoResult.cc + src/model/GetJobInstanceRequest.cc + src/model/GetJobInstanceResult.cc + src/model/GetJobInstanceListRequest.cc + src/model/GetJobInstanceListResult.cc + src/model/GrantPermissionRequest.cc + src/model/GrantPermissionResult.cc + src/model/RevokePermissionRequest.cc + src/model/RevokePermissionResult.cc + src/model/StopInstanceRequest.cc + src/model/StopInstanceResult.cc + src/model/UpdateJobRequest.cc + src/model/UpdateJobResult.cc ) + +add_library(schedulerx2 ${LIB_TYPE} + ${schedulerx2_public_header} + ${schedulerx2_public_header_model} + ${schedulerx2_src}) + +set_target_properties(schedulerx2 + 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}schedulerx2 + ) + +if(${LIB_TYPE} STREQUAL "SHARED") + set_target_properties(schedulerx2 + PROPERTIES + DEFINE_SYMBOL ALIBABACLOUD_SCHEDULERX2_LIBRARY) +endif() + +target_include_directories(schedulerx2 + PRIVATE include + ${CMAKE_SOURCE_DIR}/core/include + ) +target_link_libraries(schedulerx2 + core) + +if(CMAKE_HOST_WIN32) + ExternalProject_Get_Property(jsoncpp INSTALL_DIR) + set(jsoncpp_install_dir ${INSTALL_DIR}) + add_dependencies(schedulerx2 + jsoncpp) + target_include_directories(schedulerx2 + PRIVATE ${jsoncpp_install_dir}/include) + target_link_libraries(schedulerx2 + ${jsoncpp_install_dir}/lib/jsoncpp.lib) + set_target_properties(schedulerx2 + PROPERTIES + COMPILE_OPTIONS "/bigobj") +else() + target_include_directories(schedulerx2 + PRIVATE /usr/include/jsoncpp) + target_link_libraries(schedulerx2 + jsoncpp) +endif() + +install(FILES ${schedulerx2_public_header} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/schedulerx2) +install(FILES ${schedulerx2_public_header_model} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/schedulerx2/model) +install(TARGETS schedulerx2 + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + ) \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/Schedulerx2Client.h b/schedulerx2/include/alibabacloud/schedulerx2/Schedulerx2Client.h new file mode 100644 index 000000000..be486b244 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/Schedulerx2Client.h @@ -0,0 +1,190 @@ +/* + * 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_SCHEDULERX2_SCHEDULERX2CLIENT_H_ +#define ALIBABACLOUD_SCHEDULERX2_SCHEDULERX2CLIENT_H_ + +#include +#include +#include +#include +#include "Schedulerx2Export.h" +#include "model/CreateAppGroupRequest.h" +#include "model/CreateAppGroupResult.h" +#include "model/CreateJobRequest.h" +#include "model/CreateJobResult.h" +#include "model/DeleteJobRequest.h" +#include "model/DeleteJobResult.h" +#include "model/DeleteWorkflowRequest.h" +#include "model/DeleteWorkflowResult.h" +#include "model/DescribeRegionsRequest.h" +#include "model/DescribeRegionsResult.h" +#include "model/DisableJobRequest.h" +#include "model/DisableJobResult.h" +#include "model/DisableWorkflowRequest.h" +#include "model/DisableWorkflowResult.h" +#include "model/EnableJobRequest.h" +#include "model/EnableJobResult.h" +#include "model/EnableWorkflowRequest.h" +#include "model/EnableWorkflowResult.h" +#include "model/ExecuteJobRequest.h" +#include "model/ExecuteJobResult.h" +#include "model/ExecuteWorkflowRequest.h" +#include "model/ExecuteWorkflowResult.h" +#include "model/GetJobInfoRequest.h" +#include "model/GetJobInfoResult.h" +#include "model/GetJobInstanceRequest.h" +#include "model/GetJobInstanceResult.h" +#include "model/GetJobInstanceListRequest.h" +#include "model/GetJobInstanceListResult.h" +#include "model/GrantPermissionRequest.h" +#include "model/GrantPermissionResult.h" +#include "model/RevokePermissionRequest.h" +#include "model/RevokePermissionResult.h" +#include "model/StopInstanceRequest.h" +#include "model/StopInstanceResult.h" +#include "model/UpdateJobRequest.h" +#include "model/UpdateJobResult.h" + + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT Schedulerx2Client : public RpcServiceClient + { + public: + typedef Outcome CreateAppGroupOutcome; + typedef std::future CreateAppGroupOutcomeCallable; + typedef std::function&)> CreateAppGroupAsyncHandler; + typedef Outcome CreateJobOutcome; + typedef std::future CreateJobOutcomeCallable; + typedef std::function&)> CreateJobAsyncHandler; + typedef Outcome DeleteJobOutcome; + typedef std::future DeleteJobOutcomeCallable; + typedef std::function&)> DeleteJobAsyncHandler; + typedef Outcome DeleteWorkflowOutcome; + typedef std::future DeleteWorkflowOutcomeCallable; + typedef std::function&)> DeleteWorkflowAsyncHandler; + typedef Outcome DescribeRegionsOutcome; + typedef std::future DescribeRegionsOutcomeCallable; + typedef std::function&)> DescribeRegionsAsyncHandler; + typedef Outcome DisableJobOutcome; + typedef std::future DisableJobOutcomeCallable; + typedef std::function&)> DisableJobAsyncHandler; + typedef Outcome DisableWorkflowOutcome; + typedef std::future DisableWorkflowOutcomeCallable; + typedef std::function&)> DisableWorkflowAsyncHandler; + typedef Outcome EnableJobOutcome; + typedef std::future EnableJobOutcomeCallable; + typedef std::function&)> EnableJobAsyncHandler; + typedef Outcome EnableWorkflowOutcome; + typedef std::future EnableWorkflowOutcomeCallable; + typedef std::function&)> EnableWorkflowAsyncHandler; + typedef Outcome ExecuteJobOutcome; + typedef std::future ExecuteJobOutcomeCallable; + typedef std::function&)> ExecuteJobAsyncHandler; + typedef Outcome ExecuteWorkflowOutcome; + typedef std::future ExecuteWorkflowOutcomeCallable; + typedef std::function&)> ExecuteWorkflowAsyncHandler; + typedef Outcome GetJobInfoOutcome; + typedef std::future GetJobInfoOutcomeCallable; + typedef std::function&)> GetJobInfoAsyncHandler; + typedef Outcome GetJobInstanceOutcome; + typedef std::future GetJobInstanceOutcomeCallable; + typedef std::function&)> GetJobInstanceAsyncHandler; + typedef Outcome GetJobInstanceListOutcome; + typedef std::future GetJobInstanceListOutcomeCallable; + typedef std::function&)> GetJobInstanceListAsyncHandler; + typedef Outcome GrantPermissionOutcome; + typedef std::future GrantPermissionOutcomeCallable; + typedef std::function&)> GrantPermissionAsyncHandler; + typedef Outcome RevokePermissionOutcome; + typedef std::future RevokePermissionOutcomeCallable; + typedef std::function&)> RevokePermissionAsyncHandler; + typedef Outcome StopInstanceOutcome; + typedef std::future StopInstanceOutcomeCallable; + typedef std::function&)> StopInstanceAsyncHandler; + typedef Outcome UpdateJobOutcome; + typedef std::future UpdateJobOutcomeCallable; + typedef std::function&)> UpdateJobAsyncHandler; + + Schedulerx2Client(const Credentials &credentials, const ClientConfiguration &configuration); + Schedulerx2Client(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); + Schedulerx2Client(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration); + ~Schedulerx2Client(); + CreateAppGroupOutcome createAppGroup(const Model::CreateAppGroupRequest &request)const; + void createAppGroupAsync(const Model::CreateAppGroupRequest& request, const CreateAppGroupAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateAppGroupOutcomeCallable createAppGroupCallable(const Model::CreateAppGroupRequest& request) const; + CreateJobOutcome createJob(const Model::CreateJobRequest &request)const; + void createJobAsync(const Model::CreateJobRequest& request, const CreateJobAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateJobOutcomeCallable createJobCallable(const Model::CreateJobRequest& request) const; + DeleteJobOutcome deleteJob(const Model::DeleteJobRequest &request)const; + void deleteJobAsync(const Model::DeleteJobRequest& request, const DeleteJobAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteJobOutcomeCallable deleteJobCallable(const Model::DeleteJobRequest& request) const; + DeleteWorkflowOutcome deleteWorkflow(const Model::DeleteWorkflowRequest &request)const; + void deleteWorkflowAsync(const Model::DeleteWorkflowRequest& request, const DeleteWorkflowAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteWorkflowOutcomeCallable deleteWorkflowCallable(const Model::DeleteWorkflowRequest& request) const; + DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const; + void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const; + DisableJobOutcome disableJob(const Model::DisableJobRequest &request)const; + void disableJobAsync(const Model::DisableJobRequest& request, const DisableJobAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DisableJobOutcomeCallable disableJobCallable(const Model::DisableJobRequest& request) const; + DisableWorkflowOutcome disableWorkflow(const Model::DisableWorkflowRequest &request)const; + void disableWorkflowAsync(const Model::DisableWorkflowRequest& request, const DisableWorkflowAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DisableWorkflowOutcomeCallable disableWorkflowCallable(const Model::DisableWorkflowRequest& request) const; + EnableJobOutcome enableJob(const Model::EnableJobRequest &request)const; + void enableJobAsync(const Model::EnableJobRequest& request, const EnableJobAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + EnableJobOutcomeCallable enableJobCallable(const Model::EnableJobRequest& request) const; + EnableWorkflowOutcome enableWorkflow(const Model::EnableWorkflowRequest &request)const; + void enableWorkflowAsync(const Model::EnableWorkflowRequest& request, const EnableWorkflowAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + EnableWorkflowOutcomeCallable enableWorkflowCallable(const Model::EnableWorkflowRequest& request) const; + ExecuteJobOutcome executeJob(const Model::ExecuteJobRequest &request)const; + void executeJobAsync(const Model::ExecuteJobRequest& request, const ExecuteJobAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ExecuteJobOutcomeCallable executeJobCallable(const Model::ExecuteJobRequest& request) const; + ExecuteWorkflowOutcome executeWorkflow(const Model::ExecuteWorkflowRequest &request)const; + void executeWorkflowAsync(const Model::ExecuteWorkflowRequest& request, const ExecuteWorkflowAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ExecuteWorkflowOutcomeCallable executeWorkflowCallable(const Model::ExecuteWorkflowRequest& request) const; + GetJobInfoOutcome getJobInfo(const Model::GetJobInfoRequest &request)const; + void getJobInfoAsync(const Model::GetJobInfoRequest& request, const GetJobInfoAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetJobInfoOutcomeCallable getJobInfoCallable(const Model::GetJobInfoRequest& request) const; + GetJobInstanceOutcome getJobInstance(const Model::GetJobInstanceRequest &request)const; + void getJobInstanceAsync(const Model::GetJobInstanceRequest& request, const GetJobInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetJobInstanceOutcomeCallable getJobInstanceCallable(const Model::GetJobInstanceRequest& request) const; + GetJobInstanceListOutcome getJobInstanceList(const Model::GetJobInstanceListRequest &request)const; + void getJobInstanceListAsync(const Model::GetJobInstanceListRequest& request, const GetJobInstanceListAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetJobInstanceListOutcomeCallable getJobInstanceListCallable(const Model::GetJobInstanceListRequest& request) const; + GrantPermissionOutcome grantPermission(const Model::GrantPermissionRequest &request)const; + void grantPermissionAsync(const Model::GrantPermissionRequest& request, const GrantPermissionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GrantPermissionOutcomeCallable grantPermissionCallable(const Model::GrantPermissionRequest& request) const; + RevokePermissionOutcome revokePermission(const Model::RevokePermissionRequest &request)const; + void revokePermissionAsync(const Model::RevokePermissionRequest& request, const RevokePermissionAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + RevokePermissionOutcomeCallable revokePermissionCallable(const Model::RevokePermissionRequest& request) const; + StopInstanceOutcome stopInstance(const Model::StopInstanceRequest &request)const; + void stopInstanceAsync(const Model::StopInstanceRequest& request, const StopInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + StopInstanceOutcomeCallable stopInstanceCallable(const Model::StopInstanceRequest& request) const; + UpdateJobOutcome updateJob(const Model::UpdateJobRequest &request)const; + void updateJobAsync(const Model::UpdateJobRequest& request, const UpdateJobAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + UpdateJobOutcomeCallable updateJobCallable(const Model::UpdateJobRequest& request) const; + + private: + std::shared_ptr endpointProvider_; + }; + } +} + +#endif // !ALIBABACLOUD_SCHEDULERX2_SCHEDULERX2CLIENT_H_ diff --git a/schedulerx2/include/alibabacloud/schedulerx2/Schedulerx2Export.h b/schedulerx2/include/alibabacloud/schedulerx2/Schedulerx2Export.h new file mode 100644 index 000000000..b1bf842ce --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/Schedulerx2Export.h @@ -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_SCHEDULERX2_SCHEDULERX2EXPORT_H_ +#define ALIBABACLOUD_SCHEDULERX2_SCHEDULERX2EXPORT_H_ + +#include + +#if defined(ALIBABACLOUD_SHARED) +# if defined(ALIBABACLOUD_SCHEDULERX2_LIBRARY) +# define ALIBABACLOUD_SCHEDULERX2_EXPORT ALIBABACLOUD_DECL_EXPORT +# else +# define ALIBABACLOUD_SCHEDULERX2_EXPORT ALIBABACLOUD_DECL_IMPORT +# endif +#else +# define ALIBABACLOUD_SCHEDULERX2_EXPORT +#endif + +#endif // !ALIBABACLOUD_SCHEDULERX2_SCHEDULERX2EXPORT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/CreateAppGroupRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateAppGroupRequest.h new file mode 100644 index 000000000..ba44d3a77 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateAppGroupRequest.h @@ -0,0 +1,72 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEAPPGROUPREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEAPPGROUPREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT CreateAppGroupRequest : public RpcServiceRequest + { + + public: + CreateAppGroupRequest(); + ~CreateAppGroupRequest(); + + int getMaxJobs()const; + void setMaxJobs(int maxJobs); + std::string getNamespaceName()const; + void setNamespaceName(const std::string& namespaceName); + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getMetricsThresholdJson()const; + void setMetricsThresholdJson(const std::string& metricsThresholdJson); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + std::string getDescription()const; + void setDescription(const std::string& description); + std::string getAppName()const; + void setAppName(const std::string& appName); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + std::string getAlarmJson()const; + void setAlarmJson(const std::string& alarmJson); + + private: + int maxJobs_; + std::string namespaceName_; + std::string namespaceSource_; + std::string metricsThresholdJson_; + std::string groupId_; + std::string description_; + std::string appName_; + std::string _namespace_; + std::string alarmJson_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEAPPGROUPREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/CreateAppGroupResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateAppGroupResult.h new file mode 100644 index 000000000..c4cb6b4c1 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateAppGroupResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEAPPGROUPRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEAPPGROUPRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT CreateAppGroupResult : public ServiceResult + { + public: + struct Data + { + long appGroupId; + }; + + + CreateAppGroupResult(); + explicit CreateAppGroupResult(const std::string &payload); + ~CreateAppGroupResult(); + std::string getMessage()const; + Data getData()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEAPPGROUPRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/CreateJobRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateJobRequest.h new file mode 100644 index 000000000..5fd8cb687 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateJobRequest.h @@ -0,0 +1,141 @@ +/* + * 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_SCHEDULERX2_MODEL_CREATEJOBREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEJOBREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT CreateJobRequest : public RpcServiceRequest + { + public: + struct ContactInfo + { + std::string userPhone; + std::string userName; + }; + + public: + CreateJobRequest(); + ~CreateJobRequest(); + + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getDescription()const; + void setDescription(const std::string& description); + int getAttemptInterval()const; + void setAttemptInterval(int attemptInterval); + std::string getContent()const; + void setContent(const std::string& content); + long getTimeout()const; + void setTimeout(long timeout); + bool getTimeoutKillEnable()const; + void setTimeoutKillEnable(bool timeoutKillEnable); + int getPageSize()const; + void setPageSize(int pageSize); + int getConsumerSize()const; + void setConsumerSize(int consumerSize); + std::string getJarUrl()const; + void setJarUrl(const std::string& jarUrl); + std::string getCalendar()const; + void setCalendar(const std::string& calendar); + bool getFailEnable()const; + void setFailEnable(bool failEnable); + std::string getSendChannel()const; + void setSendChannel(const std::string& sendChannel); + int getDataOffset()const; + void setDataOffset(int dataOffset); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + int getTaskMaxAttempt()const; + void setTaskMaxAttempt(int taskMaxAttempt); + int getMaxAttempt()const; + void setMaxAttempt(int maxAttempt); + int getDispatcherSize()const; + void setDispatcherSize(int dispatcherSize); + std::string getJobType()const; + void setJobType(const std::string& jobType); + int getTaskAttemptInterval()const; + void setTaskAttemptInterval(int taskAttemptInterval); + std::string getExecuteMode()const; + void setExecuteMode(const std::string& executeMode); + int getQueueSize()const; + void setQueueSize(int queueSize); + std::string getTimeExpression()const; + void setTimeExpression(const std::string& timeExpression); + std::string getClassName()const; + void setClassName(const std::string& className); + bool getTimeoutEnable()const; + void setTimeoutEnable(bool timeoutEnable); + std::vector getContactInfo()const; + void setContactInfo(const std::vector& contactInfo); + std::string getName()const; + void setName(const std::string& name); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + int getMaxConcurrency()const; + void setMaxConcurrency(int maxConcurrency); + int getTimeType()const; + void setTimeType(int timeType); + std::string getParameters()const; + void setParameters(const std::string& parameters); + + private: + std::string namespaceSource_; + std::string description_; + int attemptInterval_; + std::string content_; + long timeout_; + bool timeoutKillEnable_; + int pageSize_; + int consumerSize_; + std::string jarUrl_; + std::string calendar_; + bool failEnable_; + std::string sendChannel_; + int dataOffset_; + std::string groupId_; + int taskMaxAttempt_; + int maxAttempt_; + int dispatcherSize_; + std::string jobType_; + int taskAttemptInterval_; + std::string executeMode_; + int queueSize_; + std::string timeExpression_; + std::string className_; + bool timeoutEnable_; + std::vector contactInfo_; + std::string name_; + std::string _namespace_; + int maxConcurrency_; + int timeType_; + std::string parameters_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEJOBREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/CreateJobResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateJobResult.h new file mode 100644 index 000000000..ae8b3956f --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/CreateJobResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEJOBRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEJOBRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT CreateJobResult : public ServiceResult + { + public: + struct Data + { + long jobId; + }; + + + CreateJobResult(); + explicit CreateJobResult(const std::string &payload); + ~CreateJobResult(); + std::string getMessage()const; + Data getData()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_CREATEJOBRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/DeleteJobRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/DeleteJobRequest.h new file mode 100644 index 000000000..7a6623d8e --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/DeleteJobRequest.h @@ -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_SCHEDULERX2_MODEL_DELETEJOBREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEJOBREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT DeleteJobRequest : public RpcServiceRequest + { + + public: + DeleteJobRequest(); + ~DeleteJobRequest(); + + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + long getJobId()const; + void setJobId(long jobId); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + + private: + std::string namespaceSource_; + std::string groupId_; + long jobId_; + std::string _namespace_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEJOBREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/DeleteJobResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/DeleteJobResult.h new file mode 100644 index 000000000..61565c194 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/DeleteJobResult.h @@ -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_SCHEDULERX2_MODEL_DELETEJOBRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEJOBRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT DeleteJobResult : public ServiceResult + { + public: + + + DeleteJobResult(); + explicit DeleteJobResult(const std::string &payload); + ~DeleteJobResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEJOBRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/DeleteWorkflowRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/DeleteWorkflowRequest.h new file mode 100644 index 000000000..bf07fa271 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/DeleteWorkflowRequest.h @@ -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_SCHEDULERX2_MODEL_DELETEWORKFLOWREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEWORKFLOWREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT DeleteWorkflowRequest : public RpcServiceRequest + { + + public: + DeleteWorkflowRequest(); + ~DeleteWorkflowRequest(); + + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + long getWorkflowId()const; + void setWorkflowId(long workflowId); + + private: + std::string namespaceSource_; + std::string groupId_; + std::string _namespace_; + long workflowId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEWORKFLOWREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/DeleteWorkflowResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/DeleteWorkflowResult.h new file mode 100644 index 000000000..16fb51c64 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/DeleteWorkflowResult.h @@ -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_SCHEDULERX2_MODEL_DELETEWORKFLOWRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEWORKFLOWRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT DeleteWorkflowResult : public ServiceResult + { + public: + + + DeleteWorkflowResult(); + explicit DeleteWorkflowResult(const std::string &payload); + ~DeleteWorkflowResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DELETEWORKFLOWRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/DescribeRegionsRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/DescribeRegionsRequest.h new file mode 100644 index 000000000..d7584f0e9 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/DescribeRegionsRequest.h @@ -0,0 +1,45 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_DESCRIBEREGIONSREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_DESCRIBEREGIONSREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT DescribeRegionsRequest : public RpcServiceRequest + { + + public: + DescribeRegionsRequest(); + ~DescribeRegionsRequest(); + + + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DESCRIBEREGIONSREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/DescribeRegionsResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/DescribeRegionsResult.h new file mode 100644 index 000000000..feb341e6e --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/DescribeRegionsResult.h @@ -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_SCHEDULERX2_MODEL_DESCRIBEREGIONSRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_DESCRIBEREGIONSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_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::string getMessage()const; + std::vector getRegions()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + std::vector regions_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DESCRIBEREGIONSRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/DisableJobRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/DisableJobRequest.h new file mode 100644 index 000000000..2ab356671 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/DisableJobRequest.h @@ -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_SCHEDULERX2_MODEL_DISABLEJOBREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEJOBREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT DisableJobRequest : public RpcServiceRequest + { + + public: + DisableJobRequest(); + ~DisableJobRequest(); + + long getJobId()const; + void setJobId(long jobId); + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + + private: + long jobId_; + std::string namespaceSource_; + std::string groupId_; + std::string _namespace_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEJOBREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/DisableJobResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/DisableJobResult.h new file mode 100644 index 000000000..ecd22cda8 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/DisableJobResult.h @@ -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_SCHEDULERX2_MODEL_DISABLEJOBRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEJOBRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT DisableJobResult : public ServiceResult + { + public: + + + DisableJobResult(); + explicit DisableJobResult(const std::string &payload); + ~DisableJobResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEJOBRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/DisableWorkflowRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/DisableWorkflowRequest.h new file mode 100644 index 000000000..661436931 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/DisableWorkflowRequest.h @@ -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_SCHEDULERX2_MODEL_DISABLEWORKFLOWREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEWORKFLOWREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT DisableWorkflowRequest : public RpcServiceRequest + { + + public: + DisableWorkflowRequest(); + ~DisableWorkflowRequest(); + + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + long getWorkflowId()const; + void setWorkflowId(long workflowId); + + private: + std::string namespaceSource_; + std::string groupId_; + std::string _namespace_; + long workflowId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEWORKFLOWREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/DisableWorkflowResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/DisableWorkflowResult.h new file mode 100644 index 000000000..bb0462ba2 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/DisableWorkflowResult.h @@ -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_SCHEDULERX2_MODEL_DISABLEWORKFLOWRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEWORKFLOWRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT DisableWorkflowResult : public ServiceResult + { + public: + + + DisableWorkflowResult(); + explicit DisableWorkflowResult(const std::string &payload); + ~DisableWorkflowResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_DISABLEWORKFLOWRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/EnableJobRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/EnableJobRequest.h new file mode 100644 index 000000000..32cac1af9 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/EnableJobRequest.h @@ -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_SCHEDULERX2_MODEL_ENABLEJOBREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEJOBREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT EnableJobRequest : public RpcServiceRequest + { + + public: + EnableJobRequest(); + ~EnableJobRequest(); + + long getJobId()const; + void setJobId(long jobId); + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + + private: + long jobId_; + std::string namespaceSource_; + std::string groupId_; + std::string _namespace_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEJOBREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/EnableJobResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/EnableJobResult.h new file mode 100644 index 000000000..3aaedbc86 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/EnableJobResult.h @@ -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_SCHEDULERX2_MODEL_ENABLEJOBRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEJOBRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT EnableJobResult : public ServiceResult + { + public: + + + EnableJobResult(); + explicit EnableJobResult(const std::string &payload); + ~EnableJobResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEJOBRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/EnableWorkflowRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/EnableWorkflowRequest.h new file mode 100644 index 000000000..e463afa1e --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/EnableWorkflowRequest.h @@ -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_SCHEDULERX2_MODEL_ENABLEWORKFLOWREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEWORKFLOWREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT EnableWorkflowRequest : public RpcServiceRequest + { + + public: + EnableWorkflowRequest(); + ~EnableWorkflowRequest(); + + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + long getWorkflowId()const; + void setWorkflowId(long workflowId); + + private: + std::string namespaceSource_; + std::string groupId_; + std::string _namespace_; + long workflowId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEWORKFLOWREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/EnableWorkflowResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/EnableWorkflowResult.h new file mode 100644 index 000000000..fee1b7cc9 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/EnableWorkflowResult.h @@ -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_SCHEDULERX2_MODEL_ENABLEWORKFLOWRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEWORKFLOWRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT EnableWorkflowResult : public ServiceResult + { + public: + + + EnableWorkflowResult(); + explicit EnableWorkflowResult(const std::string &payload); + ~EnableWorkflowResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_ENABLEWORKFLOWRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteJobRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteJobRequest.h new file mode 100644 index 000000000..2f0fb23e8 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteJobRequest.h @@ -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_SCHEDULERX2_MODEL_EXECUTEJOBREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEJOBREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT ExecuteJobRequest : public RpcServiceRequest + { + + public: + ExecuteJobRequest(); + ~ExecuteJobRequest(); + + long getJobId()const; + void setJobId(long jobId); + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + std::string getInstanceParameters()const; + void setInstanceParameters(const std::string& instanceParameters); + + private: + long jobId_; + std::string namespaceSource_; + std::string groupId_; + std::string _namespace_; + std::string instanceParameters_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEJOBREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteJobResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteJobResult.h new file mode 100644 index 000000000..9d19e0515 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteJobResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEJOBRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEJOBRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT ExecuteJobResult : public ServiceResult + { + public: + struct Data + { + long jobInstanceId; + }; + + + ExecuteJobResult(); + explicit ExecuteJobResult(const std::string &payload); + ~ExecuteJobResult(); + std::string getMessage()const; + Data getData()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEJOBRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteWorkflowRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteWorkflowRequest.h new file mode 100644 index 000000000..fb7e3aa3b --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteWorkflowRequest.h @@ -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_SCHEDULERX2_MODEL_EXECUTEWORKFLOWREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEWORKFLOWREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT ExecuteWorkflowRequest : public RpcServiceRequest + { + + public: + ExecuteWorkflowRequest(); + ~ExecuteWorkflowRequest(); + + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + long getWorkflowId()const; + void setWorkflowId(long workflowId); + std::string getInstanceParameters()const; + void setInstanceParameters(const std::string& instanceParameters); + + private: + std::string namespaceSource_; + std::string groupId_; + std::string _namespace_; + long workflowId_; + std::string instanceParameters_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEWORKFLOWREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteWorkflowResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteWorkflowResult.h new file mode 100644 index 000000000..b569c9589 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/ExecuteWorkflowResult.h @@ -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. + */ + +#ifndef ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEWORKFLOWRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEWORKFLOWRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT ExecuteWorkflowResult : public ServiceResult + { + public: + struct Data + { + long wfInstanceId; + }; + + + ExecuteWorkflowResult(); + explicit ExecuteWorkflowResult(const std::string &payload); + ~ExecuteWorkflowResult(); + std::string getMessage()const; + Data getData()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_EXECUTEWORKFLOWRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInfoRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInfoRequest.h new file mode 100644 index 000000000..c3f471a27 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInfoRequest.h @@ -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_SCHEDULERX2_MODEL_GETJOBINFOREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINFOREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT GetJobInfoRequest : public RpcServiceRequest + { + + public: + GetJobInfoRequest(); + ~GetJobInfoRequest(); + + long getJobId()const; + void setJobId(long jobId); + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + + private: + long jobId_; + std::string namespaceSource_; + std::string groupId_; + std::string _namespace_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINFOREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInfoResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInfoResult.h new file mode 100644 index 000000000..fbe66e6e1 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInfoResult.h @@ -0,0 +1,112 @@ +/* + * 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_SCHEDULERX2_MODEL_GETJOBINFORESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINFORESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT GetJobInfoResult : public ServiceResult + { + public: + struct Data + { + struct JobConfigInfo + { + struct MapTaskXAttrs + { + int taskAttemptInterval; + int queueSize; + int pageSize; + int dispatcherSize; + int taskMaxAttempt; + int consumerSize; + }; + struct TimeConfig + { + std::string calendar; + std::string timeExpression; + int dataOffset; + int timeType; + }; + struct JobMonitorInfo + { + struct MonitorConfig + { + bool timeoutEnable; + long timeout; + bool failEnable; + std::string sendChannel; + bool timeoutKillEnable; + }; + struct ContactInfoItem + { + std::string userName; + std::string userPhone; + }; + std::vector contactInfo; + MonitorConfig monitorConfig; + }; + int status; + int maxAttempt; + std::string description; + std::string parameters; + std::string jarUrl; + std::string maxConcurrency; + TimeConfig timeConfig; + MapTaskXAttrs mapTaskXAttrs; + std::string name; + JobMonitorInfo jobMonitorInfo; + std::string content; + std::string className; + int attemptInterval; + std::string executeMode; + }; + JobConfigInfo jobConfigInfo; + }; + + + GetJobInfoResult(); + explicit GetJobInfoResult(const std::string &payload); + ~GetJobInfoResult(); + std::string getMessage()const; + Data getData()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINFORESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceListRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceListRequest.h new file mode 100644 index 000000000..4be5d70e2 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceListRequest.h @@ -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_SCHEDULERX2_MODEL_GETJOBINSTANCELISTREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCELISTREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT GetJobInstanceListRequest : public RpcServiceRequest + { + + public: + GetJobInstanceListRequest(); + ~GetJobInstanceListRequest(); + + long getJobId()const; + void setJobId(long jobId); + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + + private: + long jobId_; + std::string namespaceSource_; + std::string groupId_; + std::string _namespace_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCELISTREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceListResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceListResult.h new file mode 100644 index 000000000..95a30cabe --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceListResult.h @@ -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_SCHEDULERX2_MODEL_GETJOBINSTANCELISTRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCELISTRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT GetJobInstanceListResult : public ServiceResult + { + public: + struct Data + { + struct JobInstanceDetailsItem + { + int status; + int triggerType; + std::string progress; + std::string endTime; + long instanceId; + std::string workAddr; + std::string startTime; + std::string dataTime; + std::string result; + int timeType; + std::string executor; + std::string scheduleTime; + long jobId; + }; + std::vector jobInstanceDetails; + }; + + + GetJobInstanceListResult(); + explicit GetJobInstanceListResult(const std::string &payload); + ~GetJobInstanceListResult(); + std::string getMessage()const; + Data getData()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCELISTRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceRequest.h new file mode 100644 index 000000000..1f7386f35 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceRequest.h @@ -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_SCHEDULERX2_MODEL_GETJOBINSTANCEREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT GetJobInstanceRequest : public RpcServiceRequest + { + + public: + GetJobInstanceRequest(); + ~GetJobInstanceRequest(); + + long getJobId()const; + void setJobId(long jobId); + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + long getJobInstanceId()const; + void setJobInstanceId(long jobInstanceId); + + private: + long jobId_; + std::string namespaceSource_; + std::string groupId_; + std::string _namespace_; + long jobInstanceId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCEREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceResult.h new file mode 100644 index 000000000..c05c3ec26 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/GetJobInstanceResult.h @@ -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_SCHEDULERX2_MODEL_GETJOBINSTANCERESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT GetJobInstanceResult : public ServiceResult + { + public: + struct Data + { + struct JobInstanceDetail + { + int status; + int triggerType; + std::string progress; + std::string endTime; + long instanceId; + std::string workAddr; + std::string startTime; + std::string dataTime; + std::string result; + int timeType; + std::string executor; + std::string scheduleTime; + long jobId; + }; + JobInstanceDetail jobInstanceDetail; + }; + + + GetJobInstanceResult(); + explicit GetJobInstanceResult(const std::string &payload); + ~GetJobInstanceResult(); + std::string getMessage()const; + Data getData()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + Data data_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GETJOBINSTANCERESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/GrantPermissionRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/GrantPermissionRequest.h new file mode 100644 index 000000000..4ae60adf4 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/GrantPermissionRequest.h @@ -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_SCHEDULERX2_MODEL_GRANTPERMISSIONREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_GRANTPERMISSIONREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT GrantPermissionRequest : public RpcServiceRequest + { + + public: + GrantPermissionRequest(); + ~GrantPermissionRequest(); + + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + std::string getUserId()const; + void setUserId(const std::string& userId); + bool getGrantOption()const; + void setGrantOption(bool grantOption); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + std::string getUserName()const; + void setUserName(const std::string& userName); + + private: + std::string namespaceSource_; + std::string groupId_; + std::string userId_; + bool grantOption_; + std::string _namespace_; + std::string userName_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GRANTPERMISSIONREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/GrantPermissionResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/GrantPermissionResult.h new file mode 100644 index 000000000..9f61e9967 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/GrantPermissionResult.h @@ -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_SCHEDULERX2_MODEL_GRANTPERMISSIONRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_GRANTPERMISSIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT GrantPermissionResult : public ServiceResult + { + public: + + + GrantPermissionResult(); + explicit GrantPermissionResult(const std::string &payload); + ~GrantPermissionResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_GRANTPERMISSIONRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/RevokePermissionRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/RevokePermissionRequest.h new file mode 100644 index 000000000..d85875f83 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/RevokePermissionRequest.h @@ -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_SCHEDULERX2_MODEL_REVOKEPERMISSIONREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_REVOKEPERMISSIONREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT RevokePermissionRequest : public RpcServiceRequest + { + + public: + RevokePermissionRequest(); + ~RevokePermissionRequest(); + + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + std::string getUserId()const; + void setUserId(const std::string& userId); + + private: + std::string namespaceSource_; + std::string groupId_; + std::string _namespace_; + std::string userId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_REVOKEPERMISSIONREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/RevokePermissionResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/RevokePermissionResult.h new file mode 100644 index 000000000..34400128a --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/RevokePermissionResult.h @@ -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_SCHEDULERX2_MODEL_REVOKEPERMISSIONRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_REVOKEPERMISSIONRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT RevokePermissionResult : public ServiceResult + { + public: + + + RevokePermissionResult(); + explicit RevokePermissionResult(const std::string &payload); + ~RevokePermissionResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_REVOKEPERMISSIONRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/StopInstanceRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/StopInstanceRequest.h new file mode 100644 index 000000000..121deed7c --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/StopInstanceRequest.h @@ -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_SCHEDULERX2_MODEL_STOPINSTANCEREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_STOPINSTANCEREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT StopInstanceRequest : public RpcServiceRequest + { + + public: + StopInstanceRequest(); + ~StopInstanceRequest(); + + long getJobId()const; + void setJobId(long jobId); + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + long getInstanceId()const; + void setInstanceId(long instanceId); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + + private: + long jobId_; + std::string namespaceSource_; + long instanceId_; + std::string groupId_; + std::string _namespace_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_STOPINSTANCEREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/StopInstanceResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/StopInstanceResult.h new file mode 100644 index 000000000..993005ff1 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/StopInstanceResult.h @@ -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_SCHEDULERX2_MODEL_STOPINSTANCERESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_STOPINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT StopInstanceResult : public ServiceResult + { + public: + + + StopInstanceResult(); + explicit StopInstanceResult(const std::string &payload); + ~StopInstanceResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_STOPINSTANCERESULT_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateJobRequest.h b/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateJobRequest.h new file mode 100644 index 000000000..3a5edbc32 --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateJobRequest.h @@ -0,0 +1,141 @@ +/* + * 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_SCHEDULERX2_MODEL_UPDATEJOBREQUEST_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEJOBREQUEST_H_ + +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT UpdateJobRequest : public RpcServiceRequest + { + public: + struct ContactInfo + { + std::string userPhone; + std::string userName; + }; + + public: + UpdateJobRequest(); + ~UpdateJobRequest(); + + std::string getNamespaceSource()const; + void setNamespaceSource(const std::string& namespaceSource); + std::string getDescription()const; + void setDescription(const std::string& description); + int getAttemptInterval()const; + void setAttemptInterval(int attemptInterval); + std::string getContent()const; + void setContent(const std::string& content); + long getTimeout()const; + void setTimeout(long timeout); + bool getTimeoutKillEnable()const; + void setTimeoutKillEnable(bool timeoutKillEnable); + long getJobId()const; + void setJobId(long jobId); + int getPageSize()const; + void setPageSize(int pageSize); + int getConsumerSize()const; + void setConsumerSize(int consumerSize); + std::string getJarUrl()const; + void setJarUrl(const std::string& jarUrl); + std::string getCalendar()const; + void setCalendar(const std::string& calendar); + bool getFailEnable()const; + void setFailEnable(bool failEnable); + std::string getSendChannel()const; + void setSendChannel(const std::string& sendChannel); + int getDataOffset()const; + void setDataOffset(int dataOffset); + std::string getGroupId()const; + void setGroupId(const std::string& groupId); + int getTaskMaxAttempt()const; + void setTaskMaxAttempt(int taskMaxAttempt); + int getMaxAttempt()const; + void setMaxAttempt(int maxAttempt); + int getDispatcherSize()const; + void setDispatcherSize(int dispatcherSize); + int getTaskAttemptInterval()const; + void setTaskAttemptInterval(int taskAttemptInterval); + std::string getExecuteMode()const; + void setExecuteMode(const std::string& executeMode); + int getQueueSize()const; + void setQueueSize(int queueSize); + std::string getTimeExpression()const; + void setTimeExpression(const std::string& timeExpression); + std::string getClassName()const; + void setClassName(const std::string& className); + bool getTimeoutEnable()const; + void setTimeoutEnable(bool timeoutEnable); + std::vector getContactInfo()const; + void setContactInfo(const std::vector& contactInfo); + std::string getName()const; + void setName(const std::string& name); + std::string get_Namespace()const; + void set_Namespace(const std::string& _namespace); + int getMaxConcurrency()const; + void setMaxConcurrency(int maxConcurrency); + int getTimeType()const; + void setTimeType(int timeType); + std::string getParameters()const; + void setParameters(const std::string& parameters); + + private: + std::string namespaceSource_; + std::string description_; + int attemptInterval_; + std::string content_; + long timeout_; + bool timeoutKillEnable_; + long jobId_; + int pageSize_; + int consumerSize_; + std::string jarUrl_; + std::string calendar_; + bool failEnable_; + std::string sendChannel_; + int dataOffset_; + std::string groupId_; + int taskMaxAttempt_; + int maxAttempt_; + int dispatcherSize_; + int taskAttemptInterval_; + std::string executeMode_; + int queueSize_; + std::string timeExpression_; + std::string className_; + bool timeoutEnable_; + std::vector contactInfo_; + std::string name_; + std::string _namespace_; + int maxConcurrency_; + int timeType_; + std::string parameters_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEJOBREQUEST_H_ \ No newline at end of file diff --git a/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateJobResult.h b/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateJobResult.h new file mode 100644 index 000000000..8fcae26ce --- /dev/null +++ b/schedulerx2/include/alibabacloud/schedulerx2/model/UpdateJobResult.h @@ -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_SCHEDULERX2_MODEL_UPDATEJOBRESULT_H_ +#define ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEJOBRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Schedulerx2 + { + namespace Model + { + class ALIBABACLOUD_SCHEDULERX2_EXPORT UpdateJobResult : public ServiceResult + { + public: + + + UpdateJobResult(); + explicit UpdateJobResult(const std::string &payload); + ~UpdateJobResult(); + std::string getMessage()const; + int getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_SCHEDULERX2_MODEL_UPDATEJOBRESULT_H_ \ No newline at end of file diff --git a/schedulerx2/src/Schedulerx2Client.cc b/schedulerx2/src/Schedulerx2Client.cc new file mode 100644 index 000000000..b595f997c --- /dev/null +++ b/schedulerx2/src/Schedulerx2Client.cc @@ -0,0 +1,701 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud; +using namespace AlibabaCloud::Location; +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +namespace +{ + const std::string SERVICE_NAME = "schedulerx2"; +} + +Schedulerx2Client::Schedulerx2Client(const Credentials &credentials, const ClientConfiguration &configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(credentials), configuration) +{ + auto locationClient = std::make_shared(credentials, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); +} + +Schedulerx2Client::Schedulerx2Client(const std::shared_ptr& credentialsProvider, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration) +{ + auto locationClient = std::make_shared(credentialsProvider, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); +} + +Schedulerx2Client::Schedulerx2Client(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) : + RpcServiceClient(SERVICE_NAME, std::make_shared(accessKeyId, accessKeySecret), configuration) +{ + auto locationClient = std::make_shared(accessKeyId, accessKeySecret, configuration); + endpointProvider_ = std::make_shared(locationClient, configuration.regionId(), SERVICE_NAME, ""); +} + +Schedulerx2Client::~Schedulerx2Client() +{} + +Schedulerx2Client::CreateAppGroupOutcome Schedulerx2Client::createAppGroup(const CreateAppGroupRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateAppGroupOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateAppGroupOutcome(CreateAppGroupResult(outcome.result())); + else + return CreateAppGroupOutcome(outcome.error()); +} + +void Schedulerx2Client::createAppGroupAsync(const CreateAppGroupRequest& request, const CreateAppGroupAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createAppGroup(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::CreateAppGroupOutcomeCallable Schedulerx2Client::createAppGroupCallable(const CreateAppGroupRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createAppGroup(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::CreateJobOutcome Schedulerx2Client::createJob(const CreateJobRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateJobOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateJobOutcome(CreateJobResult(outcome.result())); + else + return CreateJobOutcome(outcome.error()); +} + +void Schedulerx2Client::createJobAsync(const CreateJobRequest& request, const CreateJobAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createJob(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::CreateJobOutcomeCallable Schedulerx2Client::createJobCallable(const CreateJobRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createJob(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::DeleteJobOutcome Schedulerx2Client::deleteJob(const DeleteJobRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteJobOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteJobOutcome(DeleteJobResult(outcome.result())); + else + return DeleteJobOutcome(outcome.error()); +} + +void Schedulerx2Client::deleteJobAsync(const DeleteJobRequest& request, const DeleteJobAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteJob(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::DeleteJobOutcomeCallable Schedulerx2Client::deleteJobCallable(const DeleteJobRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteJob(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::DeleteWorkflowOutcome Schedulerx2Client::deleteWorkflow(const DeleteWorkflowRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteWorkflowOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteWorkflowOutcome(DeleteWorkflowResult(outcome.result())); + else + return DeleteWorkflowOutcome(outcome.error()); +} + +void Schedulerx2Client::deleteWorkflowAsync(const DeleteWorkflowRequest& request, const DeleteWorkflowAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteWorkflow(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::DeleteWorkflowOutcomeCallable Schedulerx2Client::deleteWorkflowCallable(const DeleteWorkflowRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteWorkflow(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::DescribeRegionsOutcome Schedulerx2Client::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 Schedulerx2Client::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeRegions(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::DescribeRegionsOutcomeCallable Schedulerx2Client::describeRegionsCallable(const DescribeRegionsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeRegions(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::DisableJobOutcome Schedulerx2Client::disableJob(const DisableJobRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DisableJobOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DisableJobOutcome(DisableJobResult(outcome.result())); + else + return DisableJobOutcome(outcome.error()); +} + +void Schedulerx2Client::disableJobAsync(const DisableJobRequest& request, const DisableJobAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, disableJob(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::DisableJobOutcomeCallable Schedulerx2Client::disableJobCallable(const DisableJobRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->disableJob(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::DisableWorkflowOutcome Schedulerx2Client::disableWorkflow(const DisableWorkflowRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DisableWorkflowOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DisableWorkflowOutcome(DisableWorkflowResult(outcome.result())); + else + return DisableWorkflowOutcome(outcome.error()); +} + +void Schedulerx2Client::disableWorkflowAsync(const DisableWorkflowRequest& request, const DisableWorkflowAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, disableWorkflow(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::DisableWorkflowOutcomeCallable Schedulerx2Client::disableWorkflowCallable(const DisableWorkflowRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->disableWorkflow(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::EnableJobOutcome Schedulerx2Client::enableJob(const EnableJobRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return EnableJobOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return EnableJobOutcome(EnableJobResult(outcome.result())); + else + return EnableJobOutcome(outcome.error()); +} + +void Schedulerx2Client::enableJobAsync(const EnableJobRequest& request, const EnableJobAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, enableJob(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::EnableJobOutcomeCallable Schedulerx2Client::enableJobCallable(const EnableJobRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->enableJob(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::EnableWorkflowOutcome Schedulerx2Client::enableWorkflow(const EnableWorkflowRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return EnableWorkflowOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return EnableWorkflowOutcome(EnableWorkflowResult(outcome.result())); + else + return EnableWorkflowOutcome(outcome.error()); +} + +void Schedulerx2Client::enableWorkflowAsync(const EnableWorkflowRequest& request, const EnableWorkflowAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, enableWorkflow(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::EnableWorkflowOutcomeCallable Schedulerx2Client::enableWorkflowCallable(const EnableWorkflowRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->enableWorkflow(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::ExecuteJobOutcome Schedulerx2Client::executeJob(const ExecuteJobRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ExecuteJobOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ExecuteJobOutcome(ExecuteJobResult(outcome.result())); + else + return ExecuteJobOutcome(outcome.error()); +} + +void Schedulerx2Client::executeJobAsync(const ExecuteJobRequest& request, const ExecuteJobAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, executeJob(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::ExecuteJobOutcomeCallable Schedulerx2Client::executeJobCallable(const ExecuteJobRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->executeJob(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::ExecuteWorkflowOutcome Schedulerx2Client::executeWorkflow(const ExecuteWorkflowRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ExecuteWorkflowOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ExecuteWorkflowOutcome(ExecuteWorkflowResult(outcome.result())); + else + return ExecuteWorkflowOutcome(outcome.error()); +} + +void Schedulerx2Client::executeWorkflowAsync(const ExecuteWorkflowRequest& request, const ExecuteWorkflowAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, executeWorkflow(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::ExecuteWorkflowOutcomeCallable Schedulerx2Client::executeWorkflowCallable(const ExecuteWorkflowRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->executeWorkflow(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::GetJobInfoOutcome Schedulerx2Client::getJobInfo(const GetJobInfoRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetJobInfoOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetJobInfoOutcome(GetJobInfoResult(outcome.result())); + else + return GetJobInfoOutcome(outcome.error()); +} + +void Schedulerx2Client::getJobInfoAsync(const GetJobInfoRequest& request, const GetJobInfoAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getJobInfo(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::GetJobInfoOutcomeCallable Schedulerx2Client::getJobInfoCallable(const GetJobInfoRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getJobInfo(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::GetJobInstanceOutcome Schedulerx2Client::getJobInstance(const GetJobInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetJobInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetJobInstanceOutcome(GetJobInstanceResult(outcome.result())); + else + return GetJobInstanceOutcome(outcome.error()); +} + +void Schedulerx2Client::getJobInstanceAsync(const GetJobInstanceRequest& request, const GetJobInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getJobInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::GetJobInstanceOutcomeCallable Schedulerx2Client::getJobInstanceCallable(const GetJobInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getJobInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::GetJobInstanceListOutcome Schedulerx2Client::getJobInstanceList(const GetJobInstanceListRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetJobInstanceListOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetJobInstanceListOutcome(GetJobInstanceListResult(outcome.result())); + else + return GetJobInstanceListOutcome(outcome.error()); +} + +void Schedulerx2Client::getJobInstanceListAsync(const GetJobInstanceListRequest& request, const GetJobInstanceListAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getJobInstanceList(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::GetJobInstanceListOutcomeCallable Schedulerx2Client::getJobInstanceListCallable(const GetJobInstanceListRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getJobInstanceList(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::GrantPermissionOutcome Schedulerx2Client::grantPermission(const GrantPermissionRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GrantPermissionOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GrantPermissionOutcome(GrantPermissionResult(outcome.result())); + else + return GrantPermissionOutcome(outcome.error()); +} + +void Schedulerx2Client::grantPermissionAsync(const GrantPermissionRequest& request, const GrantPermissionAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, grantPermission(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::GrantPermissionOutcomeCallable Schedulerx2Client::grantPermissionCallable(const GrantPermissionRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->grantPermission(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::RevokePermissionOutcome Schedulerx2Client::revokePermission(const RevokePermissionRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return RevokePermissionOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RevokePermissionOutcome(RevokePermissionResult(outcome.result())); + else + return RevokePermissionOutcome(outcome.error()); +} + +void Schedulerx2Client::revokePermissionAsync(const RevokePermissionRequest& request, const RevokePermissionAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, revokePermission(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::RevokePermissionOutcomeCallable Schedulerx2Client::revokePermissionCallable(const RevokePermissionRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->revokePermission(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::StopInstanceOutcome Schedulerx2Client::stopInstance(const StopInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return StopInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return StopInstanceOutcome(StopInstanceResult(outcome.result())); + else + return StopInstanceOutcome(outcome.error()); +} + +void Schedulerx2Client::stopInstanceAsync(const StopInstanceRequest& request, const StopInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, stopInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::StopInstanceOutcomeCallable Schedulerx2Client::stopInstanceCallable(const StopInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->stopInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +Schedulerx2Client::UpdateJobOutcome Schedulerx2Client::updateJob(const UpdateJobRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return UpdateJobOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return UpdateJobOutcome(UpdateJobResult(outcome.result())); + else + return UpdateJobOutcome(outcome.error()); +} + +void Schedulerx2Client::updateJobAsync(const UpdateJobRequest& request, const UpdateJobAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, updateJob(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +Schedulerx2Client::UpdateJobOutcomeCallable Schedulerx2Client::updateJobCallable(const UpdateJobRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->updateJob(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + diff --git a/schedulerx2/src/model/CreateAppGroupRequest.cc b/schedulerx2/src/model/CreateAppGroupRequest.cc new file mode 100644 index 000000000..5be67b235 --- /dev/null +++ b/schedulerx2/src/model/CreateAppGroupRequest.cc @@ -0,0 +1,128 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Schedulerx2::Model::CreateAppGroupRequest; + +CreateAppGroupRequest::CreateAppGroupRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "CreateAppGroup") +{ + setMethod(HttpRequest::Method::Get); +} + +CreateAppGroupRequest::~CreateAppGroupRequest() +{} + +int CreateAppGroupRequest::getMaxJobs()const +{ + return maxJobs_; +} + +void CreateAppGroupRequest::setMaxJobs(int maxJobs) +{ + maxJobs_ = maxJobs; + setParameter("MaxJobs", std::to_string(maxJobs)); +} + +std::string CreateAppGroupRequest::getNamespaceName()const +{ + return namespaceName_; +} + +void CreateAppGroupRequest::setNamespaceName(const std::string& namespaceName) +{ + namespaceName_ = namespaceName; + setParameter("NamespaceName", namespaceName); +} + +std::string CreateAppGroupRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void CreateAppGroupRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setParameter("NamespaceSource", namespaceSource); +} + +std::string CreateAppGroupRequest::getMetricsThresholdJson()const +{ + return metricsThresholdJson_; +} + +void CreateAppGroupRequest::setMetricsThresholdJson(const std::string& metricsThresholdJson) +{ + metricsThresholdJson_ = metricsThresholdJson; + setParameter("MetricsThresholdJson", metricsThresholdJson); +} + +std::string CreateAppGroupRequest::getGroupId()const +{ + return groupId_; +} + +void CreateAppGroupRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setParameter("GroupId", groupId); +} + +std::string CreateAppGroupRequest::getDescription()const +{ + return description_; +} + +void CreateAppGroupRequest::setDescription(const std::string& description) +{ + description_ = description; + setParameter("Description", description); +} + +std::string CreateAppGroupRequest::getAppName()const +{ + return appName_; +} + +void CreateAppGroupRequest::setAppName(const std::string& appName) +{ + appName_ = appName; + setParameter("AppName", appName); +} + +std::string CreateAppGroupRequest::get_Namespace()const +{ + return _namespace_; +} + +void CreateAppGroupRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setParameter("_Namespace", _namespace); +} + +std::string CreateAppGroupRequest::getAlarmJson()const +{ + return alarmJson_; +} + +void CreateAppGroupRequest::setAlarmJson(const std::string& alarmJson) +{ + alarmJson_ = alarmJson; + setParameter("AlarmJson", alarmJson); +} + diff --git a/schedulerx2/src/model/CreateAppGroupResult.cc b/schedulerx2/src/model/CreateAppGroupResult.cc new file mode 100644 index 000000000..cd6308f7b --- /dev/null +++ b/schedulerx2/src/model/CreateAppGroupResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +CreateAppGroupResult::CreateAppGroupResult() : + ServiceResult() +{} + +CreateAppGroupResult::CreateAppGroupResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateAppGroupResult::~CreateAppGroupResult() +{} + +void CreateAppGroupResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["AppGroupId"].isNull()) + data_.appGroupId = std::stol(dataNode["AppGroupId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string CreateAppGroupResult::getMessage()const +{ + return message_; +} + +CreateAppGroupResult::Data CreateAppGroupResult::getData()const +{ + return data_; +} + +int CreateAppGroupResult::getCode()const +{ + return code_; +} + +bool CreateAppGroupResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/CreateJobRequest.cc b/schedulerx2/src/model/CreateJobRequest.cc new file mode 100644 index 000000000..7bb387b4f --- /dev/null +++ b/schedulerx2/src/model/CreateJobRequest.cc @@ -0,0 +1,364 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Schedulerx2::Model::CreateJobRequest; + +CreateJobRequest::CreateJobRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "CreateJob") +{ + setMethod(HttpRequest::Method::Post); +} + +CreateJobRequest::~CreateJobRequest() +{} + +std::string CreateJobRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void CreateJobRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setBodyParameter("NamespaceSource", namespaceSource); +} + +std::string CreateJobRequest::getDescription()const +{ + return description_; +} + +void CreateJobRequest::setDescription(const std::string& description) +{ + description_ = description; + setBodyParameter("Description", description); +} + +int CreateJobRequest::getAttemptInterval()const +{ + return attemptInterval_; +} + +void CreateJobRequest::setAttemptInterval(int attemptInterval) +{ + attemptInterval_ = attemptInterval; + setBodyParameter("AttemptInterval", std::to_string(attemptInterval)); +} + +std::string CreateJobRequest::getContent()const +{ + return content_; +} + +void CreateJobRequest::setContent(const std::string& content) +{ + content_ = content; + setBodyParameter("Content", content); +} + +long CreateJobRequest::getTimeout()const +{ + return timeout_; +} + +void CreateJobRequest::setTimeout(long timeout) +{ + timeout_ = timeout; + setBodyParameter("Timeout", std::to_string(timeout)); +} + +bool CreateJobRequest::getTimeoutKillEnable()const +{ + return timeoutKillEnable_; +} + +void CreateJobRequest::setTimeoutKillEnable(bool timeoutKillEnable) +{ + timeoutKillEnable_ = timeoutKillEnable; + setBodyParameter("TimeoutKillEnable", timeoutKillEnable ? "true" : "false"); +} + +int CreateJobRequest::getPageSize()const +{ + return pageSize_; +} + +void CreateJobRequest::setPageSize(int pageSize) +{ + pageSize_ = pageSize; + setBodyParameter("PageSize", std::to_string(pageSize)); +} + +int CreateJobRequest::getConsumerSize()const +{ + return consumerSize_; +} + +void CreateJobRequest::setConsumerSize(int consumerSize) +{ + consumerSize_ = consumerSize; + setBodyParameter("ConsumerSize", std::to_string(consumerSize)); +} + +std::string CreateJobRequest::getJarUrl()const +{ + return jarUrl_; +} + +void CreateJobRequest::setJarUrl(const std::string& jarUrl) +{ + jarUrl_ = jarUrl; + setBodyParameter("JarUrl", jarUrl); +} + +std::string CreateJobRequest::getCalendar()const +{ + return calendar_; +} + +void CreateJobRequest::setCalendar(const std::string& calendar) +{ + calendar_ = calendar; + setBodyParameter("Calendar", calendar); +} + +bool CreateJobRequest::getFailEnable()const +{ + return failEnable_; +} + +void CreateJobRequest::setFailEnable(bool failEnable) +{ + failEnable_ = failEnable; + setBodyParameter("FailEnable", failEnable ? "true" : "false"); +} + +std::string CreateJobRequest::getSendChannel()const +{ + return sendChannel_; +} + +void CreateJobRequest::setSendChannel(const std::string& sendChannel) +{ + sendChannel_ = sendChannel; + setBodyParameter("SendChannel", sendChannel); +} + +int CreateJobRequest::getDataOffset()const +{ + return dataOffset_; +} + +void CreateJobRequest::setDataOffset(int dataOffset) +{ + dataOffset_ = dataOffset; + setBodyParameter("DataOffset", std::to_string(dataOffset)); +} + +std::string CreateJobRequest::getGroupId()const +{ + return groupId_; +} + +void CreateJobRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setBodyParameter("GroupId", groupId); +} + +int CreateJobRequest::getTaskMaxAttempt()const +{ + return taskMaxAttempt_; +} + +void CreateJobRequest::setTaskMaxAttempt(int taskMaxAttempt) +{ + taskMaxAttempt_ = taskMaxAttempt; + setBodyParameter("TaskMaxAttempt", std::to_string(taskMaxAttempt)); +} + +int CreateJobRequest::getMaxAttempt()const +{ + return maxAttempt_; +} + +void CreateJobRequest::setMaxAttempt(int maxAttempt) +{ + maxAttempt_ = maxAttempt; + setBodyParameter("MaxAttempt", std::to_string(maxAttempt)); +} + +int CreateJobRequest::getDispatcherSize()const +{ + return dispatcherSize_; +} + +void CreateJobRequest::setDispatcherSize(int dispatcherSize) +{ + dispatcherSize_ = dispatcherSize; + setBodyParameter("DispatcherSize", std::to_string(dispatcherSize)); +} + +std::string CreateJobRequest::getJobType()const +{ + return jobType_; +} + +void CreateJobRequest::setJobType(const std::string& jobType) +{ + jobType_ = jobType; + setBodyParameter("JobType", jobType); +} + +int CreateJobRequest::getTaskAttemptInterval()const +{ + return taskAttemptInterval_; +} + +void CreateJobRequest::setTaskAttemptInterval(int taskAttemptInterval) +{ + taskAttemptInterval_ = taskAttemptInterval; + setBodyParameter("TaskAttemptInterval", std::to_string(taskAttemptInterval)); +} + +std::string CreateJobRequest::getExecuteMode()const +{ + return executeMode_; +} + +void CreateJobRequest::setExecuteMode(const std::string& executeMode) +{ + executeMode_ = executeMode; + setBodyParameter("ExecuteMode", executeMode); +} + +int CreateJobRequest::getQueueSize()const +{ + return queueSize_; +} + +void CreateJobRequest::setQueueSize(int queueSize) +{ + queueSize_ = queueSize; + setBodyParameter("QueueSize", std::to_string(queueSize)); +} + +std::string CreateJobRequest::getTimeExpression()const +{ + return timeExpression_; +} + +void CreateJobRequest::setTimeExpression(const std::string& timeExpression) +{ + timeExpression_ = timeExpression; + setBodyParameter("TimeExpression", timeExpression); +} + +std::string CreateJobRequest::getClassName()const +{ + return className_; +} + +void CreateJobRequest::setClassName(const std::string& className) +{ + className_ = className; + setBodyParameter("ClassName", className); +} + +bool CreateJobRequest::getTimeoutEnable()const +{ + return timeoutEnable_; +} + +void CreateJobRequest::setTimeoutEnable(bool timeoutEnable) +{ + timeoutEnable_ = timeoutEnable; + setBodyParameter("TimeoutEnable", timeoutEnable ? "true" : "false"); +} + +std::vector CreateJobRequest::getContactInfo()const +{ + return contactInfo_; +} + +void CreateJobRequest::setContactInfo(const std::vector& contactInfo) +{ + contactInfo_ = contactInfo; + for(int dep1 = 0; dep1!= contactInfo.size(); dep1++) { + auto contactInfoObj = contactInfo.at(dep1); + std::string contactInfoObjStr = "ContactInfo." + std::to_string(dep1 + 1); + setParameter(contactInfoObjStr + ".UserPhone", contactInfoObj.userPhone); + setParameter(contactInfoObjStr + ".UserName", contactInfoObj.userName); + } +} + +std::string CreateJobRequest::getName()const +{ + return name_; +} + +void CreateJobRequest::setName(const std::string& name) +{ + name_ = name; + setBodyParameter("Name", name); +} + +std::string CreateJobRequest::get_Namespace()const +{ + return _namespace_; +} + +void CreateJobRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setBodyParameter("_Namespace", _namespace); +} + +int CreateJobRequest::getMaxConcurrency()const +{ + return maxConcurrency_; +} + +void CreateJobRequest::setMaxConcurrency(int maxConcurrency) +{ + maxConcurrency_ = maxConcurrency; + setBodyParameter("MaxConcurrency", std::to_string(maxConcurrency)); +} + +int CreateJobRequest::getTimeType()const +{ + return timeType_; +} + +void CreateJobRequest::setTimeType(int timeType) +{ + timeType_ = timeType; + setBodyParameter("TimeType", std::to_string(timeType)); +} + +std::string CreateJobRequest::getParameters()const +{ + return parameters_; +} + +void CreateJobRequest::setParameters(const std::string& parameters) +{ + parameters_ = parameters; + setBodyParameter("Parameters", parameters); +} + diff --git a/schedulerx2/src/model/CreateJobResult.cc b/schedulerx2/src/model/CreateJobResult.cc new file mode 100644 index 000000000..5f21f31eb --- /dev/null +++ b/schedulerx2/src/model/CreateJobResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +CreateJobResult::CreateJobResult() : + ServiceResult() +{} + +CreateJobResult::CreateJobResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateJobResult::~CreateJobResult() +{} + +void CreateJobResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["JobId"].isNull()) + data_.jobId = std::stol(dataNode["JobId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string CreateJobResult::getMessage()const +{ + return message_; +} + +CreateJobResult::Data CreateJobResult::getData()const +{ + return data_; +} + +int CreateJobResult::getCode()const +{ + return code_; +} + +bool CreateJobResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/DeleteJobRequest.cc b/schedulerx2/src/model/DeleteJobRequest.cc new file mode 100644 index 000000000..2e81cb275 --- /dev/null +++ b/schedulerx2/src/model/DeleteJobRequest.cc @@ -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 + +using AlibabaCloud::Schedulerx2::Model::DeleteJobRequest; + +DeleteJobRequest::DeleteJobRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "DeleteJob") +{ + setMethod(HttpRequest::Method::Get); +} + +DeleteJobRequest::~DeleteJobRequest() +{} + +std::string DeleteJobRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void DeleteJobRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setParameter("NamespaceSource", namespaceSource); +} + +std::string DeleteJobRequest::getGroupId()const +{ + return groupId_; +} + +void DeleteJobRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setParameter("GroupId", groupId); +} + +long DeleteJobRequest::getJobId()const +{ + return jobId_; +} + +void DeleteJobRequest::setJobId(long jobId) +{ + jobId_ = jobId; + setParameter("JobId", std::to_string(jobId)); +} + +std::string DeleteJobRequest::get_Namespace()const +{ + return _namespace_; +} + +void DeleteJobRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setParameter("_Namespace", _namespace); +} + diff --git a/schedulerx2/src/model/DeleteJobResult.cc b/schedulerx2/src/model/DeleteJobResult.cc new file mode 100644 index 000000000..c2e6f2c16 --- /dev/null +++ b/schedulerx2/src/model/DeleteJobResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +DeleteJobResult::DeleteJobResult() : + ServiceResult() +{} + +DeleteJobResult::DeleteJobResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteJobResult::~DeleteJobResult() +{} + +void DeleteJobResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::string DeleteJobResult::getMessage()const +{ + return message_; +} + +int DeleteJobResult::getCode()const +{ + return code_; +} + +bool DeleteJobResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/DeleteWorkflowRequest.cc b/schedulerx2/src/model/DeleteWorkflowRequest.cc new file mode 100644 index 000000000..a0cd7d4b2 --- /dev/null +++ b/schedulerx2/src/model/DeleteWorkflowRequest.cc @@ -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 + +using AlibabaCloud::Schedulerx2::Model::DeleteWorkflowRequest; + +DeleteWorkflowRequest::DeleteWorkflowRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "DeleteWorkflow") +{ + setMethod(HttpRequest::Method::Get); +} + +DeleteWorkflowRequest::~DeleteWorkflowRequest() +{} + +std::string DeleteWorkflowRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void DeleteWorkflowRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setParameter("NamespaceSource", namespaceSource); +} + +std::string DeleteWorkflowRequest::getGroupId()const +{ + return groupId_; +} + +void DeleteWorkflowRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setParameter("GroupId", groupId); +} + +std::string DeleteWorkflowRequest::get_Namespace()const +{ + return _namespace_; +} + +void DeleteWorkflowRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setParameter("_Namespace", _namespace); +} + +long DeleteWorkflowRequest::getWorkflowId()const +{ + return workflowId_; +} + +void DeleteWorkflowRequest::setWorkflowId(long workflowId) +{ + workflowId_ = workflowId; + setParameter("WorkflowId", std::to_string(workflowId)); +} + diff --git a/schedulerx2/src/model/DeleteWorkflowResult.cc b/schedulerx2/src/model/DeleteWorkflowResult.cc new file mode 100644 index 000000000..3b38892b4 --- /dev/null +++ b/schedulerx2/src/model/DeleteWorkflowResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +DeleteWorkflowResult::DeleteWorkflowResult() : + ServiceResult() +{} + +DeleteWorkflowResult::DeleteWorkflowResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteWorkflowResult::~DeleteWorkflowResult() +{} + +void DeleteWorkflowResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string DeleteWorkflowResult::getMessage()const +{ + return message_; +} + +int DeleteWorkflowResult::getCode()const +{ + return code_; +} + +bool DeleteWorkflowResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/DescribeRegionsRequest.cc b/schedulerx2/src/model/DescribeRegionsRequest.cc new file mode 100644 index 000000000..903a71402 --- /dev/null +++ b/schedulerx2/src/model/DescribeRegionsRequest.cc @@ -0,0 +1,29 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Schedulerx2::Model::DescribeRegionsRequest; + +DescribeRegionsRequest::DescribeRegionsRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "DescribeRegions") +{ + setMethod(HttpRequest::Method::Post); +} + +DescribeRegionsRequest::~DescribeRegionsRequest() +{} + diff --git a/schedulerx2/src/model/DescribeRegionsResult.cc b/schedulerx2/src/model/DescribeRegionsResult.cc new file mode 100644 index 000000000..1ace1d2b9 --- /dev/null +++ b/schedulerx2/src/model/DescribeRegionsResult.cc @@ -0,0 +1,82 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::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["LocalName"].isNull()) + regionsObject.localName = valueRegionsRegion["LocalName"].asString(); + if(!valueRegionsRegion["RegionEndpoint"].isNull()) + regionsObject.regionEndpoint = valueRegionsRegion["RegionEndpoint"].asString(); + regions_.push_back(regionsObject); + } + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::string DescribeRegionsResult::getMessage()const +{ + return message_; +} + +std::vector DescribeRegionsResult::getRegions()const +{ + return regions_; +} + +int DescribeRegionsResult::getCode()const +{ + return code_; +} + +bool DescribeRegionsResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/DisableJobRequest.cc b/schedulerx2/src/model/DisableJobRequest.cc new file mode 100644 index 000000000..c1fe6cdac --- /dev/null +++ b/schedulerx2/src/model/DisableJobRequest.cc @@ -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 + +using AlibabaCloud::Schedulerx2::Model::DisableJobRequest; + +DisableJobRequest::DisableJobRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "DisableJob") +{ + setMethod(HttpRequest::Method::Get); +} + +DisableJobRequest::~DisableJobRequest() +{} + +long DisableJobRequest::getJobId()const +{ + return jobId_; +} + +void DisableJobRequest::setJobId(long jobId) +{ + jobId_ = jobId; + setParameter("JobId", std::to_string(jobId)); +} + +std::string DisableJobRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void DisableJobRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setParameter("NamespaceSource", namespaceSource); +} + +std::string DisableJobRequest::getGroupId()const +{ + return groupId_; +} + +void DisableJobRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setParameter("GroupId", groupId); +} + +std::string DisableJobRequest::get_Namespace()const +{ + return _namespace_; +} + +void DisableJobRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setParameter("_Namespace", _namespace); +} + diff --git a/schedulerx2/src/model/DisableJobResult.cc b/schedulerx2/src/model/DisableJobResult.cc new file mode 100644 index 000000000..62b2e3f69 --- /dev/null +++ b/schedulerx2/src/model/DisableJobResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +DisableJobResult::DisableJobResult() : + ServiceResult() +{} + +DisableJobResult::DisableJobResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DisableJobResult::~DisableJobResult() +{} + +void DisableJobResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string DisableJobResult::getMessage()const +{ + return message_; +} + +int DisableJobResult::getCode()const +{ + return code_; +} + +bool DisableJobResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/DisableWorkflowRequest.cc b/schedulerx2/src/model/DisableWorkflowRequest.cc new file mode 100644 index 000000000..d95d5e600 --- /dev/null +++ b/schedulerx2/src/model/DisableWorkflowRequest.cc @@ -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 + +using AlibabaCloud::Schedulerx2::Model::DisableWorkflowRequest; + +DisableWorkflowRequest::DisableWorkflowRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "DisableWorkflow") +{ + setMethod(HttpRequest::Method::Get); +} + +DisableWorkflowRequest::~DisableWorkflowRequest() +{} + +std::string DisableWorkflowRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void DisableWorkflowRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setParameter("NamespaceSource", namespaceSource); +} + +std::string DisableWorkflowRequest::getGroupId()const +{ + return groupId_; +} + +void DisableWorkflowRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setParameter("GroupId", groupId); +} + +std::string DisableWorkflowRequest::get_Namespace()const +{ + return _namespace_; +} + +void DisableWorkflowRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setParameter("_Namespace", _namespace); +} + +long DisableWorkflowRequest::getWorkflowId()const +{ + return workflowId_; +} + +void DisableWorkflowRequest::setWorkflowId(long workflowId) +{ + workflowId_ = workflowId; + setParameter("WorkflowId", std::to_string(workflowId)); +} + diff --git a/schedulerx2/src/model/DisableWorkflowResult.cc b/schedulerx2/src/model/DisableWorkflowResult.cc new file mode 100644 index 000000000..17c1e6f34 --- /dev/null +++ b/schedulerx2/src/model/DisableWorkflowResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +DisableWorkflowResult::DisableWorkflowResult() : + ServiceResult() +{} + +DisableWorkflowResult::DisableWorkflowResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DisableWorkflowResult::~DisableWorkflowResult() +{} + +void DisableWorkflowResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string DisableWorkflowResult::getMessage()const +{ + return message_; +} + +int DisableWorkflowResult::getCode()const +{ + return code_; +} + +bool DisableWorkflowResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/EnableJobRequest.cc b/schedulerx2/src/model/EnableJobRequest.cc new file mode 100644 index 000000000..009cc9ce1 --- /dev/null +++ b/schedulerx2/src/model/EnableJobRequest.cc @@ -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 + +using AlibabaCloud::Schedulerx2::Model::EnableJobRequest; + +EnableJobRequest::EnableJobRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "EnableJob") +{ + setMethod(HttpRequest::Method::Get); +} + +EnableJobRequest::~EnableJobRequest() +{} + +long EnableJobRequest::getJobId()const +{ + return jobId_; +} + +void EnableJobRequest::setJobId(long jobId) +{ + jobId_ = jobId; + setParameter("JobId", std::to_string(jobId)); +} + +std::string EnableJobRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void EnableJobRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setParameter("NamespaceSource", namespaceSource); +} + +std::string EnableJobRequest::getGroupId()const +{ + return groupId_; +} + +void EnableJobRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setParameter("GroupId", groupId); +} + +std::string EnableJobRequest::get_Namespace()const +{ + return _namespace_; +} + +void EnableJobRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setParameter("_Namespace", _namespace); +} + diff --git a/schedulerx2/src/model/EnableJobResult.cc b/schedulerx2/src/model/EnableJobResult.cc new file mode 100644 index 000000000..ffb15852c --- /dev/null +++ b/schedulerx2/src/model/EnableJobResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +EnableJobResult::EnableJobResult() : + ServiceResult() +{} + +EnableJobResult::EnableJobResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +EnableJobResult::~EnableJobResult() +{} + +void EnableJobResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string EnableJobResult::getMessage()const +{ + return message_; +} + +int EnableJobResult::getCode()const +{ + return code_; +} + +bool EnableJobResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/EnableWorkflowRequest.cc b/schedulerx2/src/model/EnableWorkflowRequest.cc new file mode 100644 index 000000000..446bbca1c --- /dev/null +++ b/schedulerx2/src/model/EnableWorkflowRequest.cc @@ -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 + +using AlibabaCloud::Schedulerx2::Model::EnableWorkflowRequest; + +EnableWorkflowRequest::EnableWorkflowRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "EnableWorkflow") +{ + setMethod(HttpRequest::Method::Get); +} + +EnableWorkflowRequest::~EnableWorkflowRequest() +{} + +std::string EnableWorkflowRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void EnableWorkflowRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setParameter("NamespaceSource", namespaceSource); +} + +std::string EnableWorkflowRequest::getGroupId()const +{ + return groupId_; +} + +void EnableWorkflowRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setParameter("GroupId", groupId); +} + +std::string EnableWorkflowRequest::get_Namespace()const +{ + return _namespace_; +} + +void EnableWorkflowRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setParameter("_Namespace", _namespace); +} + +long EnableWorkflowRequest::getWorkflowId()const +{ + return workflowId_; +} + +void EnableWorkflowRequest::setWorkflowId(long workflowId) +{ + workflowId_ = workflowId; + setParameter("WorkflowId", std::to_string(workflowId)); +} + diff --git a/schedulerx2/src/model/EnableWorkflowResult.cc b/schedulerx2/src/model/EnableWorkflowResult.cc new file mode 100644 index 000000000..f37edc5e3 --- /dev/null +++ b/schedulerx2/src/model/EnableWorkflowResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +EnableWorkflowResult::EnableWorkflowResult() : + ServiceResult() +{} + +EnableWorkflowResult::EnableWorkflowResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +EnableWorkflowResult::~EnableWorkflowResult() +{} + +void EnableWorkflowResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string EnableWorkflowResult::getMessage()const +{ + return message_; +} + +int EnableWorkflowResult::getCode()const +{ + return code_; +} + +bool EnableWorkflowResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/ExecuteJobRequest.cc b/schedulerx2/src/model/ExecuteJobRequest.cc new file mode 100644 index 000000000..955786006 --- /dev/null +++ b/schedulerx2/src/model/ExecuteJobRequest.cc @@ -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 + +using AlibabaCloud::Schedulerx2::Model::ExecuteJobRequest; + +ExecuteJobRequest::ExecuteJobRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "ExecuteJob") +{ + setMethod(HttpRequest::Method::Get); +} + +ExecuteJobRequest::~ExecuteJobRequest() +{} + +long ExecuteJobRequest::getJobId()const +{ + return jobId_; +} + +void ExecuteJobRequest::setJobId(long jobId) +{ + jobId_ = jobId; + setParameter("JobId", std::to_string(jobId)); +} + +std::string ExecuteJobRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void ExecuteJobRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setParameter("NamespaceSource", namespaceSource); +} + +std::string ExecuteJobRequest::getGroupId()const +{ + return groupId_; +} + +void ExecuteJobRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setParameter("GroupId", groupId); +} + +std::string ExecuteJobRequest::get_Namespace()const +{ + return _namespace_; +} + +void ExecuteJobRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setParameter("_Namespace", _namespace); +} + +std::string ExecuteJobRequest::getInstanceParameters()const +{ + return instanceParameters_; +} + +void ExecuteJobRequest::setInstanceParameters(const std::string& instanceParameters) +{ + instanceParameters_ = instanceParameters; + setParameter("InstanceParameters", instanceParameters); +} + diff --git a/schedulerx2/src/model/ExecuteJobResult.cc b/schedulerx2/src/model/ExecuteJobResult.cc new file mode 100644 index 000000000..027c7ad53 --- /dev/null +++ b/schedulerx2/src/model/ExecuteJobResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +ExecuteJobResult::ExecuteJobResult() : + ServiceResult() +{} + +ExecuteJobResult::ExecuteJobResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ExecuteJobResult::~ExecuteJobResult() +{} + +void ExecuteJobResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["JobInstanceId"].isNull()) + data_.jobInstanceId = std::stol(dataNode["JobInstanceId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::string ExecuteJobResult::getMessage()const +{ + return message_; +} + +ExecuteJobResult::Data ExecuteJobResult::getData()const +{ + return data_; +} + +int ExecuteJobResult::getCode()const +{ + return code_; +} + +bool ExecuteJobResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/ExecuteWorkflowRequest.cc b/schedulerx2/src/model/ExecuteWorkflowRequest.cc new file mode 100644 index 000000000..05a6e3ce4 --- /dev/null +++ b/schedulerx2/src/model/ExecuteWorkflowRequest.cc @@ -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 + +using AlibabaCloud::Schedulerx2::Model::ExecuteWorkflowRequest; + +ExecuteWorkflowRequest::ExecuteWorkflowRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "ExecuteWorkflow") +{ + setMethod(HttpRequest::Method::Get); +} + +ExecuteWorkflowRequest::~ExecuteWorkflowRequest() +{} + +std::string ExecuteWorkflowRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void ExecuteWorkflowRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setParameter("NamespaceSource", namespaceSource); +} + +std::string ExecuteWorkflowRequest::getGroupId()const +{ + return groupId_; +} + +void ExecuteWorkflowRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setParameter("GroupId", groupId); +} + +std::string ExecuteWorkflowRequest::get_Namespace()const +{ + return _namespace_; +} + +void ExecuteWorkflowRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setParameter("_Namespace", _namespace); +} + +long ExecuteWorkflowRequest::getWorkflowId()const +{ + return workflowId_; +} + +void ExecuteWorkflowRequest::setWorkflowId(long workflowId) +{ + workflowId_ = workflowId; + setParameter("WorkflowId", std::to_string(workflowId)); +} + +std::string ExecuteWorkflowRequest::getInstanceParameters()const +{ + return instanceParameters_; +} + +void ExecuteWorkflowRequest::setInstanceParameters(const std::string& instanceParameters) +{ + instanceParameters_ = instanceParameters; + setParameter("InstanceParameters", instanceParameters); +} + diff --git a/schedulerx2/src/model/ExecuteWorkflowResult.cc b/schedulerx2/src/model/ExecuteWorkflowResult.cc new file mode 100644 index 000000000..e7916edf2 --- /dev/null +++ b/schedulerx2/src/model/ExecuteWorkflowResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +ExecuteWorkflowResult::ExecuteWorkflowResult() : + ServiceResult() +{} + +ExecuteWorkflowResult::ExecuteWorkflowResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ExecuteWorkflowResult::~ExecuteWorkflowResult() +{} + +void ExecuteWorkflowResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["WfInstanceId"].isNull()) + data_.wfInstanceId = std::stol(dataNode["WfInstanceId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::string ExecuteWorkflowResult::getMessage()const +{ + return message_; +} + +ExecuteWorkflowResult::Data ExecuteWorkflowResult::getData()const +{ + return data_; +} + +int ExecuteWorkflowResult::getCode()const +{ + return code_; +} + +bool ExecuteWorkflowResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/GetJobInfoRequest.cc b/schedulerx2/src/model/GetJobInfoRequest.cc new file mode 100644 index 000000000..6ce24f908 --- /dev/null +++ b/schedulerx2/src/model/GetJobInfoRequest.cc @@ -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 + +using AlibabaCloud::Schedulerx2::Model::GetJobInfoRequest; + +GetJobInfoRequest::GetJobInfoRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "GetJobInfo") +{ + setMethod(HttpRequest::Method::Get); +} + +GetJobInfoRequest::~GetJobInfoRequest() +{} + +long GetJobInfoRequest::getJobId()const +{ + return jobId_; +} + +void GetJobInfoRequest::setJobId(long jobId) +{ + jobId_ = jobId; + setParameter("JobId", std::to_string(jobId)); +} + +std::string GetJobInfoRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void GetJobInfoRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setParameter("NamespaceSource", namespaceSource); +} + +std::string GetJobInfoRequest::getGroupId()const +{ + return groupId_; +} + +void GetJobInfoRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setParameter("GroupId", groupId); +} + +std::string GetJobInfoRequest::get_Namespace()const +{ + return _namespace_; +} + +void GetJobInfoRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setParameter("_Namespace", _namespace); +} + diff --git a/schedulerx2/src/model/GetJobInfoResult.cc b/schedulerx2/src/model/GetJobInfoResult.cc new file mode 100644 index 000000000..64d168fd9 --- /dev/null +++ b/schedulerx2/src/model/GetJobInfoResult.cc @@ -0,0 +1,138 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +GetJobInfoResult::GetJobInfoResult() : + ServiceResult() +{} + +GetJobInfoResult::GetJobInfoResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetJobInfoResult::~GetJobInfoResult() +{} + +void GetJobInfoResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + auto jobConfigInfoNode = dataNode["JobConfigInfo"]; + if(!jobConfigInfoNode["ClassName"].isNull()) + data_.jobConfigInfo.className = jobConfigInfoNode["ClassName"].asString(); + if(!jobConfigInfoNode["JarUrl"].isNull()) + data_.jobConfigInfo.jarUrl = jobConfigInfoNode["JarUrl"].asString(); + if(!jobConfigInfoNode["Content"].isNull()) + data_.jobConfigInfo.content = jobConfigInfoNode["Content"].asString(); + if(!jobConfigInfoNode["Name"].isNull()) + data_.jobConfigInfo.name = jobConfigInfoNode["Name"].asString(); + if(!jobConfigInfoNode["Description"].isNull()) + data_.jobConfigInfo.description = jobConfigInfoNode["Description"].asString(); + if(!jobConfigInfoNode["Status"].isNull()) + data_.jobConfigInfo.status = std::stoi(jobConfigInfoNode["Status"].asString()); + if(!jobConfigInfoNode["ExecuteMode"].isNull()) + data_.jobConfigInfo.executeMode = jobConfigInfoNode["ExecuteMode"].asString(); + if(!jobConfigInfoNode["Parameters"].isNull()) + data_.jobConfigInfo.parameters = jobConfigInfoNode["Parameters"].asString(); + if(!jobConfigInfoNode["MaxConcurrency"].isNull()) + data_.jobConfigInfo.maxConcurrency = jobConfigInfoNode["MaxConcurrency"].asString(); + if(!jobConfigInfoNode["MaxAttempt"].isNull()) + data_.jobConfigInfo.maxAttempt = std::stoi(jobConfigInfoNode["MaxAttempt"].asString()); + if(!jobConfigInfoNode["AttemptInterval"].isNull()) + data_.jobConfigInfo.attemptInterval = std::stoi(jobConfigInfoNode["AttemptInterval"].asString()); + auto mapTaskXAttrsNode = jobConfigInfoNode["MapTaskXAttrs"]; + if(!mapTaskXAttrsNode["PageSize"].isNull()) + data_.jobConfigInfo.mapTaskXAttrs.pageSize = std::stoi(mapTaskXAttrsNode["PageSize"].asString()); + if(!mapTaskXAttrsNode["ConsumerSize"].isNull()) + data_.jobConfigInfo.mapTaskXAttrs.consumerSize = std::stoi(mapTaskXAttrsNode["ConsumerSize"].asString()); + if(!mapTaskXAttrsNode["QueueSize"].isNull()) + data_.jobConfigInfo.mapTaskXAttrs.queueSize = std::stoi(mapTaskXAttrsNode["QueueSize"].asString()); + if(!mapTaskXAttrsNode["DispatcherSize"].isNull()) + data_.jobConfigInfo.mapTaskXAttrs.dispatcherSize = std::stoi(mapTaskXAttrsNode["DispatcherSize"].asString()); + if(!mapTaskXAttrsNode["TaskMaxAttempt"].isNull()) + data_.jobConfigInfo.mapTaskXAttrs.taskMaxAttempt = std::stoi(mapTaskXAttrsNode["TaskMaxAttempt"].asString()); + if(!mapTaskXAttrsNode["TaskAttemptInterval"].isNull()) + data_.jobConfigInfo.mapTaskXAttrs.taskAttemptInterval = std::stoi(mapTaskXAttrsNode["TaskAttemptInterval"].asString()); + auto timeConfigNode = jobConfigInfoNode["TimeConfig"]; + if(!timeConfigNode["TimeType"].isNull()) + data_.jobConfigInfo.timeConfig.timeType = std::stoi(timeConfigNode["TimeType"].asString()); + if(!timeConfigNode["TimeExpression"].isNull()) + data_.jobConfigInfo.timeConfig.timeExpression = timeConfigNode["TimeExpression"].asString(); + if(!timeConfigNode["Calendar"].isNull()) + data_.jobConfigInfo.timeConfig.calendar = timeConfigNode["Calendar"].asString(); + if(!timeConfigNode["DataOffset"].isNull()) + data_.jobConfigInfo.timeConfig.dataOffset = std::stoi(timeConfigNode["DataOffset"].asString()); + auto jobMonitorInfoNode = jobConfigInfoNode["JobMonitorInfo"]; + auto allContactInfoNode = jobMonitorInfoNode["ContactInfo"]["ContactInfoItem"]; + for (auto jobMonitorInfoNodeContactInfoContactInfoItem : allContactInfoNode) + { + Data::JobConfigInfo::JobMonitorInfo::ContactInfoItem contactInfoItemObject; + if(!jobMonitorInfoNodeContactInfoContactInfoItem["UserName"].isNull()) + contactInfoItemObject.userName = jobMonitorInfoNodeContactInfoContactInfoItem["UserName"].asString(); + if(!jobMonitorInfoNodeContactInfoContactInfoItem["UserPhone"].isNull()) + contactInfoItemObject.userPhone = jobMonitorInfoNodeContactInfoContactInfoItem["UserPhone"].asString(); + data_.jobConfigInfo.jobMonitorInfo.contactInfo.push_back(contactInfoItemObject); + } + auto monitorConfigNode = jobMonitorInfoNode["MonitorConfig"]; + if(!monitorConfigNode["TimeoutEnable"].isNull()) + data_.jobConfigInfo.jobMonitorInfo.monitorConfig.timeoutEnable = monitorConfigNode["TimeoutEnable"].asString() == "true"; + if(!monitorConfigNode["Timeout"].isNull()) + data_.jobConfigInfo.jobMonitorInfo.monitorConfig.timeout = std::stol(monitorConfigNode["Timeout"].asString()); + if(!monitorConfigNode["TimeoutKillEnable"].isNull()) + data_.jobConfigInfo.jobMonitorInfo.monitorConfig.timeoutKillEnable = monitorConfigNode["TimeoutKillEnable"].asString() == "true"; + if(!monitorConfigNode["FailEnable"].isNull()) + data_.jobConfigInfo.jobMonitorInfo.monitorConfig.failEnable = monitorConfigNode["FailEnable"].asString() == "true"; + if(!monitorConfigNode["SendChannel"].isNull()) + data_.jobConfigInfo.jobMonitorInfo.monitorConfig.sendChannel = monitorConfigNode["SendChannel"].asString(); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::string GetJobInfoResult::getMessage()const +{ + return message_; +} + +GetJobInfoResult::Data GetJobInfoResult::getData()const +{ + return data_; +} + +int GetJobInfoResult::getCode()const +{ + return code_; +} + +bool GetJobInfoResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/GetJobInstanceListRequest.cc b/schedulerx2/src/model/GetJobInstanceListRequest.cc new file mode 100644 index 000000000..4826d821a --- /dev/null +++ b/schedulerx2/src/model/GetJobInstanceListRequest.cc @@ -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 + +using AlibabaCloud::Schedulerx2::Model::GetJobInstanceListRequest; + +GetJobInstanceListRequest::GetJobInstanceListRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "GetJobInstanceList") +{ + setMethod(HttpRequest::Method::Get); +} + +GetJobInstanceListRequest::~GetJobInstanceListRequest() +{} + +long GetJobInstanceListRequest::getJobId()const +{ + return jobId_; +} + +void GetJobInstanceListRequest::setJobId(long jobId) +{ + jobId_ = jobId; + setParameter("JobId", std::to_string(jobId)); +} + +std::string GetJobInstanceListRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void GetJobInstanceListRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setParameter("NamespaceSource", namespaceSource); +} + +std::string GetJobInstanceListRequest::getGroupId()const +{ + return groupId_; +} + +void GetJobInstanceListRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setParameter("GroupId", groupId); +} + +std::string GetJobInstanceListRequest::get_Namespace()const +{ + return _namespace_; +} + +void GetJobInstanceListRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setParameter("_Namespace", _namespace); +} + diff --git a/schedulerx2/src/model/GetJobInstanceListResult.cc b/schedulerx2/src/model/GetJobInstanceListResult.cc new file mode 100644 index 000000000..0c31b2c6c --- /dev/null +++ b/schedulerx2/src/model/GetJobInstanceListResult.cc @@ -0,0 +1,103 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +GetJobInstanceListResult::GetJobInstanceListResult() : + ServiceResult() +{} + +GetJobInstanceListResult::GetJobInstanceListResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetJobInstanceListResult::~GetJobInstanceListResult() +{} + +void GetJobInstanceListResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + auto allJobInstanceDetailsNode = dataNode["JobInstanceDetails"]["JobInstanceDetailsItem"]; + for (auto dataNodeJobInstanceDetailsJobInstanceDetailsItem : allJobInstanceDetailsNode) + { + Data::JobInstanceDetailsItem jobInstanceDetailsItemObject; + if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["InstanceId"].isNull()) + jobInstanceDetailsItemObject.instanceId = std::stol(dataNodeJobInstanceDetailsJobInstanceDetailsItem["InstanceId"].asString()); + if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["JobId"].isNull()) + jobInstanceDetailsItemObject.jobId = std::stol(dataNodeJobInstanceDetailsJobInstanceDetailsItem["JobId"].asString()); + if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["Status"].isNull()) + jobInstanceDetailsItemObject.status = std::stoi(dataNodeJobInstanceDetailsJobInstanceDetailsItem["Status"].asString()); + if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["StartTime"].isNull()) + jobInstanceDetailsItemObject.startTime = dataNodeJobInstanceDetailsJobInstanceDetailsItem["StartTime"].asString(); + if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["EndTime"].isNull()) + jobInstanceDetailsItemObject.endTime = dataNodeJobInstanceDetailsJobInstanceDetailsItem["EndTime"].asString(); + if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["ScheduleTime"].isNull()) + jobInstanceDetailsItemObject.scheduleTime = dataNodeJobInstanceDetailsJobInstanceDetailsItem["ScheduleTime"].asString(); + if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["DataTime"].isNull()) + jobInstanceDetailsItemObject.dataTime = dataNodeJobInstanceDetailsJobInstanceDetailsItem["DataTime"].asString(); + if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["Executor"].isNull()) + jobInstanceDetailsItemObject.executor = dataNodeJobInstanceDetailsJobInstanceDetailsItem["Executor"].asString(); + if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["WorkAddr"].isNull()) + jobInstanceDetailsItemObject.workAddr = dataNodeJobInstanceDetailsJobInstanceDetailsItem["WorkAddr"].asString(); + if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["Result"].isNull()) + jobInstanceDetailsItemObject.result = dataNodeJobInstanceDetailsJobInstanceDetailsItem["Result"].asString(); + if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["Progress"].isNull()) + jobInstanceDetailsItemObject.progress = dataNodeJobInstanceDetailsJobInstanceDetailsItem["Progress"].asString(); + if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["TimeType"].isNull()) + jobInstanceDetailsItemObject.timeType = std::stoi(dataNodeJobInstanceDetailsJobInstanceDetailsItem["TimeType"].asString()); + if(!dataNodeJobInstanceDetailsJobInstanceDetailsItem["TriggerType"].isNull()) + jobInstanceDetailsItemObject.triggerType = std::stoi(dataNodeJobInstanceDetailsJobInstanceDetailsItem["TriggerType"].asString()); + data_.jobInstanceDetails.push_back(jobInstanceDetailsItemObject); + } + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::string GetJobInstanceListResult::getMessage()const +{ + return message_; +} + +GetJobInstanceListResult::Data GetJobInstanceListResult::getData()const +{ + return data_; +} + +int GetJobInstanceListResult::getCode()const +{ + return code_; +} + +bool GetJobInstanceListResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/GetJobInstanceRequest.cc b/schedulerx2/src/model/GetJobInstanceRequest.cc new file mode 100644 index 000000000..38126b9a4 --- /dev/null +++ b/schedulerx2/src/model/GetJobInstanceRequest.cc @@ -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 + +using AlibabaCloud::Schedulerx2::Model::GetJobInstanceRequest; + +GetJobInstanceRequest::GetJobInstanceRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "GetJobInstance") +{ + setMethod(HttpRequest::Method::Get); +} + +GetJobInstanceRequest::~GetJobInstanceRequest() +{} + +long GetJobInstanceRequest::getJobId()const +{ + return jobId_; +} + +void GetJobInstanceRequest::setJobId(long jobId) +{ + jobId_ = jobId; + setParameter("JobId", std::to_string(jobId)); +} + +std::string GetJobInstanceRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void GetJobInstanceRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setParameter("NamespaceSource", namespaceSource); +} + +std::string GetJobInstanceRequest::getGroupId()const +{ + return groupId_; +} + +void GetJobInstanceRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setParameter("GroupId", groupId); +} + +std::string GetJobInstanceRequest::get_Namespace()const +{ + return _namespace_; +} + +void GetJobInstanceRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setParameter("_Namespace", _namespace); +} + +long GetJobInstanceRequest::getJobInstanceId()const +{ + return jobInstanceId_; +} + +void GetJobInstanceRequest::setJobInstanceId(long jobInstanceId) +{ + jobInstanceId_ = jobInstanceId; + setParameter("JobInstanceId", std::to_string(jobInstanceId)); +} + diff --git a/schedulerx2/src/model/GetJobInstanceResult.cc b/schedulerx2/src/model/GetJobInstanceResult.cc new file mode 100644 index 000000000..d63c5f106 --- /dev/null +++ b/schedulerx2/src/model/GetJobInstanceResult.cc @@ -0,0 +1,98 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +GetJobInstanceResult::GetJobInstanceResult() : + ServiceResult() +{} + +GetJobInstanceResult::GetJobInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetJobInstanceResult::~GetJobInstanceResult() +{} + +void GetJobInstanceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + auto jobInstanceDetailNode = dataNode["JobInstanceDetail"]; + if(!jobInstanceDetailNode["InstanceId"].isNull()) + data_.jobInstanceDetail.instanceId = std::stol(jobInstanceDetailNode["InstanceId"].asString()); + if(!jobInstanceDetailNode["JobId"].isNull()) + data_.jobInstanceDetail.jobId = std::stol(jobInstanceDetailNode["JobId"].asString()); + if(!jobInstanceDetailNode["Status"].isNull()) + data_.jobInstanceDetail.status = std::stoi(jobInstanceDetailNode["Status"].asString()); + if(!jobInstanceDetailNode["StartTime"].isNull()) + data_.jobInstanceDetail.startTime = jobInstanceDetailNode["StartTime"].asString(); + if(!jobInstanceDetailNode["EndTime"].isNull()) + data_.jobInstanceDetail.endTime = jobInstanceDetailNode["EndTime"].asString(); + if(!jobInstanceDetailNode["ScheduleTime"].isNull()) + data_.jobInstanceDetail.scheduleTime = jobInstanceDetailNode["ScheduleTime"].asString(); + if(!jobInstanceDetailNode["DataTime"].isNull()) + data_.jobInstanceDetail.dataTime = jobInstanceDetailNode["DataTime"].asString(); + if(!jobInstanceDetailNode["Executor"].isNull()) + data_.jobInstanceDetail.executor = jobInstanceDetailNode["Executor"].asString(); + if(!jobInstanceDetailNode["WorkAddr"].isNull()) + data_.jobInstanceDetail.workAddr = jobInstanceDetailNode["WorkAddr"].asString(); + if(!jobInstanceDetailNode["Result"].isNull()) + data_.jobInstanceDetail.result = jobInstanceDetailNode["Result"].asString(); + if(!jobInstanceDetailNode["Progress"].isNull()) + data_.jobInstanceDetail.progress = jobInstanceDetailNode["Progress"].asString(); + if(!jobInstanceDetailNode["TimeType"].isNull()) + data_.jobInstanceDetail.timeType = std::stoi(jobInstanceDetailNode["TimeType"].asString()); + if(!jobInstanceDetailNode["TriggerType"].isNull()) + data_.jobInstanceDetail.triggerType = std::stoi(jobInstanceDetailNode["TriggerType"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::string GetJobInstanceResult::getMessage()const +{ + return message_; +} + +GetJobInstanceResult::Data GetJobInstanceResult::getData()const +{ + return data_; +} + +int GetJobInstanceResult::getCode()const +{ + return code_; +} + +bool GetJobInstanceResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/GrantPermissionRequest.cc b/schedulerx2/src/model/GrantPermissionRequest.cc new file mode 100644 index 000000000..14abcb128 --- /dev/null +++ b/schedulerx2/src/model/GrantPermissionRequest.cc @@ -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 + +using AlibabaCloud::Schedulerx2::Model::GrantPermissionRequest; + +GrantPermissionRequest::GrantPermissionRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "GrantPermission") +{ + setMethod(HttpRequest::Method::Post); +} + +GrantPermissionRequest::~GrantPermissionRequest() +{} + +std::string GrantPermissionRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void GrantPermissionRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setParameter("NamespaceSource", namespaceSource); +} + +std::string GrantPermissionRequest::getGroupId()const +{ + return groupId_; +} + +void GrantPermissionRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setParameter("GroupId", groupId); +} + +std::string GrantPermissionRequest::getUserId()const +{ + return userId_; +} + +void GrantPermissionRequest::setUserId(const std::string& userId) +{ + userId_ = userId; + setParameter("UserId", userId); +} + +bool GrantPermissionRequest::getGrantOption()const +{ + return grantOption_; +} + +void GrantPermissionRequest::setGrantOption(bool grantOption) +{ + grantOption_ = grantOption; + setParameter("GrantOption", grantOption ? "true" : "false"); +} + +std::string GrantPermissionRequest::get_Namespace()const +{ + return _namespace_; +} + +void GrantPermissionRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setParameter("_Namespace", _namespace); +} + +std::string GrantPermissionRequest::getUserName()const +{ + return userName_; +} + +void GrantPermissionRequest::setUserName(const std::string& userName) +{ + userName_ = userName; + setParameter("UserName", userName); +} + diff --git a/schedulerx2/src/model/GrantPermissionResult.cc b/schedulerx2/src/model/GrantPermissionResult.cc new file mode 100644 index 000000000..bab489b0b --- /dev/null +++ b/schedulerx2/src/model/GrantPermissionResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +GrantPermissionResult::GrantPermissionResult() : + ServiceResult() +{} + +GrantPermissionResult::GrantPermissionResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GrantPermissionResult::~GrantPermissionResult() +{} + +void GrantPermissionResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string GrantPermissionResult::getMessage()const +{ + return message_; +} + +int GrantPermissionResult::getCode()const +{ + return code_; +} + +bool GrantPermissionResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/RevokePermissionRequest.cc b/schedulerx2/src/model/RevokePermissionRequest.cc new file mode 100644 index 000000000..e8936f247 --- /dev/null +++ b/schedulerx2/src/model/RevokePermissionRequest.cc @@ -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 + +using AlibabaCloud::Schedulerx2::Model::RevokePermissionRequest; + +RevokePermissionRequest::RevokePermissionRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "RevokePermission") +{ + setMethod(HttpRequest::Method::Post); +} + +RevokePermissionRequest::~RevokePermissionRequest() +{} + +std::string RevokePermissionRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void RevokePermissionRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setParameter("NamespaceSource", namespaceSource); +} + +std::string RevokePermissionRequest::getGroupId()const +{ + return groupId_; +} + +void RevokePermissionRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setParameter("GroupId", groupId); +} + +std::string RevokePermissionRequest::get_Namespace()const +{ + return _namespace_; +} + +void RevokePermissionRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setParameter("_Namespace", _namespace); +} + +std::string RevokePermissionRequest::getUserId()const +{ + return userId_; +} + +void RevokePermissionRequest::setUserId(const std::string& userId) +{ + userId_ = userId; + setParameter("UserId", userId); +} + diff --git a/schedulerx2/src/model/RevokePermissionResult.cc b/schedulerx2/src/model/RevokePermissionResult.cc new file mode 100644 index 000000000..25c145897 --- /dev/null +++ b/schedulerx2/src/model/RevokePermissionResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +RevokePermissionResult::RevokePermissionResult() : + ServiceResult() +{} + +RevokePermissionResult::RevokePermissionResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RevokePermissionResult::~RevokePermissionResult() +{} + +void RevokePermissionResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string RevokePermissionResult::getMessage()const +{ + return message_; +} + +int RevokePermissionResult::getCode()const +{ + return code_; +} + +bool RevokePermissionResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/StopInstanceRequest.cc b/schedulerx2/src/model/StopInstanceRequest.cc new file mode 100644 index 000000000..6822b0271 --- /dev/null +++ b/schedulerx2/src/model/StopInstanceRequest.cc @@ -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 + +using AlibabaCloud::Schedulerx2::Model::StopInstanceRequest; + +StopInstanceRequest::StopInstanceRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "StopInstance") +{ + setMethod(HttpRequest::Method::Get); +} + +StopInstanceRequest::~StopInstanceRequest() +{} + +long StopInstanceRequest::getJobId()const +{ + return jobId_; +} + +void StopInstanceRequest::setJobId(long jobId) +{ + jobId_ = jobId; + setParameter("JobId", std::to_string(jobId)); +} + +std::string StopInstanceRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void StopInstanceRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setParameter("NamespaceSource", namespaceSource); +} + +long StopInstanceRequest::getInstanceId()const +{ + return instanceId_; +} + +void StopInstanceRequest::setInstanceId(long instanceId) +{ + instanceId_ = instanceId; + setParameter("InstanceId", std::to_string(instanceId)); +} + +std::string StopInstanceRequest::getGroupId()const +{ + return groupId_; +} + +void StopInstanceRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setParameter("GroupId", groupId); +} + +std::string StopInstanceRequest::get_Namespace()const +{ + return _namespace_; +} + +void StopInstanceRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setParameter("_Namespace", _namespace); +} + diff --git a/schedulerx2/src/model/StopInstanceResult.cc b/schedulerx2/src/model/StopInstanceResult.cc new file mode 100644 index 000000000..419030656 --- /dev/null +++ b/schedulerx2/src/model/StopInstanceResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +StopInstanceResult::StopInstanceResult() : + ServiceResult() +{} + +StopInstanceResult::StopInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +StopInstanceResult::~StopInstanceResult() +{} + +void StopInstanceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + +} + +std::string StopInstanceResult::getMessage()const +{ + return message_; +} + +int StopInstanceResult::getCode()const +{ + return code_; +} + +bool StopInstanceResult::getSuccess()const +{ + return success_; +} + diff --git a/schedulerx2/src/model/UpdateJobRequest.cc b/schedulerx2/src/model/UpdateJobRequest.cc new file mode 100644 index 000000000..24c718aac --- /dev/null +++ b/schedulerx2/src/model/UpdateJobRequest.cc @@ -0,0 +1,364 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::Schedulerx2::Model::UpdateJobRequest; + +UpdateJobRequest::UpdateJobRequest() : + RpcServiceRequest("schedulerx2", "2019-04-30", "UpdateJob") +{ + setMethod(HttpRequest::Method::Post); +} + +UpdateJobRequest::~UpdateJobRequest() +{} + +std::string UpdateJobRequest::getNamespaceSource()const +{ + return namespaceSource_; +} + +void UpdateJobRequest::setNamespaceSource(const std::string& namespaceSource) +{ + namespaceSource_ = namespaceSource; + setBodyParameter("NamespaceSource", namespaceSource); +} + +std::string UpdateJobRequest::getDescription()const +{ + return description_; +} + +void UpdateJobRequest::setDescription(const std::string& description) +{ + description_ = description; + setBodyParameter("Description", description); +} + +int UpdateJobRequest::getAttemptInterval()const +{ + return attemptInterval_; +} + +void UpdateJobRequest::setAttemptInterval(int attemptInterval) +{ + attemptInterval_ = attemptInterval; + setBodyParameter("AttemptInterval", std::to_string(attemptInterval)); +} + +std::string UpdateJobRequest::getContent()const +{ + return content_; +} + +void UpdateJobRequest::setContent(const std::string& content) +{ + content_ = content; + setBodyParameter("Content", content); +} + +long UpdateJobRequest::getTimeout()const +{ + return timeout_; +} + +void UpdateJobRequest::setTimeout(long timeout) +{ + timeout_ = timeout; + setBodyParameter("Timeout", std::to_string(timeout)); +} + +bool UpdateJobRequest::getTimeoutKillEnable()const +{ + return timeoutKillEnable_; +} + +void UpdateJobRequest::setTimeoutKillEnable(bool timeoutKillEnable) +{ + timeoutKillEnable_ = timeoutKillEnable; + setBodyParameter("TimeoutKillEnable", timeoutKillEnable ? "true" : "false"); +} + +long UpdateJobRequest::getJobId()const +{ + return jobId_; +} + +void UpdateJobRequest::setJobId(long jobId) +{ + jobId_ = jobId; + setBodyParameter("JobId", std::to_string(jobId)); +} + +int UpdateJobRequest::getPageSize()const +{ + return pageSize_; +} + +void UpdateJobRequest::setPageSize(int pageSize) +{ + pageSize_ = pageSize; + setBodyParameter("PageSize", std::to_string(pageSize)); +} + +int UpdateJobRequest::getConsumerSize()const +{ + return consumerSize_; +} + +void UpdateJobRequest::setConsumerSize(int consumerSize) +{ + consumerSize_ = consumerSize; + setBodyParameter("ConsumerSize", std::to_string(consumerSize)); +} + +std::string UpdateJobRequest::getJarUrl()const +{ + return jarUrl_; +} + +void UpdateJobRequest::setJarUrl(const std::string& jarUrl) +{ + jarUrl_ = jarUrl; + setBodyParameter("JarUrl", jarUrl); +} + +std::string UpdateJobRequest::getCalendar()const +{ + return calendar_; +} + +void UpdateJobRequest::setCalendar(const std::string& calendar) +{ + calendar_ = calendar; + setBodyParameter("Calendar", calendar); +} + +bool UpdateJobRequest::getFailEnable()const +{ + return failEnable_; +} + +void UpdateJobRequest::setFailEnable(bool failEnable) +{ + failEnable_ = failEnable; + setBodyParameter("FailEnable", failEnable ? "true" : "false"); +} + +std::string UpdateJobRequest::getSendChannel()const +{ + return sendChannel_; +} + +void UpdateJobRequest::setSendChannel(const std::string& sendChannel) +{ + sendChannel_ = sendChannel; + setBodyParameter("SendChannel", sendChannel); +} + +int UpdateJobRequest::getDataOffset()const +{ + return dataOffset_; +} + +void UpdateJobRequest::setDataOffset(int dataOffset) +{ + dataOffset_ = dataOffset; + setBodyParameter("DataOffset", std::to_string(dataOffset)); +} + +std::string UpdateJobRequest::getGroupId()const +{ + return groupId_; +} + +void UpdateJobRequest::setGroupId(const std::string& groupId) +{ + groupId_ = groupId; + setBodyParameter("GroupId", groupId); +} + +int UpdateJobRequest::getTaskMaxAttempt()const +{ + return taskMaxAttempt_; +} + +void UpdateJobRequest::setTaskMaxAttempt(int taskMaxAttempt) +{ + taskMaxAttempt_ = taskMaxAttempt; + setBodyParameter("TaskMaxAttempt", std::to_string(taskMaxAttempt)); +} + +int UpdateJobRequest::getMaxAttempt()const +{ + return maxAttempt_; +} + +void UpdateJobRequest::setMaxAttempt(int maxAttempt) +{ + maxAttempt_ = maxAttempt; + setBodyParameter("MaxAttempt", std::to_string(maxAttempt)); +} + +int UpdateJobRequest::getDispatcherSize()const +{ + return dispatcherSize_; +} + +void UpdateJobRequest::setDispatcherSize(int dispatcherSize) +{ + dispatcherSize_ = dispatcherSize; + setBodyParameter("DispatcherSize", std::to_string(dispatcherSize)); +} + +int UpdateJobRequest::getTaskAttemptInterval()const +{ + return taskAttemptInterval_; +} + +void UpdateJobRequest::setTaskAttemptInterval(int taskAttemptInterval) +{ + taskAttemptInterval_ = taskAttemptInterval; + setBodyParameter("TaskAttemptInterval", std::to_string(taskAttemptInterval)); +} + +std::string UpdateJobRequest::getExecuteMode()const +{ + return executeMode_; +} + +void UpdateJobRequest::setExecuteMode(const std::string& executeMode) +{ + executeMode_ = executeMode; + setBodyParameter("ExecuteMode", executeMode); +} + +int UpdateJobRequest::getQueueSize()const +{ + return queueSize_; +} + +void UpdateJobRequest::setQueueSize(int queueSize) +{ + queueSize_ = queueSize; + setBodyParameter("QueueSize", std::to_string(queueSize)); +} + +std::string UpdateJobRequest::getTimeExpression()const +{ + return timeExpression_; +} + +void UpdateJobRequest::setTimeExpression(const std::string& timeExpression) +{ + timeExpression_ = timeExpression; + setBodyParameter("TimeExpression", timeExpression); +} + +std::string UpdateJobRequest::getClassName()const +{ + return className_; +} + +void UpdateJobRequest::setClassName(const std::string& className) +{ + className_ = className; + setBodyParameter("ClassName", className); +} + +bool UpdateJobRequest::getTimeoutEnable()const +{ + return timeoutEnable_; +} + +void UpdateJobRequest::setTimeoutEnable(bool timeoutEnable) +{ + timeoutEnable_ = timeoutEnable; + setBodyParameter("TimeoutEnable", timeoutEnable ? "true" : "false"); +} + +std::vector UpdateJobRequest::getContactInfo()const +{ + return contactInfo_; +} + +void UpdateJobRequest::setContactInfo(const std::vector& contactInfo) +{ + contactInfo_ = contactInfo; + for(int dep1 = 0; dep1!= contactInfo.size(); dep1++) { + auto contactInfoObj = contactInfo.at(dep1); + std::string contactInfoObjStr = "ContactInfo." + std::to_string(dep1 + 1); + setParameter(contactInfoObjStr + ".UserPhone", contactInfoObj.userPhone); + setParameter(contactInfoObjStr + ".UserName", contactInfoObj.userName); + } +} + +std::string UpdateJobRequest::getName()const +{ + return name_; +} + +void UpdateJobRequest::setName(const std::string& name) +{ + name_ = name; + setBodyParameter("Name", name); +} + +std::string UpdateJobRequest::get_Namespace()const +{ + return _namespace_; +} + +void UpdateJobRequest::set_Namespace(const std::string& _namespace) +{ + _namespace_ = _namespace; + setBodyParameter("_Namespace", _namespace); +} + +int UpdateJobRequest::getMaxConcurrency()const +{ + return maxConcurrency_; +} + +void UpdateJobRequest::setMaxConcurrency(int maxConcurrency) +{ + maxConcurrency_ = maxConcurrency; + setBodyParameter("MaxConcurrency", std::to_string(maxConcurrency)); +} + +int UpdateJobRequest::getTimeType()const +{ + return timeType_; +} + +void UpdateJobRequest::setTimeType(int timeType) +{ + timeType_ = timeType; + setBodyParameter("TimeType", std::to_string(timeType)); +} + +std::string UpdateJobRequest::getParameters()const +{ + return parameters_; +} + +void UpdateJobRequest::setParameters(const std::string& parameters) +{ + parameters_ = parameters; + setBodyParameter("Parameters", parameters); +} + diff --git a/schedulerx2/src/model/UpdateJobResult.cc b/schedulerx2/src/model/UpdateJobResult.cc new file mode 100644 index 000000000..9d0444619 --- /dev/null +++ b/schedulerx2/src/model/UpdateJobResult.cc @@ -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 +#include + +using namespace AlibabaCloud::Schedulerx2; +using namespace AlibabaCloud::Schedulerx2::Model; + +UpdateJobResult::UpdateJobResult() : + ServiceResult() +{} + +UpdateJobResult::UpdateJobResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +UpdateJobResult::~UpdateJobResult() +{} + +void UpdateJobResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Code"].isNull()) + code_ = std::stoi(value["Code"].asString()); + if(!value["Success"].isNull()) + success_ = value["Success"].asString() == "true"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string UpdateJobResult::getMessage()const +{ + return message_; +} + +int UpdateJobResult::getCode()const +{ + return code_; +} + +bool UpdateJobResult::getSuccess()const +{ + return success_; +} +