diff --git a/VERSION b/VERSION index cc505a361..baba3c3c1 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.1572 \ No newline at end of file +1.36.1573 \ No newline at end of file diff --git a/computenest/CMakeLists.txt b/computenest/CMakeLists.txt new file mode 100644 index 000000000..97d8a4b52 --- /dev/null +++ b/computenest/CMakeLists.txt @@ -0,0 +1,110 @@ +# +# Copyright 2009-2017 Alibaba Cloud All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT 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(computenest_public_header + include/alibabacloud/computenest/ComputeNestClient.h + include/alibabacloud/computenest/ComputeNestExport.h ) + +set(computenest_public_header_model + include/alibabacloud/computenest/model/ContinueDeployServiceInstanceRequest.h + include/alibabacloud/computenest/model/ContinueDeployServiceInstanceResult.h + include/alibabacloud/computenest/model/CreateServiceInstanceRequest.h + include/alibabacloud/computenest/model/CreateServiceInstanceResult.h + include/alibabacloud/computenest/model/DeleteServiceInstancesRequest.h + include/alibabacloud/computenest/model/DeleteServiceInstancesResult.h + include/alibabacloud/computenest/model/GetServiceInstanceRequest.h + include/alibabacloud/computenest/model/GetServiceInstanceResult.h + include/alibabacloud/computenest/model/ListServiceInstanceLogsRequest.h + include/alibabacloud/computenest/model/ListServiceInstanceLogsResult.h + include/alibabacloud/computenest/model/ListServiceInstanceResourcesRequest.h + include/alibabacloud/computenest/model/ListServiceInstanceResourcesResult.h + include/alibabacloud/computenest/model/ListServiceInstancesRequest.h + include/alibabacloud/computenest/model/ListServiceInstancesResult.h ) + +set(computenest_src + src/ComputeNestClient.cc + src/model/ContinueDeployServiceInstanceRequest.cc + src/model/ContinueDeployServiceInstanceResult.cc + src/model/CreateServiceInstanceRequest.cc + src/model/CreateServiceInstanceResult.cc + src/model/DeleteServiceInstancesRequest.cc + src/model/DeleteServiceInstancesResult.cc + src/model/GetServiceInstanceRequest.cc + src/model/GetServiceInstanceResult.cc + src/model/ListServiceInstanceLogsRequest.cc + src/model/ListServiceInstanceLogsResult.cc + src/model/ListServiceInstanceResourcesRequest.cc + src/model/ListServiceInstanceResourcesResult.cc + src/model/ListServiceInstancesRequest.cc + src/model/ListServiceInstancesResult.cc ) + +add_library(computenest ${LIB_TYPE} + ${computenest_public_header} + ${computenest_public_header_model} + ${computenest_src}) + +set_target_properties(computenest + 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}computenest + ) + +if(${LIB_TYPE} STREQUAL "SHARED") + set_target_properties(computenest + PROPERTIES + DEFINE_SYMBOL ALIBABACLOUD_COMPUTENEST_LIBRARY) +endif() + +target_include_directories(computenest + PRIVATE include + ${CMAKE_SOURCE_DIR}/core/include + ) +target_link_libraries(computenest + core) + +if(CMAKE_HOST_WIN32) + ExternalProject_Get_Property(jsoncpp INSTALL_DIR) + set(jsoncpp_install_dir ${INSTALL_DIR}) + add_dependencies(computenest + jsoncpp) + target_include_directories(computenest + PRIVATE ${jsoncpp_install_dir}/include) + target_link_libraries(computenest + ${jsoncpp_install_dir}/lib/jsoncpp.lib) + set_target_properties(computenest + PROPERTIES + COMPILE_OPTIONS "/bigobj") +else() + target_include_directories(computenest + PRIVATE /usr/include/jsoncpp) + target_link_libraries(computenest + jsoncpp) +endif() + +install(FILES ${computenest_public_header} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/computenest) +install(FILES ${computenest_public_header_model} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/computenest/model) +install(TARGETS computenest + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + ) \ No newline at end of file diff --git a/computenest/include/alibabacloud/computenest/ComputeNestClient.h b/computenest/include/alibabacloud/computenest/ComputeNestClient.h new file mode 100644 index 000000000..fbab12bce --- /dev/null +++ b/computenest/include/alibabacloud/computenest/ComputeNestClient.h @@ -0,0 +1,102 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_COMPUTENEST_COMPUTENESTCLIENT_H_ +#define ALIBABACLOUD_COMPUTENEST_COMPUTENESTCLIENT_H_ + +#include +#include +#include +#include +#include "ComputeNestExport.h" +#include "model/ContinueDeployServiceInstanceRequest.h" +#include "model/ContinueDeployServiceInstanceResult.h" +#include "model/CreateServiceInstanceRequest.h" +#include "model/CreateServiceInstanceResult.h" +#include "model/DeleteServiceInstancesRequest.h" +#include "model/DeleteServiceInstancesResult.h" +#include "model/GetServiceInstanceRequest.h" +#include "model/GetServiceInstanceResult.h" +#include "model/ListServiceInstanceLogsRequest.h" +#include "model/ListServiceInstanceLogsResult.h" +#include "model/ListServiceInstanceResourcesRequest.h" +#include "model/ListServiceInstanceResourcesResult.h" +#include "model/ListServiceInstancesRequest.h" +#include "model/ListServiceInstancesResult.h" + + +namespace AlibabaCloud +{ + namespace ComputeNest + { + class ALIBABACLOUD_COMPUTENEST_EXPORT ComputeNestClient : public RpcServiceClient + { + public: + typedef Outcome ContinueDeployServiceInstanceOutcome; + typedef std::future ContinueDeployServiceInstanceOutcomeCallable; + typedef std::function&)> ContinueDeployServiceInstanceAsyncHandler; + typedef Outcome CreateServiceInstanceOutcome; + typedef std::future CreateServiceInstanceOutcomeCallable; + typedef std::function&)> CreateServiceInstanceAsyncHandler; + typedef Outcome DeleteServiceInstancesOutcome; + typedef std::future DeleteServiceInstancesOutcomeCallable; + typedef std::function&)> DeleteServiceInstancesAsyncHandler; + typedef Outcome GetServiceInstanceOutcome; + typedef std::future GetServiceInstanceOutcomeCallable; + typedef std::function&)> GetServiceInstanceAsyncHandler; + typedef Outcome ListServiceInstanceLogsOutcome; + typedef std::future ListServiceInstanceLogsOutcomeCallable; + typedef std::function&)> ListServiceInstanceLogsAsyncHandler; + typedef Outcome ListServiceInstanceResourcesOutcome; + typedef std::future ListServiceInstanceResourcesOutcomeCallable; + typedef std::function&)> ListServiceInstanceResourcesAsyncHandler; + typedef Outcome ListServiceInstancesOutcome; + typedef std::future ListServiceInstancesOutcomeCallable; + typedef std::function&)> ListServiceInstancesAsyncHandler; + + ComputeNestClient(const Credentials &credentials, const ClientConfiguration &configuration); + ComputeNestClient(const std::shared_ptr &credentialsProvider, const ClientConfiguration &configuration); + ComputeNestClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration); + ~ComputeNestClient(); + ContinueDeployServiceInstanceOutcome continueDeployServiceInstance(const Model::ContinueDeployServiceInstanceRequest &request)const; + void continueDeployServiceInstanceAsync(const Model::ContinueDeployServiceInstanceRequest& request, const ContinueDeployServiceInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ContinueDeployServiceInstanceOutcomeCallable continueDeployServiceInstanceCallable(const Model::ContinueDeployServiceInstanceRequest& request) const; + CreateServiceInstanceOutcome createServiceInstance(const Model::CreateServiceInstanceRequest &request)const; + void createServiceInstanceAsync(const Model::CreateServiceInstanceRequest& request, const CreateServiceInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateServiceInstanceOutcomeCallable createServiceInstanceCallable(const Model::CreateServiceInstanceRequest& request) const; + DeleteServiceInstancesOutcome deleteServiceInstances(const Model::DeleteServiceInstancesRequest &request)const; + void deleteServiceInstancesAsync(const Model::DeleteServiceInstancesRequest& request, const DeleteServiceInstancesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DeleteServiceInstancesOutcomeCallable deleteServiceInstancesCallable(const Model::DeleteServiceInstancesRequest& request) const; + GetServiceInstanceOutcome getServiceInstance(const Model::GetServiceInstanceRequest &request)const; + void getServiceInstanceAsync(const Model::GetServiceInstanceRequest& request, const GetServiceInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + GetServiceInstanceOutcomeCallable getServiceInstanceCallable(const Model::GetServiceInstanceRequest& request) const; + ListServiceInstanceLogsOutcome listServiceInstanceLogs(const Model::ListServiceInstanceLogsRequest &request)const; + void listServiceInstanceLogsAsync(const Model::ListServiceInstanceLogsRequest& request, const ListServiceInstanceLogsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListServiceInstanceLogsOutcomeCallable listServiceInstanceLogsCallable(const Model::ListServiceInstanceLogsRequest& request) const; + ListServiceInstanceResourcesOutcome listServiceInstanceResources(const Model::ListServiceInstanceResourcesRequest &request)const; + void listServiceInstanceResourcesAsync(const Model::ListServiceInstanceResourcesRequest& request, const ListServiceInstanceResourcesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListServiceInstanceResourcesOutcomeCallable listServiceInstanceResourcesCallable(const Model::ListServiceInstanceResourcesRequest& request) const; + ListServiceInstancesOutcome listServiceInstances(const Model::ListServiceInstancesRequest &request)const; + void listServiceInstancesAsync(const Model::ListServiceInstancesRequest& request, const ListServiceInstancesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + ListServiceInstancesOutcomeCallable listServiceInstancesCallable(const Model::ListServiceInstancesRequest& request) const; + + private: + std::shared_ptr endpointProvider_; + }; + } +} + +#endif // !ALIBABACLOUD_COMPUTENEST_COMPUTENESTCLIENT_H_ diff --git a/computenest/include/alibabacloud/computenest/ComputeNestExport.h b/computenest/include/alibabacloud/computenest/ComputeNestExport.h new file mode 100644 index 000000000..ab8e8cdef --- /dev/null +++ b/computenest/include/alibabacloud/computenest/ComputeNestExport.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_COMPUTENEST_COMPUTENESTEXPORT_H_ +#define ALIBABACLOUD_COMPUTENEST_COMPUTENESTEXPORT_H_ + +#include + +#if defined(ALIBABACLOUD_SHARED) +# if defined(ALIBABACLOUD_COMPUTENEST_LIBRARY) +# define ALIBABACLOUD_COMPUTENEST_EXPORT ALIBABACLOUD_DECL_EXPORT +# else +# define ALIBABACLOUD_COMPUTENEST_EXPORT ALIBABACLOUD_DECL_IMPORT +# endif +#else +# define ALIBABACLOUD_COMPUTENEST_EXPORT +#endif + +#endif // !ALIBABACLOUD_COMPUTENEST_COMPUTENESTEXPORT_H_ \ No newline at end of file diff --git a/computenest/include/alibabacloud/computenest/model/ContinueDeployServiceInstanceRequest.h b/computenest/include/alibabacloud/computenest/model/ContinueDeployServiceInstanceRequest.h new file mode 100644 index 000000000..6ae0befe2 --- /dev/null +++ b/computenest/include/alibabacloud/computenest/model/ContinueDeployServiceInstanceRequest.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_COMPUTENEST_MODEL_CONTINUEDEPLOYSERVICEINSTANCEREQUEST_H_ +#define ALIBABACLOUD_COMPUTENEST_MODEL_CONTINUEDEPLOYSERVICEINSTANCEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ComputeNest { +namespace Model { +class ALIBABACLOUD_COMPUTENEST_EXPORT ContinueDeployServiceInstanceRequest : public RpcServiceRequest { +public: + ContinueDeployServiceInstanceRequest(); + ~ContinueDeployServiceInstanceRequest(); + std::string getClientToken() const; + void setClientToken(const std::string &clientToken); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getServiceInstanceId() const; + void setServiceInstanceId(const std::string &serviceInstanceId); + bool getDryRun() const; + void setDryRun(bool dryRun); + std::string getParameters() const; + void setParameters(const std::string ¶meters); + std::vector getOption() const; + void setOption(const std::vector &option); + +private: + std::string clientToken_; + std::string regionId_; + std::string serviceInstanceId_; + bool dryRun_; + std::string parameters_; + std::vector option_; +}; +} // namespace Model +} // namespace ComputeNest +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_CONTINUEDEPLOYSERVICEINSTANCEREQUEST_H_ diff --git a/computenest/include/alibabacloud/computenest/model/ContinueDeployServiceInstanceResult.h b/computenest/include/alibabacloud/computenest/model/ContinueDeployServiceInstanceResult.h new file mode 100644 index 000000000..0dbac6f49 --- /dev/null +++ b/computenest/include/alibabacloud/computenest/model/ContinueDeployServiceInstanceResult.h @@ -0,0 +1,59 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_COMPUTENEST_MODEL_CONTINUEDEPLOYSERVICEINSTANCERESULT_H_ +#define ALIBABACLOUD_COMPUTENEST_MODEL_CONTINUEDEPLOYSERVICEINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ComputeNest + { + namespace Model + { + class ALIBABACLOUD_COMPUTENEST_EXPORT ContinueDeployServiceInstanceResult : public ServiceResult + { + public: + struct DryRunResult + { + std::vector parametersNotAllowedToBeModified; + std::vector parametersConditionallyAllowedToBeModified; + std::vector parametersAllowedToBeModified; + }; + + + ContinueDeployServiceInstanceResult(); + explicit ContinueDeployServiceInstanceResult(const std::string &payload); + ~ContinueDeployServiceInstanceResult(); + std::string getServiceInstanceId()const; + DryRunResult getDryRunResult()const; + + protected: + void parse(const std::string &payload); + private: + std::string serviceInstanceId_; + DryRunResult dryRunResult_; + + }; + } + } +} +#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_CONTINUEDEPLOYSERVICEINSTANCERESULT_H_ \ No newline at end of file diff --git a/computenest/include/alibabacloud/computenest/model/CreateServiceInstanceRequest.h b/computenest/include/alibabacloud/computenest/model/CreateServiceInstanceRequest.h new file mode 100644 index 000000000..572c69ea9 --- /dev/null +++ b/computenest/include/alibabacloud/computenest/model/CreateServiceInstanceRequest.h @@ -0,0 +1,111 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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_COMPUTENEST_MODEL_CREATESERVICEINSTANCEREQUEST_H_ +#define ALIBABACLOUD_COMPUTENEST_MODEL_CREATESERVICEINSTANCEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ComputeNest { +namespace Model { +class ALIBABACLOUD_COMPUTENEST_EXPORT CreateServiceInstanceRequest : public RpcServiceRequest { +public: + struct Commodity { + long payPeriod; + std::string payPeriodUnit; + }; + struct Tag { + std::string value; + std::string key; + }; + struct OperationMetadata { + std::string endTime; + std::string resources; + std::string startTime; + std::string extraInfo; + std::string serviceInstanceId; + }; + CreateServiceInstanceRequest(); + ~CreateServiceInstanceRequest(); + Commodity getCommodity() const; + void setCommodity(const Commodity &commodity); + std::string getContactGroup() const; + void setContactGroup(const std::string &contactGroup); + std::string getClientToken() const; + void setClientToken(const std::string &clientToken); + std::string getSpecificationCode() const; + void setSpecificationCode(const std::string &specificationCode); + std::string getResourceGroupId() const; + void setResourceGroupId(const std::string &resourceGroupId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + bool getEnableInstanceOps() const; + void setEnableInstanceOps(bool enableInstanceOps); + std::string getTemplateName() const; + void setTemplateName(const std::string &templateName); + std::vector getTag() const; + void setTag(const std::vector &tag); + bool getDryRun() const; + void setDryRun(bool dryRun); + bool getEnableUserPrometheus() const; + void setEnableUserPrometheus(bool enableUserPrometheus); + std::string getSpecificationName() const; + void setSpecificationName(const std::string &specificationName); + std::string getTrialType() const; + void setTrialType(const std::string &trialType); + std::string getName() const; + void setName(const std::string &name); + std::string getServiceVersion() const; + void setServiceVersion(const std::string &serviceVersion); + std::string getServiceId() const; + void setServiceId(const std::string &serviceId); + std::string getParameters() const; + void setParameters(const std::string ¶meters); + long getPayType() const; + void setPayType(long payType); + OperationMetadata getOperationMetadata() const; + void setOperationMetadata(const OperationMetadata &operationMetadata); + +private: + Commodity commodity_; + std::string contactGroup_; + std::string clientToken_; + std::string specificationCode_; + std::string resourceGroupId_; + std::string regionId_; + bool enableInstanceOps_; + std::string templateName_; + std::vector tag_; + bool dryRun_; + bool enableUserPrometheus_; + std::string specificationName_; + std::string trialType_; + std::string name_; + std::string serviceVersion_; + std::string serviceId_; + std::string parameters_; + long payType_; + OperationMetadata operationMetadata_; +}; +} // namespace Model +} // namespace ComputeNest +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_CREATESERVICEINSTANCEREQUEST_H_ diff --git a/computenest/include/alibabacloud/computenest/model/CreateServiceInstanceResult.h b/computenest/include/alibabacloud/computenest/model/CreateServiceInstanceResult.h new file mode 100644 index 000000000..3a3ffa610 --- /dev/null +++ b/computenest/include/alibabacloud/computenest/model/CreateServiceInstanceResult.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_COMPUTENEST_MODEL_CREATESERVICEINSTANCERESULT_H_ +#define ALIBABACLOUD_COMPUTENEST_MODEL_CREATESERVICEINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ComputeNest + { + namespace Model + { + class ALIBABACLOUD_COMPUTENEST_EXPORT CreateServiceInstanceResult : public ServiceResult + { + public: + + + CreateServiceInstanceResult(); + explicit CreateServiceInstanceResult(const std::string &payload); + ~CreateServiceInstanceResult(); + std::string getStatus()const; + std::string getServiceInstanceId()const; + std::string getMarketInstanceId()const; + + protected: + void parse(const std::string &payload); + private: + std::string status_; + std::string serviceInstanceId_; + std::string marketInstanceId_; + + }; + } + } +} +#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_CREATESERVICEINSTANCERESULT_H_ \ No newline at end of file diff --git a/computenest/include/alibabacloud/computenest/model/DeleteServiceInstancesRequest.h b/computenest/include/alibabacloud/computenest/model/DeleteServiceInstancesRequest.h new file mode 100644 index 000000000..8b90339b9 --- /dev/null +++ b/computenest/include/alibabacloud/computenest/model/DeleteServiceInstancesRequest.h @@ -0,0 +1,48 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_COMPUTENEST_MODEL_DELETESERVICEINSTANCESREQUEST_H_ +#define ALIBABACLOUD_COMPUTENEST_MODEL_DELETESERVICEINSTANCESREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ComputeNest { +namespace Model { +class ALIBABACLOUD_COMPUTENEST_EXPORT DeleteServiceInstancesRequest : public RpcServiceRequest { +public: + DeleteServiceInstancesRequest(); + ~DeleteServiceInstancesRequest(); + std::string getClientToken() const; + void setClientToken(const std::string &clientToken); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::vector getServiceInstanceId() const; + void setServiceInstanceId(const std::vector &serviceInstanceId); + +private: + std::string clientToken_; + std::string regionId_; + std::vector serviceInstanceId_; +}; +} // namespace Model +} // namespace ComputeNest +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_DELETESERVICEINSTANCESREQUEST_H_ diff --git a/computenest/include/alibabacloud/computenest/model/DeleteServiceInstancesResult.h b/computenest/include/alibabacloud/computenest/model/DeleteServiceInstancesResult.h new file mode 100644 index 000000000..afee6eb05 --- /dev/null +++ b/computenest/include/alibabacloud/computenest/model/DeleteServiceInstancesResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_COMPUTENEST_MODEL_DELETESERVICEINSTANCESRESULT_H_ +#define ALIBABACLOUD_COMPUTENEST_MODEL_DELETESERVICEINSTANCESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ComputeNest + { + namespace Model + { + class ALIBABACLOUD_COMPUTENEST_EXPORT DeleteServiceInstancesResult : public ServiceResult + { + public: + + + DeleteServiceInstancesResult(); + explicit DeleteServiceInstancesResult(const std::string &payload); + ~DeleteServiceInstancesResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_DELETESERVICEINSTANCESRESULT_H_ \ No newline at end of file diff --git a/computenest/include/alibabacloud/computenest/model/GetServiceInstanceRequest.h b/computenest/include/alibabacloud/computenest/model/GetServiceInstanceRequest.h new file mode 100644 index 000000000..84b99afe2 --- /dev/null +++ b/computenest/include/alibabacloud/computenest/model/GetServiceInstanceRequest.h @@ -0,0 +1,48 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_COMPUTENEST_MODEL_GETSERVICEINSTANCEREQUEST_H_ +#define ALIBABACLOUD_COMPUTENEST_MODEL_GETSERVICEINSTANCEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ComputeNest { +namespace Model { +class ALIBABACLOUD_COMPUTENEST_EXPORT GetServiceInstanceRequest : public RpcServiceRequest { +public: + GetServiceInstanceRequest(); + ~GetServiceInstanceRequest(); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getServiceInstanceId() const; + void setServiceInstanceId(const std::string &serviceInstanceId); + std::string getMarketInstanceId() const; + void setMarketInstanceId(const std::string &marketInstanceId); + +private: + std::string regionId_; + std::string serviceInstanceId_; + std::string marketInstanceId_; +}; +} // namespace Model +} // namespace ComputeNest +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_GETSERVICEINSTANCEREQUEST_H_ diff --git a/computenest/include/alibabacloud/computenest/model/GetServiceInstanceResult.h b/computenest/include/alibabacloud/computenest/model/GetServiceInstanceResult.h new file mode 100644 index 000000000..aec98ea34 --- /dev/null +++ b/computenest/include/alibabacloud/computenest/model/GetServiceInstanceResult.h @@ -0,0 +1,172 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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_COMPUTENEST_MODEL_GETSERVICEINSTANCERESULT_H_ +#define ALIBABACLOUD_COMPUTENEST_MODEL_GETSERVICEINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ComputeNest + { + namespace Model + { + class ALIBABACLOUD_COMPUTENEST_EXPORT GetServiceInstanceResult : public ServiceResult + { + public: + struct Service + { + struct ServiceInfo + { + std::string locale; + std::string image; + std::string name; + std::string shortDescription; + }; + std::string status; + std::string deployType; + std::vector upgradableServiceVersions; + std::string serviceId; + std::string deployMetadata; + std::string version; + std::string supplierName; + std::string serviceType; + std::vector serviceInfos; + std::string publishTime; + std::string versionName; + std::string serviceProductUrl; + std::string supplierUrl; + std::string upgradeMetadata; + std::string serviceDocUrl; + }; + struct NetworkConfig + { + struct PrivateVpcConnection + { + struct ConnectionConfig + { + std::vector securityGroups; + std::vector endpointIps; + std::string ingressEndpointStatus; + std::string vpcId; + std::string domainName; + std::string networkServiceStatus; + int connectBandwidth; + std::vector vSwitches; + std::string regionId; + }; + std::string privateZoneName; + std::vector connectionConfigs; + std::string endpointId; + std::string regionId; + std::string privateZoneId; + }; + struct ReversePrivateVpcConnection + { + std::string endpointId; + }; + std::vector reversePrivateVpcConnections; + std::string endpointId; + std::vector privateVpcConnections; + std::string privateZoneId; + }; + struct Tag + { + std::string value; + std::string key; + }; + + + GetServiceInstanceResult(); + explicit GetServiceInstanceResult(const std::string &payload); + ~GetServiceInstanceResult(); + std::string getOperatedServiceInstanceId()const; + std::string getEndTime()const; + std::string getResourceGroupId()const; + std::string getOperationEndTime()const; + bool getEnableInstanceOps()const; + std::string getPredefinedParameterName()const; + std::string getSource()const; + std::string getName()const; + std::string getComponents()const; + std::string getOperationStartTime()const; + std::string getServiceInstanceId()const; + std::string getServiceType()const; + std::string getTemplateName()const; + std::string getMarketInstanceId()const; + std::vector getTags()const; + std::string getStatus()const; + long getProgress()const; + std::string getParameters()const; + std::string getCreateTime()const; + NetworkConfig getNetworkConfig()const; + Service getService()const; + std::string getPayType()const; + std::string getLicenseEndTime()const; + long getUserId()const; + bool getEnableUserPrometheus()const; + std::string getStatusDetail()const; + std::string getOutputs()const; + std::string getUpdateTime()const; + bool getIsOperated()const; + long getSupplierUid()const; + std::string getResources()const; + + protected: + void parse(const std::string &payload); + private: + std::string operatedServiceInstanceId_; + std::string endTime_; + std::string resourceGroupId_; + std::string operationEndTime_; + bool enableInstanceOps_; + std::string predefinedParameterName_; + std::string source_; + std::string name_; + std::string components_; + std::string operationStartTime_; + std::string serviceInstanceId_; + std::string serviceType_; + std::string templateName_; + std::string marketInstanceId_; + std::vector tags_; + std::string status_; + long progress_; + std::string parameters_; + std::string createTime_; + NetworkConfig networkConfig_; + Service service_; + std::string payType_; + std::string licenseEndTime_; + long userId_; + bool enableUserPrometheus_; + std::string statusDetail_; + std::string outputs_; + std::string updateTime_; + bool isOperated_; + long supplierUid_; + std::string resources_; + + }; + } + } +} +#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_GETSERVICEINSTANCERESULT_H_ \ No newline at end of file diff --git a/computenest/include/alibabacloud/computenest/model/ListServiceInstanceLogsRequest.h b/computenest/include/alibabacloud/computenest/model/ListServiceInstanceLogsRequest.h new file mode 100644 index 000000000..3527c09de --- /dev/null +++ b/computenest/include/alibabacloud/computenest/model/ListServiceInstanceLogsRequest.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCELOGSREQUEST_H_ +#define ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCELOGSREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ComputeNest { +namespace Model { +class ALIBABACLOUD_COMPUTENEST_EXPORT ListServiceInstanceLogsRequest : public RpcServiceRequest { +public: + ListServiceInstanceLogsRequest(); + ~ListServiceInstanceLogsRequest(); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getNextToken() const; + void setNextToken(const std::string &nextToken); + std::string getServiceInstanceId() const; + void setServiceInstanceId(const std::string &serviceInstanceId); + std::string getMaxResults() const; + void setMaxResults(const std::string &maxResults); + +private: + std::string regionId_; + std::string nextToken_; + std::string serviceInstanceId_; + std::string maxResults_; +}; +} // namespace Model +} // namespace ComputeNest +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCELOGSREQUEST_H_ diff --git a/computenest/include/alibabacloud/computenest/model/ListServiceInstanceLogsResult.h b/computenest/include/alibabacloud/computenest/model/ListServiceInstanceLogsResult.h new file mode 100644 index 000000000..a6f54d20c --- /dev/null +++ b/computenest/include/alibabacloud/computenest/model/ListServiceInstanceLogsResult.h @@ -0,0 +1,66 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCELOGSRESULT_H_ +#define ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCELOGSRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ComputeNest + { + namespace Model + { + class ALIBABACLOUD_COMPUTENEST_EXPORT ListServiceInstanceLogsResult : public ServiceResult + { + public: + struct ServiceInstanceLogs + { + std::string status; + std::string serviceInstanceId; + std::string resourceId; + std::string content; + std::string logType; + std::string resourceType; + std::string timestamp; + std::string source; + }; + + + ListServiceInstanceLogsResult(); + explicit ListServiceInstanceLogsResult(const std::string &payload); + ~ListServiceInstanceLogsResult(); + std::string getNextToken()const; + std::string getMaxResults()const; + std::vector getServiceInstancesLogs()const; + + protected: + void parse(const std::string &payload); + private: + std::string nextToken_; + std::string maxResults_; + std::vector serviceInstancesLogs_; + + }; + } + } +} +#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCELOGSRESULT_H_ \ No newline at end of file diff --git a/computenest/include/alibabacloud/computenest/model/ListServiceInstanceResourcesRequest.h b/computenest/include/alibabacloud/computenest/model/ListServiceInstanceResourcesRequest.h new file mode 100644 index 000000000..c0a6c4fe2 --- /dev/null +++ b/computenest/include/alibabacloud/computenest/model/ListServiceInstanceResourcesRequest.h @@ -0,0 +1,70 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCERESOURCESREQUEST_H_ +#define ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCERESOURCESREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ComputeNest { +namespace Model { +class ALIBABACLOUD_COMPUTENEST_EXPORT ListServiceInstanceResourcesRequest : public RpcServiceRequest { +public: + struct Tag { + std::string value; + std::string key; + }; + ListServiceInstanceResourcesRequest(); + ~ListServiceInstanceResourcesRequest(); + std::string getExpireTimeEnd() const; + void setExpireTimeEnd(const std::string &expireTimeEnd); + std::string getNextToken() const; + void setNextToken(const std::string &nextToken); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::vector getResourceARN() const; + void setResourceARN(const std::vector &resourceARN); + std::vector getTag() const; + void setTag(const std::vector &tag); + std::string getServiceInstanceId() const; + void setServiceInstanceId(const std::string &serviceInstanceId); + std::string getExpireTimeStart() const; + void setExpireTimeStart(const std::string &expireTimeStart); + std::string getMaxResults() const; + void setMaxResults(const std::string &maxResults); + std::string getPayType() const; + void setPayType(const std::string &payType); + +private: + std::string expireTimeEnd_; + std::string nextToken_; + std::string regionId_; + std::vector resourceARN_; + std::vector tag_; + std::string serviceInstanceId_; + std::string expireTimeStart_; + std::string maxResults_; + std::string payType_; +}; +} // namespace Model +} // namespace ComputeNest +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCERESOURCESREQUEST_H_ diff --git a/computenest/include/alibabacloud/computenest/model/ListServiceInstanceResourcesResult.h b/computenest/include/alibabacloud/computenest/model/ListServiceInstanceResourcesResult.h new file mode 100644 index 000000000..ac38f6fe4 --- /dev/null +++ b/computenest/include/alibabacloud/computenest/model/ListServiceInstanceResourcesResult.h @@ -0,0 +1,67 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCERESOURCESRESULT_H_ +#define ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCERESOURCESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ComputeNest + { + namespace Model + { + class ALIBABACLOUD_COMPUTENEST_EXPORT ListServiceInstanceResourcesResult : public ServiceResult + { + public: + struct ResourcesItem + { + std::string resourceARN; + std::string productCode; + std::string renewalPeriodUnit; + std::string createTime; + std::string productType; + std::string payType; + std::string expireTime; + std::string renewStatus; + int renewalPeriod; + }; + + + ListServiceInstanceResourcesResult(); + explicit ListServiceInstanceResourcesResult(const std::string &payload); + ~ListServiceInstanceResourcesResult(); + std::string getNextToken()const; + std::string getMaxResults()const; + std::vector getResources()const; + + protected: + void parse(const std::string &payload); + private: + std::string nextToken_; + std::string maxResults_; + std::vector resources_; + + }; + } + } +} +#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCERESOURCESRESULT_H_ \ No newline at end of file diff --git a/computenest/include/alibabacloud/computenest/model/ListServiceInstancesRequest.h b/computenest/include/alibabacloud/computenest/model/ListServiceInstancesRequest.h new file mode 100644 index 000000000..b419b5738 --- /dev/null +++ b/computenest/include/alibabacloud/computenest/model/ListServiceInstancesRequest.h @@ -0,0 +1,64 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCESREQUEST_H_ +#define ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCESREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace ComputeNest { +namespace Model { +class ALIBABACLOUD_COMPUTENEST_EXPORT ListServiceInstancesRequest : public RpcServiceRequest { +public: + struct Tag { + std::string value; + std::string key; + }; + struct Filter { + std::string name; + }; + ListServiceInstancesRequest(); + ~ListServiceInstancesRequest(); + std::string getResourceGroupId() const; + void setResourceGroupId(const std::string &resourceGroupId); + std::string getRegionId() const; + void setRegionId(const std::string ®ionId); + std::string getNextToken() const; + void setNextToken(const std::string &nextToken); + std::vector getTag() const; + void setTag(const std::vector &tag); + std::vector getFilter() const; + void setFilter(const std::vector &filter); + std::string getMaxResults() const; + void setMaxResults(const std::string &maxResults); + +private: + std::string resourceGroupId_; + std::string regionId_; + std::string nextToken_; + std::vector tag_; + std::vector filter_; + std::string maxResults_; +}; +} // namespace Model +} // namespace ComputeNest +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCESREQUEST_H_ diff --git a/computenest/include/alibabacloud/computenest/model/ListServiceInstancesResult.h b/computenest/include/alibabacloud/computenest/model/ListServiceInstancesResult.h new file mode 100644 index 000000000..91483709c --- /dev/null +++ b/computenest/include/alibabacloud/computenest/model/ListServiceInstancesResult.h @@ -0,0 +1,108 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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_COMPUTENEST_MODEL_LISTSERVICEINSTANCESRESULT_H_ +#define ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace ComputeNest + { + namespace Model + { + class ALIBABACLOUD_COMPUTENEST_EXPORT ListServiceInstancesResult : public ServiceResult + { + public: + struct ServiceInstance + { + struct Service + { + struct ServiceInfo + { + std::string locale; + std::string image; + std::string name; + std::string shortDescription; + }; + std::string status; + std::string deployType; + std::string version; + std::string supplierName; + std::string serviceType; + std::vector serviceInfos; + std::string publishTime; + std::string versionName; + std::string supplierUrl; + std::string serviceId; + }; + struct Tag + { + std::string value; + std::string key; + }; + std::string status; + std::string operatedServiceInstanceId; + long progress; + std::string parameters; + std::string endTime; + std::string resourceGroupId; + std::string operationEndTime; + std::string createTime; + bool enableInstanceOps; + Service service; + std::string payType; + std::string source; + std::string name; + std::string operationStartTime; + std::string serviceInstanceId; + std::string serviceType; + std::string statusDetail; + std::string outputs; + std::string updateTime; + std::string templateName; + std::string resources; + std::string marketInstanceId; + std::vector tags; + }; + + + ListServiceInstancesResult(); + explicit ListServiceInstancesResult(const std::string &payload); + ~ListServiceInstancesResult(); + long getTotalCount()const; + std::vector getServiceInstances()const; + std::string getNextToken()const; + std::string getMaxResults()const; + + protected: + void parse(const std::string &payload); + private: + long totalCount_; + std::vector serviceInstances_; + std::string nextToken_; + std::string maxResults_; + + }; + } + } +} +#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCESRESULT_H_ \ No newline at end of file diff --git a/computenest/src/ComputeNestClient.cc b/computenest/src/ComputeNestClient.cc new file mode 100644 index 000000000..4604ecc62 --- /dev/null +++ b/computenest/src/ComputeNestClient.cc @@ -0,0 +1,305 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::ComputeNest; +using namespace AlibabaCloud::ComputeNest::Model; + +namespace +{ + const std::string SERVICE_NAME = "ComputeNest"; +} + +ComputeNestClient::ComputeNestClient(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, "computenest"); +} + +ComputeNestClient::ComputeNestClient(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, "computenest"); +} + +ComputeNestClient::ComputeNestClient(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, "computenest"); +} + +ComputeNestClient::~ComputeNestClient() +{} + +ComputeNestClient::ContinueDeployServiceInstanceOutcome ComputeNestClient::continueDeployServiceInstance(const ContinueDeployServiceInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ContinueDeployServiceInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ContinueDeployServiceInstanceOutcome(ContinueDeployServiceInstanceResult(outcome.result())); + else + return ContinueDeployServiceInstanceOutcome(outcome.error()); +} + +void ComputeNestClient::continueDeployServiceInstanceAsync(const ContinueDeployServiceInstanceRequest& request, const ContinueDeployServiceInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, continueDeployServiceInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ComputeNestClient::ContinueDeployServiceInstanceOutcomeCallable ComputeNestClient::continueDeployServiceInstanceCallable(const ContinueDeployServiceInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->continueDeployServiceInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ComputeNestClient::CreateServiceInstanceOutcome ComputeNestClient::createServiceInstance(const CreateServiceInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateServiceInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateServiceInstanceOutcome(CreateServiceInstanceResult(outcome.result())); + else + return CreateServiceInstanceOutcome(outcome.error()); +} + +void ComputeNestClient::createServiceInstanceAsync(const CreateServiceInstanceRequest& request, const CreateServiceInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createServiceInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ComputeNestClient::CreateServiceInstanceOutcomeCallable ComputeNestClient::createServiceInstanceCallable(const CreateServiceInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createServiceInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ComputeNestClient::DeleteServiceInstancesOutcome ComputeNestClient::deleteServiceInstances(const DeleteServiceInstancesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DeleteServiceInstancesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DeleteServiceInstancesOutcome(DeleteServiceInstancesResult(outcome.result())); + else + return DeleteServiceInstancesOutcome(outcome.error()); +} + +void ComputeNestClient::deleteServiceInstancesAsync(const DeleteServiceInstancesRequest& request, const DeleteServiceInstancesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, deleteServiceInstances(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ComputeNestClient::DeleteServiceInstancesOutcomeCallable ComputeNestClient::deleteServiceInstancesCallable(const DeleteServiceInstancesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->deleteServiceInstances(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ComputeNestClient::GetServiceInstanceOutcome ComputeNestClient::getServiceInstance(const GetServiceInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return GetServiceInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return GetServiceInstanceOutcome(GetServiceInstanceResult(outcome.result())); + else + return GetServiceInstanceOutcome(outcome.error()); +} + +void ComputeNestClient::getServiceInstanceAsync(const GetServiceInstanceRequest& request, const GetServiceInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, getServiceInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ComputeNestClient::GetServiceInstanceOutcomeCallable ComputeNestClient::getServiceInstanceCallable(const GetServiceInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->getServiceInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ComputeNestClient::ListServiceInstanceLogsOutcome ComputeNestClient::listServiceInstanceLogs(const ListServiceInstanceLogsRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListServiceInstanceLogsOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListServiceInstanceLogsOutcome(ListServiceInstanceLogsResult(outcome.result())); + else + return ListServiceInstanceLogsOutcome(outcome.error()); +} + +void ComputeNestClient::listServiceInstanceLogsAsync(const ListServiceInstanceLogsRequest& request, const ListServiceInstanceLogsAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listServiceInstanceLogs(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ComputeNestClient::ListServiceInstanceLogsOutcomeCallable ComputeNestClient::listServiceInstanceLogsCallable(const ListServiceInstanceLogsRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listServiceInstanceLogs(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ComputeNestClient::ListServiceInstanceResourcesOutcome ComputeNestClient::listServiceInstanceResources(const ListServiceInstanceResourcesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListServiceInstanceResourcesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListServiceInstanceResourcesOutcome(ListServiceInstanceResourcesResult(outcome.result())); + else + return ListServiceInstanceResourcesOutcome(outcome.error()); +} + +void ComputeNestClient::listServiceInstanceResourcesAsync(const ListServiceInstanceResourcesRequest& request, const ListServiceInstanceResourcesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listServiceInstanceResources(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ComputeNestClient::ListServiceInstanceResourcesOutcomeCallable ComputeNestClient::listServiceInstanceResourcesCallable(const ListServiceInstanceResourcesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listServiceInstanceResources(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + +ComputeNestClient::ListServiceInstancesOutcome ComputeNestClient::listServiceInstances(const ListServiceInstancesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return ListServiceInstancesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return ListServiceInstancesOutcome(ListServiceInstancesResult(outcome.result())); + else + return ListServiceInstancesOutcome(outcome.error()); +} + +void ComputeNestClient::listServiceInstancesAsync(const ListServiceInstancesRequest& request, const ListServiceInstancesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, listServiceInstances(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +ComputeNestClient::ListServiceInstancesOutcomeCallable ComputeNestClient::listServiceInstancesCallable(const ListServiceInstancesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->listServiceInstances(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + diff --git a/computenest/src/model/ContinueDeployServiceInstanceRequest.cc b/computenest/src/model/ContinueDeployServiceInstanceRequest.cc new file mode 100644 index 000000000..8a5fc00cb --- /dev/null +++ b/computenest/src/model/ContinueDeployServiceInstanceRequest.cc @@ -0,0 +1,80 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::ComputeNest::Model::ContinueDeployServiceInstanceRequest; + +ContinueDeployServiceInstanceRequest::ContinueDeployServiceInstanceRequest() + : RpcServiceRequest("computenest", "2021-06-01", "ContinueDeployServiceInstance") { + setMethod(HttpRequest::Method::Post); +} + +ContinueDeployServiceInstanceRequest::~ContinueDeployServiceInstanceRequest() {} + +std::string ContinueDeployServiceInstanceRequest::getClientToken() const { + return clientToken_; +} + +void ContinueDeployServiceInstanceRequest::setClientToken(const std::string &clientToken) { + clientToken_ = clientToken; + setParameter(std::string("ClientToken"), clientToken); +} + +std::string ContinueDeployServiceInstanceRequest::getRegionId() const { + return regionId_; +} + +void ContinueDeployServiceInstanceRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string ContinueDeployServiceInstanceRequest::getServiceInstanceId() const { + return serviceInstanceId_; +} + +void ContinueDeployServiceInstanceRequest::setServiceInstanceId(const std::string &serviceInstanceId) { + serviceInstanceId_ = serviceInstanceId; + setParameter(std::string("ServiceInstanceId"), serviceInstanceId); +} + +bool ContinueDeployServiceInstanceRequest::getDryRun() const { + return dryRun_; +} + +void ContinueDeployServiceInstanceRequest::setDryRun(bool dryRun) { + dryRun_ = dryRun; + setParameter(std::string("DryRun"), dryRun ? "true" : "false"); +} + +std::string ContinueDeployServiceInstanceRequest::getParameters() const { + return parameters_; +} + +void ContinueDeployServiceInstanceRequest::setParameters(const std::string ¶meters) { + parameters_ = parameters; + setParameter(std::string("Parameters"), parameters); +} + +std::vector ContinueDeployServiceInstanceRequest::getOption() const { + return option_; +} + +void ContinueDeployServiceInstanceRequest::setOption(const std::vector &option) { + option_ = option; +} + diff --git a/computenest/src/model/ContinueDeployServiceInstanceResult.cc b/computenest/src/model/ContinueDeployServiceInstanceResult.cc new file mode 100644 index 000000000..004d4b44b --- /dev/null +++ b/computenest/src/model/ContinueDeployServiceInstanceResult.cc @@ -0,0 +1,66 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::ComputeNest; +using namespace AlibabaCloud::ComputeNest::Model; + +ContinueDeployServiceInstanceResult::ContinueDeployServiceInstanceResult() : + ServiceResult() +{} + +ContinueDeployServiceInstanceResult::ContinueDeployServiceInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ContinueDeployServiceInstanceResult::~ContinueDeployServiceInstanceResult() +{} + +void ContinueDeployServiceInstanceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dryRunResultNode = value["DryRunResult"]; + auto allParametersNotAllowedToBeModified = dryRunResultNode["ParametersNotAllowedToBeModified"]["parameterNotAllowedToBeModified"]; + for (auto value : allParametersNotAllowedToBeModified) + dryRunResult_.parametersNotAllowedToBeModified.push_back(value.asString()); + auto allParametersConditionallyAllowedToBeModified = dryRunResultNode["ParametersConditionallyAllowedToBeModified"]["parameterConditionallyAllowedToBeModified"]; + for (auto value : allParametersConditionallyAllowedToBeModified) + dryRunResult_.parametersConditionallyAllowedToBeModified.push_back(value.asString()); + auto allParametersAllowedToBeModified = dryRunResultNode["ParametersAllowedToBeModified"]["parameterAllowedToBeModified"]; + for (auto value : allParametersAllowedToBeModified) + dryRunResult_.parametersAllowedToBeModified.push_back(value.asString()); + if(!value["ServiceInstanceId"].isNull()) + serviceInstanceId_ = value["ServiceInstanceId"].asString(); + +} + +std::string ContinueDeployServiceInstanceResult::getServiceInstanceId()const +{ + return serviceInstanceId_; +} + +ContinueDeployServiceInstanceResult::DryRunResult ContinueDeployServiceInstanceResult::getDryRunResult()const +{ + return dryRunResult_; +} + diff --git a/computenest/src/model/CreateServiceInstanceRequest.cc b/computenest/src/model/CreateServiceInstanceRequest.cc new file mode 100644 index 000000000..73fbb1423 --- /dev/null +++ b/computenest/src/model/CreateServiceInstanceRequest.cc @@ -0,0 +1,208 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::ComputeNest::Model::CreateServiceInstanceRequest; + +CreateServiceInstanceRequest::CreateServiceInstanceRequest() + : RpcServiceRequest("computenest", "2021-06-01", "CreateServiceInstance") { + setMethod(HttpRequest::Method::Post); +} + +CreateServiceInstanceRequest::~CreateServiceInstanceRequest() {} + +CreateServiceInstanceRequest::Commodity CreateServiceInstanceRequest::getCommodity() const { + return commodity_; +} + +void CreateServiceInstanceRequest::setCommodity(const CreateServiceInstanceRequest::Commodity &commodity) { + commodity_ = commodity; + setParameter(std::string("Commodity") + ".PayPeriod", std::to_string(commodity.payPeriod)); + setParameter(std::string("Commodity") + ".PayPeriodUnit", commodity.payPeriodUnit); +} + +std::string CreateServiceInstanceRequest::getContactGroup() const { + return contactGroup_; +} + +void CreateServiceInstanceRequest::setContactGroup(const std::string &contactGroup) { + contactGroup_ = contactGroup; + setParameter(std::string("ContactGroup"), contactGroup); +} + +std::string CreateServiceInstanceRequest::getClientToken() const { + return clientToken_; +} + +void CreateServiceInstanceRequest::setClientToken(const std::string &clientToken) { + clientToken_ = clientToken; + setParameter(std::string("ClientToken"), clientToken); +} + +std::string CreateServiceInstanceRequest::getSpecificationCode() const { + return specificationCode_; +} + +void CreateServiceInstanceRequest::setSpecificationCode(const std::string &specificationCode) { + specificationCode_ = specificationCode; + setParameter(std::string("SpecificationCode"), specificationCode); +} + +std::string CreateServiceInstanceRequest::getResourceGroupId() const { + return resourceGroupId_; +} + +void CreateServiceInstanceRequest::setResourceGroupId(const std::string &resourceGroupId) { + resourceGroupId_ = resourceGroupId; + setParameter(std::string("ResourceGroupId"), resourceGroupId); +} + +std::string CreateServiceInstanceRequest::getRegionId() const { + return regionId_; +} + +void CreateServiceInstanceRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +bool CreateServiceInstanceRequest::getEnableInstanceOps() const { + return enableInstanceOps_; +} + +void CreateServiceInstanceRequest::setEnableInstanceOps(bool enableInstanceOps) { + enableInstanceOps_ = enableInstanceOps; + setParameter(std::string("EnableInstanceOps"), enableInstanceOps ? "true" : "false"); +} + +std::string CreateServiceInstanceRequest::getTemplateName() const { + return templateName_; +} + +void CreateServiceInstanceRequest::setTemplateName(const std::string &templateName) { + templateName_ = templateName; + setParameter(std::string("TemplateName"), templateName); +} + +std::vector CreateServiceInstanceRequest::getTag() const { + return tag_; +} + +void CreateServiceInstanceRequest::setTag(const std::vector &tag) { + tag_ = tag; + for(int dep1 = 0; dep1 != tag.size(); dep1++) { + auto tagObj = tag.at(dep1); + std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1); + setParameter(tagObjStr + ".Value", tagObj.value); + setParameter(tagObjStr + ".Key", tagObj.key); + } +} + +bool CreateServiceInstanceRequest::getDryRun() const { + return dryRun_; +} + +void CreateServiceInstanceRequest::setDryRun(bool dryRun) { + dryRun_ = dryRun; + setParameter(std::string("DryRun"), dryRun ? "true" : "false"); +} + +bool CreateServiceInstanceRequest::getEnableUserPrometheus() const { + return enableUserPrometheus_; +} + +void CreateServiceInstanceRequest::setEnableUserPrometheus(bool enableUserPrometheus) { + enableUserPrometheus_ = enableUserPrometheus; + setParameter(std::string("EnableUserPrometheus"), enableUserPrometheus ? "true" : "false"); +} + +std::string CreateServiceInstanceRequest::getSpecificationName() const { + return specificationName_; +} + +void CreateServiceInstanceRequest::setSpecificationName(const std::string &specificationName) { + specificationName_ = specificationName; + setParameter(std::string("SpecificationName"), specificationName); +} + +std::string CreateServiceInstanceRequest::getTrialType() const { + return trialType_; +} + +void CreateServiceInstanceRequest::setTrialType(const std::string &trialType) { + trialType_ = trialType; + setParameter(std::string("TrialType"), trialType); +} + +std::string CreateServiceInstanceRequest::getName() const { + return name_; +} + +void CreateServiceInstanceRequest::setName(const std::string &name) { + name_ = name; + setParameter(std::string("Name"), name); +} + +std::string CreateServiceInstanceRequest::getServiceVersion() const { + return serviceVersion_; +} + +void CreateServiceInstanceRequest::setServiceVersion(const std::string &serviceVersion) { + serviceVersion_ = serviceVersion; + setParameter(std::string("ServiceVersion"), serviceVersion); +} + +std::string CreateServiceInstanceRequest::getServiceId() const { + return serviceId_; +} + +void CreateServiceInstanceRequest::setServiceId(const std::string &serviceId) { + serviceId_ = serviceId; + setParameter(std::string("ServiceId"), serviceId); +} + +std::string CreateServiceInstanceRequest::getParameters() const { + return parameters_; +} + +void CreateServiceInstanceRequest::setParameters(const std::string ¶meters) { + parameters_ = parameters; + setParameter(std::string("Parameters"), parameters); +} + +long CreateServiceInstanceRequest::getPayType() const { + return payType_; +} + +void CreateServiceInstanceRequest::setPayType(long payType) { + payType_ = payType; + setParameter(std::string("PayType"), std::to_string(payType)); +} + +CreateServiceInstanceRequest::OperationMetadata CreateServiceInstanceRequest::getOperationMetadata() const { + return operationMetadata_; +} + +void CreateServiceInstanceRequest::setOperationMetadata(const CreateServiceInstanceRequest::OperationMetadata &operationMetadata) { + operationMetadata_ = operationMetadata; + setParameter(std::string("OperationMetadata") + ".EndTime", operationMetadata.endTime); + setParameter(std::string("OperationMetadata") + ".Resources", operationMetadata.resources); + setParameter(std::string("OperationMetadata") + ".StartTime", operationMetadata.startTime); + setParameter(std::string("OperationMetadata") + ".ExtraInfo", operationMetadata.extraInfo); + setParameter(std::string("OperationMetadata") + ".ServiceInstanceId", operationMetadata.serviceInstanceId); +} + diff --git a/computenest/src/model/CreateServiceInstanceResult.cc b/computenest/src/model/CreateServiceInstanceResult.cc new file mode 100644 index 000000000..180efe073 --- /dev/null +++ b/computenest/src/model/CreateServiceInstanceResult.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::ComputeNest; +using namespace AlibabaCloud::ComputeNest::Model; + +CreateServiceInstanceResult::CreateServiceInstanceResult() : + ServiceResult() +{} + +CreateServiceInstanceResult::CreateServiceInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateServiceInstanceResult::~CreateServiceInstanceResult() +{} + +void CreateServiceInstanceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + if(!value["Status"].isNull()) + status_ = value["Status"].asString(); + if(!value["ServiceInstanceId"].isNull()) + serviceInstanceId_ = value["ServiceInstanceId"].asString(); + if(!value["MarketInstanceId"].isNull()) + marketInstanceId_ = value["MarketInstanceId"].asString(); + +} + +std::string CreateServiceInstanceResult::getStatus()const +{ + return status_; +} + +std::string CreateServiceInstanceResult::getServiceInstanceId()const +{ + return serviceInstanceId_; +} + +std::string CreateServiceInstanceResult::getMarketInstanceId()const +{ + return marketInstanceId_; +} + diff --git a/computenest/src/model/DeleteServiceInstancesRequest.cc b/computenest/src/model/DeleteServiceInstancesRequest.cc new file mode 100644 index 000000000..826650d5f --- /dev/null +++ b/computenest/src/model/DeleteServiceInstancesRequest.cc @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::ComputeNest::Model::DeleteServiceInstancesRequest; + +DeleteServiceInstancesRequest::DeleteServiceInstancesRequest() + : RpcServiceRequest("computenest", "2021-06-01", "DeleteServiceInstances") { + setMethod(HttpRequest::Method::Post); +} + +DeleteServiceInstancesRequest::~DeleteServiceInstancesRequest() {} + +std::string DeleteServiceInstancesRequest::getClientToken() const { + return clientToken_; +} + +void DeleteServiceInstancesRequest::setClientToken(const std::string &clientToken) { + clientToken_ = clientToken; + setParameter(std::string("ClientToken"), clientToken); +} + +std::string DeleteServiceInstancesRequest::getRegionId() const { + return regionId_; +} + +void DeleteServiceInstancesRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::vector DeleteServiceInstancesRequest::getServiceInstanceId() const { + return serviceInstanceId_; +} + +void DeleteServiceInstancesRequest::setServiceInstanceId(const std::vector &serviceInstanceId) { + serviceInstanceId_ = serviceInstanceId; +} + diff --git a/computenest/src/model/DeleteServiceInstancesResult.cc b/computenest/src/model/DeleteServiceInstancesResult.cc new file mode 100644 index 000000000..49ca10009 --- /dev/null +++ b/computenest/src/model/DeleteServiceInstancesResult.cc @@ -0,0 +1,44 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::ComputeNest; +using namespace AlibabaCloud::ComputeNest::Model; + +DeleteServiceInstancesResult::DeleteServiceInstancesResult() : + ServiceResult() +{} + +DeleteServiceInstancesResult::DeleteServiceInstancesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DeleteServiceInstancesResult::~DeleteServiceInstancesResult() +{} + +void DeleteServiceInstancesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/computenest/src/model/GetServiceInstanceRequest.cc b/computenest/src/model/GetServiceInstanceRequest.cc new file mode 100644 index 000000000..045ff177b --- /dev/null +++ b/computenest/src/model/GetServiceInstanceRequest.cc @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::ComputeNest::Model::GetServiceInstanceRequest; + +GetServiceInstanceRequest::GetServiceInstanceRequest() + : RpcServiceRequest("computenest", "2021-06-01", "GetServiceInstance") { + setMethod(HttpRequest::Method::Post); +} + +GetServiceInstanceRequest::~GetServiceInstanceRequest() {} + +std::string GetServiceInstanceRequest::getRegionId() const { + return regionId_; +} + +void GetServiceInstanceRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string GetServiceInstanceRequest::getServiceInstanceId() const { + return serviceInstanceId_; +} + +void GetServiceInstanceRequest::setServiceInstanceId(const std::string &serviceInstanceId) { + serviceInstanceId_ = serviceInstanceId; + setParameter(std::string("ServiceInstanceId"), serviceInstanceId); +} + +std::string GetServiceInstanceRequest::getMarketInstanceId() const { + return marketInstanceId_; +} + +void GetServiceInstanceRequest::setMarketInstanceId(const std::string &marketInstanceId) { + marketInstanceId_ = marketInstanceId; + setParameter(std::string("MarketInstanceId"), marketInstanceId); +} + diff --git a/computenest/src/model/GetServiceInstanceResult.cc b/computenest/src/model/GetServiceInstanceResult.cc new file mode 100644 index 000000000..f9c5b35d9 --- /dev/null +++ b/computenest/src/model/GetServiceInstanceResult.cc @@ -0,0 +1,363 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::ComputeNest; +using namespace AlibabaCloud::ComputeNest::Model; + +GetServiceInstanceResult::GetServiceInstanceResult() : + ServiceResult() +{} + +GetServiceInstanceResult::GetServiceInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +GetServiceInstanceResult::~GetServiceInstanceResult() +{} + +void GetServiceInstanceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allTagsNode = value["Tags"]["Tag"]; + for (auto valueTagsTag : allTagsNode) + { + Tag tagsObject; + if(!valueTagsTag["Key"].isNull()) + tagsObject.key = valueTagsTag["Key"].asString(); + if(!valueTagsTag["Value"].isNull()) + tagsObject.value = valueTagsTag["Value"].asString(); + tags_.push_back(tagsObject); + } + auto serviceNode = value["Service"]; + if(!serviceNode["Status"].isNull()) + service_.status = serviceNode["Status"].asString(); + if(!serviceNode["PublishTime"].isNull()) + service_.publishTime = serviceNode["PublishTime"].asString(); + if(!serviceNode["Version"].isNull()) + service_.version = serviceNode["Version"].asString(); + if(!serviceNode["DeployMetadata"].isNull()) + service_.deployMetadata = serviceNode["DeployMetadata"].asString(); + if(!serviceNode["DeployType"].isNull()) + service_.deployType = serviceNode["DeployType"].asString(); + if(!serviceNode["ServiceId"].isNull()) + service_.serviceId = serviceNode["ServiceId"].asString(); + if(!serviceNode["SupplierUrl"].isNull()) + service_.supplierUrl = serviceNode["SupplierUrl"].asString(); + if(!serviceNode["ServiceType"].isNull()) + service_.serviceType = serviceNode["ServiceType"].asString(); + if(!serviceNode["SupplierName"].isNull()) + service_.supplierName = serviceNode["SupplierName"].asString(); + if(!serviceNode["VersionName"].isNull()) + service_.versionName = serviceNode["VersionName"].asString(); + if(!serviceNode["UpgradeMetadata"].isNull()) + service_.upgradeMetadata = serviceNode["UpgradeMetadata"].asString(); + if(!serviceNode["ServiceProductUrl"].isNull()) + service_.serviceProductUrl = serviceNode["ServiceProductUrl"].asString(); + if(!serviceNode["ServiceDocUrl"].isNull()) + service_.serviceDocUrl = serviceNode["ServiceDocUrl"].asString(); + auto allServiceInfosNode = serviceNode["ServiceInfos"]["ServiceInfo"]; + for (auto serviceNodeServiceInfosServiceInfo : allServiceInfosNode) + { + Service::ServiceInfo serviceInfoObject; + if(!serviceNodeServiceInfosServiceInfo["Locale"].isNull()) + serviceInfoObject.locale = serviceNodeServiceInfosServiceInfo["Locale"].asString(); + if(!serviceNodeServiceInfosServiceInfo["Image"].isNull()) + serviceInfoObject.image = serviceNodeServiceInfosServiceInfo["Image"].asString(); + if(!serviceNodeServiceInfosServiceInfo["Name"].isNull()) + serviceInfoObject.name = serviceNodeServiceInfosServiceInfo["Name"].asString(); + if(!serviceNodeServiceInfosServiceInfo["ShortDescription"].isNull()) + serviceInfoObject.shortDescription = serviceNodeServiceInfosServiceInfo["ShortDescription"].asString(); + service_.serviceInfos.push_back(serviceInfoObject); + } + auto allUpgradableServiceVersions = serviceNode["UpgradableServiceVersions"]["UpgradableServiceVersion"]; + for (auto value : allUpgradableServiceVersions) + service_.upgradableServiceVersions.push_back(value.asString()); + auto networkConfigNode = value["NetworkConfig"]; + if(!networkConfigNode["EndpointId"].isNull()) + networkConfig_.endpointId = networkConfigNode["EndpointId"].asString(); + if(!networkConfigNode["PrivateZoneId"].isNull()) + networkConfig_.privateZoneId = networkConfigNode["PrivateZoneId"].asString(); + auto allPrivateVpcConnectionsNode = networkConfigNode["PrivateVpcConnections"]["PrivateVpcConnection"]; + for (auto networkConfigNodePrivateVpcConnectionsPrivateVpcConnection : allPrivateVpcConnectionsNode) + { + NetworkConfig::PrivateVpcConnection privateVpcConnectionObject; + if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["EndpointId"].isNull()) + privateVpcConnectionObject.endpointId = networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["EndpointId"].asString(); + if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["PrivateZoneId"].isNull()) + privateVpcConnectionObject.privateZoneId = networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["PrivateZoneId"].asString(); + if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["PrivateZoneName"].isNull()) + privateVpcConnectionObject.privateZoneName = networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["PrivateZoneName"].asString(); + if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["RegionId"].isNull()) + privateVpcConnectionObject.regionId = networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["RegionId"].asString(); + auto allConnectionConfigsNode = networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["ConnectionConfigs"]["ConnectionConfig"]; + for (auto networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig : allConnectionConfigsNode) + { + NetworkConfig::PrivateVpcConnection::ConnectionConfig connectionConfigsObject; + if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["VpcId"].isNull()) + connectionConfigsObject.vpcId = networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["VpcId"].asString(); + if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["IngressEndpointStatus"].isNull()) + connectionConfigsObject.ingressEndpointStatus = networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["IngressEndpointStatus"].asString(); + if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["NetworkServiceStatus"].isNull()) + connectionConfigsObject.networkServiceStatus = networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["NetworkServiceStatus"].asString(); + if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["DomainName"].isNull()) + connectionConfigsObject.domainName = networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["DomainName"].asString(); + if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["RegionId"].isNull()) + connectionConfigsObject.regionId = networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["RegionId"].asString(); + if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["ConnectBandwidth"].isNull()) + connectionConfigsObject.connectBandwidth = std::stoi(networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["ConnectBandwidth"].asString()); + auto allSecurityGroups = value["SecurityGroups"]["SecurityGroup"]; + for (auto value : allSecurityGroups) + connectionConfigsObject.securityGroups.push_back(value.asString()); + auto allVSwitches = value["VSwitches"]["VSwitch"]; + for (auto value : allVSwitches) + connectionConfigsObject.vSwitches.push_back(value.asString()); + auto allEndpointIps = value["EndpointIps"]["EndpointIp"]; + for (auto value : allEndpointIps) + connectionConfigsObject.endpointIps.push_back(value.asString()); + privateVpcConnectionObject.connectionConfigs.push_back(connectionConfigsObject); + } + networkConfig_.privateVpcConnections.push_back(privateVpcConnectionObject); + } + auto allReversePrivateVpcConnectionsNode = networkConfigNode["ReversePrivateVpcConnections"]["ReversePrivateVpcConnection"]; + for (auto networkConfigNodeReversePrivateVpcConnectionsReversePrivateVpcConnection : allReversePrivateVpcConnectionsNode) + { + NetworkConfig::ReversePrivateVpcConnection reversePrivateVpcConnectionObject; + if(!networkConfigNodeReversePrivateVpcConnectionsReversePrivateVpcConnection["EndpointId"].isNull()) + reversePrivateVpcConnectionObject.endpointId = networkConfigNodeReversePrivateVpcConnectionsReversePrivateVpcConnection["EndpointId"].asString(); + networkConfig_.reversePrivateVpcConnections.push_back(reversePrivateVpcConnectionObject); + } + if(!value["Outputs"].isNull()) + outputs_ = value["Outputs"].asString(); + if(!value["Status"].isNull()) + status_ = value["Status"].asString(); + if(!value["TemplateName"].isNull()) + templateName_ = value["TemplateName"].asString(); + if(!value["UpdateTime"].isNull()) + updateTime_ = value["UpdateTime"].asString(); + if(!value["Progress"].isNull()) + progress_ = std::stol(value["Progress"].asString()); + if(!value["Parameters"].isNull()) + parameters_ = value["Parameters"].asString(); + if(!value["ServiceInstanceId"].isNull()) + serviceInstanceId_ = value["ServiceInstanceId"].asString(); + if(!value["CreateTime"].isNull()) + createTime_ = value["CreateTime"].asString(); + if(!value["StatusDetail"].isNull()) + statusDetail_ = value["StatusDetail"].asString(); + if(!value["Resources"].isNull()) + resources_ = value["Resources"].asString(); + if(!value["OperationStartTime"].isNull()) + operationStartTime_ = value["OperationStartTime"].asString(); + if(!value["OperationEndTime"].isNull()) + operationEndTime_ = value["OperationEndTime"].asString(); + if(!value["OperatedServiceInstanceId"].isNull()) + operatedServiceInstanceId_ = value["OperatedServiceInstanceId"].asString(); + if(!value["EnableInstanceOps"].isNull()) + enableInstanceOps_ = value["EnableInstanceOps"].asString() == "true"; + if(!value["IsOperated"].isNull()) + isOperated_ = value["IsOperated"].asString() == "true"; + if(!value["LicenseEndTime"].isNull()) + licenseEndTime_ = value["LicenseEndTime"].asString(); + if(!value["UserId"].isNull()) + userId_ = std::stol(value["UserId"].asString()); + if(!value["SupplierUid"].isNull()) + supplierUid_ = std::stol(value["SupplierUid"].asString()); + if(!value["EndTime"].isNull()) + endTime_ = value["EndTime"].asString(); + if(!value["Source"].isNull()) + source_ = value["Source"].asString(); + if(!value["ServiceType"].isNull()) + serviceType_ = value["ServiceType"].asString(); + if(!value["PayType"].isNull()) + payType_ = value["PayType"].asString(); + if(!value["Name"].isNull()) + name_ = value["Name"].asString(); + if(!value["EnableUserPrometheus"].isNull()) + enableUserPrometheus_ = value["EnableUserPrometheus"].asString() == "true"; + if(!value["Components"].isNull()) + components_ = value["Components"].asString(); + if(!value["PredefinedParameterName"].isNull()) + predefinedParameterName_ = value["PredefinedParameterName"].asString(); + if(!value["MarketInstanceId"].isNull()) + marketInstanceId_ = value["MarketInstanceId"].asString(); + if(!value["ResourceGroupId"].isNull()) + resourceGroupId_ = value["ResourceGroupId"].asString(); + +} + +std::string GetServiceInstanceResult::getOperatedServiceInstanceId()const +{ + return operatedServiceInstanceId_; +} + +std::string GetServiceInstanceResult::getEndTime()const +{ + return endTime_; +} + +std::string GetServiceInstanceResult::getResourceGroupId()const +{ + return resourceGroupId_; +} + +std::string GetServiceInstanceResult::getOperationEndTime()const +{ + return operationEndTime_; +} + +bool GetServiceInstanceResult::getEnableInstanceOps()const +{ + return enableInstanceOps_; +} + +std::string GetServiceInstanceResult::getPredefinedParameterName()const +{ + return predefinedParameterName_; +} + +std::string GetServiceInstanceResult::getSource()const +{ + return source_; +} + +std::string GetServiceInstanceResult::getName()const +{ + return name_; +} + +std::string GetServiceInstanceResult::getComponents()const +{ + return components_; +} + +std::string GetServiceInstanceResult::getOperationStartTime()const +{ + return operationStartTime_; +} + +std::string GetServiceInstanceResult::getServiceInstanceId()const +{ + return serviceInstanceId_; +} + +std::string GetServiceInstanceResult::getServiceType()const +{ + return serviceType_; +} + +std::string GetServiceInstanceResult::getTemplateName()const +{ + return templateName_; +} + +std::string GetServiceInstanceResult::getMarketInstanceId()const +{ + return marketInstanceId_; +} + +std::vector GetServiceInstanceResult::getTags()const +{ + return tags_; +} + +std::string GetServiceInstanceResult::getStatus()const +{ + return status_; +} + +long GetServiceInstanceResult::getProgress()const +{ + return progress_; +} + +std::string GetServiceInstanceResult::getParameters()const +{ + return parameters_; +} + +std::string GetServiceInstanceResult::getCreateTime()const +{ + return createTime_; +} + +GetServiceInstanceResult::NetworkConfig GetServiceInstanceResult::getNetworkConfig()const +{ + return networkConfig_; +} + +GetServiceInstanceResult::Service GetServiceInstanceResult::getService()const +{ + return service_; +} + +std::string GetServiceInstanceResult::getPayType()const +{ + return payType_; +} + +std::string GetServiceInstanceResult::getLicenseEndTime()const +{ + return licenseEndTime_; +} + +long GetServiceInstanceResult::getUserId()const +{ + return userId_; +} + +bool GetServiceInstanceResult::getEnableUserPrometheus()const +{ + return enableUserPrometheus_; +} + +std::string GetServiceInstanceResult::getStatusDetail()const +{ + return statusDetail_; +} + +std::string GetServiceInstanceResult::getOutputs()const +{ + return outputs_; +} + +std::string GetServiceInstanceResult::getUpdateTime()const +{ + return updateTime_; +} + +bool GetServiceInstanceResult::getIsOperated()const +{ + return isOperated_; +} + +long GetServiceInstanceResult::getSupplierUid()const +{ + return supplierUid_; +} + +std::string GetServiceInstanceResult::getResources()const +{ + return resources_; +} + diff --git a/computenest/src/model/ListServiceInstanceLogsRequest.cc b/computenest/src/model/ListServiceInstanceLogsRequest.cc new file mode 100644 index 000000000..d560a28e6 --- /dev/null +++ b/computenest/src/model/ListServiceInstanceLogsRequest.cc @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::ComputeNest::Model::ListServiceInstanceLogsRequest; + +ListServiceInstanceLogsRequest::ListServiceInstanceLogsRequest() + : RpcServiceRequest("computenest", "2021-06-01", "ListServiceInstanceLogs") { + setMethod(HttpRequest::Method::Post); +} + +ListServiceInstanceLogsRequest::~ListServiceInstanceLogsRequest() {} + +std::string ListServiceInstanceLogsRequest::getRegionId() const { + return regionId_; +} + +void ListServiceInstanceLogsRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string ListServiceInstanceLogsRequest::getNextToken() const { + return nextToken_; +} + +void ListServiceInstanceLogsRequest::setNextToken(const std::string &nextToken) { + nextToken_ = nextToken; + setParameter(std::string("NextToken"), nextToken); +} + +std::string ListServiceInstanceLogsRequest::getServiceInstanceId() const { + return serviceInstanceId_; +} + +void ListServiceInstanceLogsRequest::setServiceInstanceId(const std::string &serviceInstanceId) { + serviceInstanceId_ = serviceInstanceId; + setParameter(std::string("ServiceInstanceId"), serviceInstanceId); +} + +std::string ListServiceInstanceLogsRequest::getMaxResults() const { + return maxResults_; +} + +void ListServiceInstanceLogsRequest::setMaxResults(const std::string &maxResults) { + maxResults_ = maxResults; + setParameter(std::string("MaxResults"), maxResults); +} + diff --git a/computenest/src/model/ListServiceInstanceLogsResult.cc b/computenest/src/model/ListServiceInstanceLogsResult.cc new file mode 100644 index 000000000..015490760 --- /dev/null +++ b/computenest/src/model/ListServiceInstanceLogsResult.cc @@ -0,0 +1,85 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::ComputeNest; +using namespace AlibabaCloud::ComputeNest::Model; + +ListServiceInstanceLogsResult::ListServiceInstanceLogsResult() : + ServiceResult() +{} + +ListServiceInstanceLogsResult::ListServiceInstanceLogsResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListServiceInstanceLogsResult::~ListServiceInstanceLogsResult() +{} + +void ListServiceInstanceLogsResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allServiceInstancesLogsNode = value["ServiceInstancesLogs"]["ServiceInstanceLogs"]; + for (auto valueServiceInstancesLogsServiceInstanceLogs : allServiceInstancesLogsNode) + { + ServiceInstanceLogs serviceInstancesLogsObject; + if(!valueServiceInstancesLogsServiceInstanceLogs["Timestamp"].isNull()) + serviceInstancesLogsObject.timestamp = valueServiceInstancesLogsServiceInstanceLogs["Timestamp"].asString(); + if(!valueServiceInstancesLogsServiceInstanceLogs["ServiceInstanceId"].isNull()) + serviceInstancesLogsObject.serviceInstanceId = valueServiceInstancesLogsServiceInstanceLogs["ServiceInstanceId"].asString(); + if(!valueServiceInstancesLogsServiceInstanceLogs["Source"].isNull()) + serviceInstancesLogsObject.source = valueServiceInstancesLogsServiceInstanceLogs["Source"].asString(); + if(!valueServiceInstancesLogsServiceInstanceLogs["Content"].isNull()) + serviceInstancesLogsObject.content = valueServiceInstancesLogsServiceInstanceLogs["Content"].asString(); + if(!valueServiceInstancesLogsServiceInstanceLogs["LogType"].isNull()) + serviceInstancesLogsObject.logType = valueServiceInstancesLogsServiceInstanceLogs["LogType"].asString(); + if(!valueServiceInstancesLogsServiceInstanceLogs["ResourceType"].isNull()) + serviceInstancesLogsObject.resourceType = valueServiceInstancesLogsServiceInstanceLogs["ResourceType"].asString(); + if(!valueServiceInstancesLogsServiceInstanceLogs["ResourceId"].isNull()) + serviceInstancesLogsObject.resourceId = valueServiceInstancesLogsServiceInstanceLogs["ResourceId"].asString(); + if(!valueServiceInstancesLogsServiceInstanceLogs["Status"].isNull()) + serviceInstancesLogsObject.status = valueServiceInstancesLogsServiceInstanceLogs["Status"].asString(); + serviceInstancesLogs_.push_back(serviceInstancesLogsObject); + } + if(!value["NextToken"].isNull()) + nextToken_ = value["NextToken"].asString(); + if(!value["MaxResults"].isNull()) + maxResults_ = value["MaxResults"].asString(); + +} + +std::string ListServiceInstanceLogsResult::getNextToken()const +{ + return nextToken_; +} + +std::string ListServiceInstanceLogsResult::getMaxResults()const +{ + return maxResults_; +} + +std::vector ListServiceInstanceLogsResult::getServiceInstancesLogs()const +{ + return serviceInstancesLogs_; +} + diff --git a/computenest/src/model/ListServiceInstanceResourcesRequest.cc b/computenest/src/model/ListServiceInstanceResourcesRequest.cc new file mode 100644 index 000000000..1c24eb281 --- /dev/null +++ b/computenest/src/model/ListServiceInstanceResourcesRequest.cc @@ -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. + */ + +#include + +using AlibabaCloud::ComputeNest::Model::ListServiceInstanceResourcesRequest; + +ListServiceInstanceResourcesRequest::ListServiceInstanceResourcesRequest() + : RpcServiceRequest("computenest", "2021-06-01", "ListServiceInstanceResources") { + setMethod(HttpRequest::Method::Post); +} + +ListServiceInstanceResourcesRequest::~ListServiceInstanceResourcesRequest() {} + +std::string ListServiceInstanceResourcesRequest::getExpireTimeEnd() const { + return expireTimeEnd_; +} + +void ListServiceInstanceResourcesRequest::setExpireTimeEnd(const std::string &expireTimeEnd) { + expireTimeEnd_ = expireTimeEnd; + setParameter(std::string("ExpireTimeEnd"), expireTimeEnd); +} + +std::string ListServiceInstanceResourcesRequest::getNextToken() const { + return nextToken_; +} + +void ListServiceInstanceResourcesRequest::setNextToken(const std::string &nextToken) { + nextToken_ = nextToken; + setParameter(std::string("NextToken"), nextToken); +} + +std::string ListServiceInstanceResourcesRequest::getRegionId() const { + return regionId_; +} + +void ListServiceInstanceResourcesRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::vector ListServiceInstanceResourcesRequest::getResourceARN() const { + return resourceARN_; +} + +void ListServiceInstanceResourcesRequest::setResourceARN(const std::vector &resourceARN) { + resourceARN_ = resourceARN; +} + +std::vector ListServiceInstanceResourcesRequest::getTag() const { + return tag_; +} + +void ListServiceInstanceResourcesRequest::setTag(const std::vector &tag) { + tag_ = tag; + for(int dep1 = 0; dep1 != tag.size(); dep1++) { + auto tagObj = tag.at(dep1); + std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1); + setParameter(tagObjStr + ".Value", tagObj.value); + setParameter(tagObjStr + ".Key", tagObj.key); + } +} + +std::string ListServiceInstanceResourcesRequest::getServiceInstanceId() const { + return serviceInstanceId_; +} + +void ListServiceInstanceResourcesRequest::setServiceInstanceId(const std::string &serviceInstanceId) { + serviceInstanceId_ = serviceInstanceId; + setParameter(std::string("ServiceInstanceId"), serviceInstanceId); +} + +std::string ListServiceInstanceResourcesRequest::getExpireTimeStart() const { + return expireTimeStart_; +} + +void ListServiceInstanceResourcesRequest::setExpireTimeStart(const std::string &expireTimeStart) { + expireTimeStart_ = expireTimeStart; + setParameter(std::string("ExpireTimeStart"), expireTimeStart); +} + +std::string ListServiceInstanceResourcesRequest::getMaxResults() const { + return maxResults_; +} + +void ListServiceInstanceResourcesRequest::setMaxResults(const std::string &maxResults) { + maxResults_ = maxResults; + setParameter(std::string("MaxResults"), maxResults); +} + +std::string ListServiceInstanceResourcesRequest::getPayType() const { + return payType_; +} + +void ListServiceInstanceResourcesRequest::setPayType(const std::string &payType) { + payType_ = payType; + setParameter(std::string("PayType"), payType); +} + diff --git a/computenest/src/model/ListServiceInstanceResourcesResult.cc b/computenest/src/model/ListServiceInstanceResourcesResult.cc new file mode 100644 index 000000000..405e8c034 --- /dev/null +++ b/computenest/src/model/ListServiceInstanceResourcesResult.cc @@ -0,0 +1,87 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::ComputeNest; +using namespace AlibabaCloud::ComputeNest::Model; + +ListServiceInstanceResourcesResult::ListServiceInstanceResourcesResult() : + ServiceResult() +{} + +ListServiceInstanceResourcesResult::ListServiceInstanceResourcesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListServiceInstanceResourcesResult::~ListServiceInstanceResourcesResult() +{} + +void ListServiceInstanceResourcesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allResourcesNode = value["Resources"]["ResourcesItem"]; + for (auto valueResourcesResourcesItem : allResourcesNode) + { + ResourcesItem resourcesObject; + if(!valueResourcesResourcesItem["ResourceARN"].isNull()) + resourcesObject.resourceARN = valueResourcesResourcesItem["ResourceARN"].asString(); + if(!valueResourcesResourcesItem["PayType"].isNull()) + resourcesObject.payType = valueResourcesResourcesItem["PayType"].asString(); + if(!valueResourcesResourcesItem["RenewStatus"].isNull()) + resourcesObject.renewStatus = valueResourcesResourcesItem["RenewStatus"].asString(); + if(!valueResourcesResourcesItem["CreateTime"].isNull()) + resourcesObject.createTime = valueResourcesResourcesItem["CreateTime"].asString(); + if(!valueResourcesResourcesItem["ExpireTime"].isNull()) + resourcesObject.expireTime = valueResourcesResourcesItem["ExpireTime"].asString(); + if(!valueResourcesResourcesItem["RenewalPeriod"].isNull()) + resourcesObject.renewalPeriod = std::stoi(valueResourcesResourcesItem["RenewalPeriod"].asString()); + if(!valueResourcesResourcesItem["RenewalPeriodUnit"].isNull()) + resourcesObject.renewalPeriodUnit = valueResourcesResourcesItem["RenewalPeriodUnit"].asString(); + if(!valueResourcesResourcesItem["ProductType"].isNull()) + resourcesObject.productType = valueResourcesResourcesItem["ProductType"].asString(); + if(!valueResourcesResourcesItem["ProductCode"].isNull()) + resourcesObject.productCode = valueResourcesResourcesItem["ProductCode"].asString(); + resources_.push_back(resourcesObject); + } + if(!value["NextToken"].isNull()) + nextToken_ = value["NextToken"].asString(); + if(!value["MaxResults"].isNull()) + maxResults_ = value["MaxResults"].asString(); + +} + +std::string ListServiceInstanceResourcesResult::getNextToken()const +{ + return nextToken_; +} + +std::string ListServiceInstanceResourcesResult::getMaxResults()const +{ + return maxResults_; +} + +std::vector ListServiceInstanceResourcesResult::getResources()const +{ + return resources_; +} + diff --git a/computenest/src/model/ListServiceInstancesRequest.cc b/computenest/src/model/ListServiceInstancesRequest.cc new file mode 100644 index 000000000..b265b9c94 --- /dev/null +++ b/computenest/src/model/ListServiceInstancesRequest.cc @@ -0,0 +1,90 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::ComputeNest::Model::ListServiceInstancesRequest; + +ListServiceInstancesRequest::ListServiceInstancesRequest() + : RpcServiceRequest("computenest", "2021-06-01", "ListServiceInstances") { + setMethod(HttpRequest::Method::Post); +} + +ListServiceInstancesRequest::~ListServiceInstancesRequest() {} + +std::string ListServiceInstancesRequest::getResourceGroupId() const { + return resourceGroupId_; +} + +void ListServiceInstancesRequest::setResourceGroupId(const std::string &resourceGroupId) { + resourceGroupId_ = resourceGroupId; + setParameter(std::string("ResourceGroupId"), resourceGroupId); +} + +std::string ListServiceInstancesRequest::getRegionId() const { + return regionId_; +} + +void ListServiceInstancesRequest::setRegionId(const std::string ®ionId) { + regionId_ = regionId; + setParameter(std::string("RegionId"), regionId); +} + +std::string ListServiceInstancesRequest::getNextToken() const { + return nextToken_; +} + +void ListServiceInstancesRequest::setNextToken(const std::string &nextToken) { + nextToken_ = nextToken; + setParameter(std::string("NextToken"), nextToken); +} + +std::vector ListServiceInstancesRequest::getTag() const { + return tag_; +} + +void ListServiceInstancesRequest::setTag(const std::vector &tag) { + tag_ = tag; + for(int dep1 = 0; dep1 != tag.size(); dep1++) { + auto tagObj = tag.at(dep1); + std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1); + setParameter(tagObjStr + ".Value", tagObj.value); + setParameter(tagObjStr + ".Key", tagObj.key); + } +} + +std::vector ListServiceInstancesRequest::getFilter() const { + return filter_; +} + +void ListServiceInstancesRequest::setFilter(const std::vector &filter) { + filter_ = filter; + for(int dep1 = 0; dep1 != filter.size(); dep1++) { + auto filterObj = filter.at(dep1); + std::string filterObjStr = std::string("Filter") + "." + std::to_string(dep1 + 1); + setParameter(filterObjStr + ".Name", filterObj.name); + } +} + +std::string ListServiceInstancesRequest::getMaxResults() const { + return maxResults_; +} + +void ListServiceInstancesRequest::setMaxResults(const std::string &maxResults) { + maxResults_ = maxResults; + setParameter(std::string("MaxResults"), maxResults); +} + diff --git a/computenest/src/model/ListServiceInstancesResult.cc b/computenest/src/model/ListServiceInstancesResult.cc new file mode 100644 index 000000000..d624d94a7 --- /dev/null +++ b/computenest/src/model/ListServiceInstancesResult.cc @@ -0,0 +1,161 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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::ComputeNest; +using namespace AlibabaCloud::ComputeNest::Model; + +ListServiceInstancesResult::ListServiceInstancesResult() : + ServiceResult() +{} + +ListServiceInstancesResult::ListServiceInstancesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +ListServiceInstancesResult::~ListServiceInstancesResult() +{} + +void ListServiceInstancesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allServiceInstancesNode = value["ServiceInstances"]["ServiceInstance"]; + for (auto valueServiceInstancesServiceInstance : allServiceInstancesNode) + { + ServiceInstance serviceInstancesObject; + if(!valueServiceInstancesServiceInstance["Name"].isNull()) + serviceInstancesObject.name = valueServiceInstancesServiceInstance["Name"].asString(); + if(!valueServiceInstancesServiceInstance["Status"].isNull()) + serviceInstancesObject.status = valueServiceInstancesServiceInstance["Status"].asString(); + if(!valueServiceInstancesServiceInstance["Outputs"].isNull()) + serviceInstancesObject.outputs = valueServiceInstancesServiceInstance["Outputs"].asString(); + if(!valueServiceInstancesServiceInstance["UpdateTime"].isNull()) + serviceInstancesObject.updateTime = valueServiceInstancesServiceInstance["UpdateTime"].asString(); + if(!valueServiceInstancesServiceInstance["Parameters"].isNull()) + serviceInstancesObject.parameters = valueServiceInstancesServiceInstance["Parameters"].asString(); + if(!valueServiceInstancesServiceInstance["ServiceInstanceId"].isNull()) + serviceInstancesObject.serviceInstanceId = valueServiceInstancesServiceInstance["ServiceInstanceId"].asString(); + if(!valueServiceInstancesServiceInstance["CreateTime"].isNull()) + serviceInstancesObject.createTime = valueServiceInstancesServiceInstance["CreateTime"].asString(); + if(!valueServiceInstancesServiceInstance["StatusDetail"].isNull()) + serviceInstancesObject.statusDetail = valueServiceInstancesServiceInstance["StatusDetail"].asString(); + if(!valueServiceInstancesServiceInstance["Progress"].isNull()) + serviceInstancesObject.progress = std::stol(valueServiceInstancesServiceInstance["Progress"].asString()); + if(!valueServiceInstancesServiceInstance["Resources"].isNull()) + serviceInstancesObject.resources = valueServiceInstancesServiceInstance["Resources"].asString(); + if(!valueServiceInstancesServiceInstance["TemplateName"].isNull()) + serviceInstancesObject.templateName = valueServiceInstancesServiceInstance["TemplateName"].asString(); + if(!valueServiceInstancesServiceInstance["OperatedServiceInstanceId"].isNull()) + serviceInstancesObject.operatedServiceInstanceId = valueServiceInstancesServiceInstance["OperatedServiceInstanceId"].asString(); + if(!valueServiceInstancesServiceInstance["OperationStartTime"].isNull()) + serviceInstancesObject.operationStartTime = valueServiceInstancesServiceInstance["OperationStartTime"].asString(); + if(!valueServiceInstancesServiceInstance["OperationEndTime"].isNull()) + serviceInstancesObject.operationEndTime = valueServiceInstancesServiceInstance["OperationEndTime"].asString(); + if(!valueServiceInstancesServiceInstance["EnableInstanceOps"].isNull()) + serviceInstancesObject.enableInstanceOps = valueServiceInstancesServiceInstance["EnableInstanceOps"].asString() == "true"; + if(!valueServiceInstancesServiceInstance["Source"].isNull()) + serviceInstancesObject.source = valueServiceInstancesServiceInstance["Source"].asString(); + if(!valueServiceInstancesServiceInstance["EndTime"].isNull()) + serviceInstancesObject.endTime = valueServiceInstancesServiceInstance["EndTime"].asString(); + if(!valueServiceInstancesServiceInstance["ServiceType"].isNull()) + serviceInstancesObject.serviceType = valueServiceInstancesServiceInstance["ServiceType"].asString(); + if(!valueServiceInstancesServiceInstance["PayType"].isNull()) + serviceInstancesObject.payType = valueServiceInstancesServiceInstance["PayType"].asString(); + if(!valueServiceInstancesServiceInstance["MarketInstanceId"].isNull()) + serviceInstancesObject.marketInstanceId = valueServiceInstancesServiceInstance["MarketInstanceId"].asString(); + if(!valueServiceInstancesServiceInstance["ResourceGroupId"].isNull()) + serviceInstancesObject.resourceGroupId = valueServiceInstancesServiceInstance["ResourceGroupId"].asString(); + auto allTagsNode = valueServiceInstancesServiceInstance["Tags"]["Tag"]; + for (auto valueServiceInstancesServiceInstanceTagsTag : allTagsNode) + { + ServiceInstance::Tag tagsObject; + if(!valueServiceInstancesServiceInstanceTagsTag["Key"].isNull()) + tagsObject.key = valueServiceInstancesServiceInstanceTagsTag["Key"].asString(); + if(!valueServiceInstancesServiceInstanceTagsTag["Value"].isNull()) + tagsObject.value = valueServiceInstancesServiceInstanceTagsTag["Value"].asString(); + serviceInstancesObject.tags.push_back(tagsObject); + } + auto serviceNode = value["Service"]; + if(!serviceNode["Status"].isNull()) + serviceInstancesObject.service.status = serviceNode["Status"].asString(); + if(!serviceNode["PublishTime"].isNull()) + serviceInstancesObject.service.publishTime = serviceNode["PublishTime"].asString(); + if(!serviceNode["Version"].isNull()) + serviceInstancesObject.service.version = serviceNode["Version"].asString(); + if(!serviceNode["DeployType"].isNull()) + serviceInstancesObject.service.deployType = serviceNode["DeployType"].asString(); + if(!serviceNode["ServiceId"].isNull()) + serviceInstancesObject.service.serviceId = serviceNode["ServiceId"].asString(); + if(!serviceNode["SupplierUrl"].isNull()) + serviceInstancesObject.service.supplierUrl = serviceNode["SupplierUrl"].asString(); + if(!serviceNode["ServiceType"].isNull()) + serviceInstancesObject.service.serviceType = serviceNode["ServiceType"].asString(); + if(!serviceNode["SupplierName"].isNull()) + serviceInstancesObject.service.supplierName = serviceNode["SupplierName"].asString(); + if(!serviceNode["VersionName"].isNull()) + serviceInstancesObject.service.versionName = serviceNode["VersionName"].asString(); + auto allServiceInfosNode = serviceNode["ServiceInfos"]["ServiceInfo"]; + for (auto serviceNodeServiceInfosServiceInfo : allServiceInfosNode) + { + ServiceInstance::Service::ServiceInfo serviceInfoObject; + if(!serviceNodeServiceInfosServiceInfo["Locale"].isNull()) + serviceInfoObject.locale = serviceNodeServiceInfosServiceInfo["Locale"].asString(); + if(!serviceNodeServiceInfosServiceInfo["Image"].isNull()) + serviceInfoObject.image = serviceNodeServiceInfosServiceInfo["Image"].asString(); + if(!serviceNodeServiceInfosServiceInfo["Name"].isNull()) + serviceInfoObject.name = serviceNodeServiceInfosServiceInfo["Name"].asString(); + if(!serviceNodeServiceInfosServiceInfo["ShortDescription"].isNull()) + serviceInfoObject.shortDescription = serviceNodeServiceInfosServiceInfo["ShortDescription"].asString(); + serviceInstancesObject.service.serviceInfos.push_back(serviceInfoObject); + } + serviceInstances_.push_back(serviceInstancesObject); + } + if(!value["NextToken"].isNull()) + nextToken_ = value["NextToken"].asString(); + if(!value["TotalCount"].isNull()) + totalCount_ = std::stol(value["TotalCount"].asString()); + if(!value["MaxResults"].isNull()) + maxResults_ = value["MaxResults"].asString(); + +} + +long ListServiceInstancesResult::getTotalCount()const +{ + return totalCount_; +} + +std::vector ListServiceInstancesResult::getServiceInstances()const +{ + return serviceInstances_; +} + +std::string ListServiceInstancesResult::getNextToken()const +{ + return nextToken_; +} + +std::string ListServiceInstancesResult::getMaxResults()const +{ + return maxResults_; +} +