Public ListServiceInstances and GetServiceInstance OpenApi.

This commit is contained in:
sdk-team
2023-01-04 09:56:06 +00:00
parent 5b44f9773d
commit 7d28af74ab
45 changed files with 3772 additions and 1 deletions

View File

@@ -1 +1 @@
1.36.1409
1.36.1410

View File

@@ -0,0 +1,122 @@
#
# Copyright 2009-2017 Alibaba Cloud All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT 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(computenestsupplier_public_header
include/alibabacloud/computenestsupplier/ComputeNestSupplierClient.h
include/alibabacloud/computenestsupplier/ComputeNestSupplierExport.h )
set(computenestsupplier_public_header_model
include/alibabacloud/computenestsupplier/model/CreateArtifactRequest.h
include/alibabacloud/computenestsupplier/model/CreateArtifactResult.h
include/alibabacloud/computenestsupplier/model/DeleteArtifactRequest.h
include/alibabacloud/computenestsupplier/model/DeleteArtifactResult.h
include/alibabacloud/computenestsupplier/model/GetArtifactRequest.h
include/alibabacloud/computenestsupplier/model/GetArtifactResult.h
include/alibabacloud/computenestsupplier/model/GetArtifactRepositoryCredentialsRequest.h
include/alibabacloud/computenestsupplier/model/GetArtifactRepositoryCredentialsResult.h
include/alibabacloud/computenestsupplier/model/GetServiceInstanceRequest.h
include/alibabacloud/computenestsupplier/model/GetServiceInstanceResult.h
include/alibabacloud/computenestsupplier/model/ListArtifactVersionsRequest.h
include/alibabacloud/computenestsupplier/model/ListArtifactVersionsResult.h
include/alibabacloud/computenestsupplier/model/ListArtifactsRequest.h
include/alibabacloud/computenestsupplier/model/ListArtifactsResult.h
include/alibabacloud/computenestsupplier/model/ListServiceInstancesRequest.h
include/alibabacloud/computenestsupplier/model/ListServiceInstancesResult.h
include/alibabacloud/computenestsupplier/model/ReleaseArtifactRequest.h
include/alibabacloud/computenestsupplier/model/ReleaseArtifactResult.h
include/alibabacloud/computenestsupplier/model/UpdateArtifactRequest.h
include/alibabacloud/computenestsupplier/model/UpdateArtifactResult.h )
set(computenestsupplier_src
src/ComputeNestSupplierClient.cc
src/model/CreateArtifactRequest.cc
src/model/CreateArtifactResult.cc
src/model/DeleteArtifactRequest.cc
src/model/DeleteArtifactResult.cc
src/model/GetArtifactRequest.cc
src/model/GetArtifactResult.cc
src/model/GetArtifactRepositoryCredentialsRequest.cc
src/model/GetArtifactRepositoryCredentialsResult.cc
src/model/GetServiceInstanceRequest.cc
src/model/GetServiceInstanceResult.cc
src/model/ListArtifactVersionsRequest.cc
src/model/ListArtifactVersionsResult.cc
src/model/ListArtifactsRequest.cc
src/model/ListArtifactsResult.cc
src/model/ListServiceInstancesRequest.cc
src/model/ListServiceInstancesResult.cc
src/model/ReleaseArtifactRequest.cc
src/model/ReleaseArtifactResult.cc
src/model/UpdateArtifactRequest.cc
src/model/UpdateArtifactResult.cc )
add_library(computenestsupplier ${LIB_TYPE}
${computenestsupplier_public_header}
${computenestsupplier_public_header_model}
${computenestsupplier_src})
set_target_properties(computenestsupplier
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}computenestsupplier
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(computenestsupplier
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_COMPUTENESTSUPPLIER_LIBRARY)
endif()
target_include_directories(computenestsupplier
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(computenestsupplier
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(computenestsupplier
jsoncpp)
target_include_directories(computenestsupplier
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(computenestsupplier
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(computenestsupplier
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(computenestsupplier
PRIVATE /usr/include/jsoncpp)
target_link_libraries(computenestsupplier
jsoncpp)
endif()
install(FILES ${computenestsupplier_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/computenestsupplier)
install(FILES ${computenestsupplier_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/computenestsupplier/model)
install(TARGETS computenestsupplier
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

View File

@@ -0,0 +1,126 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_COMPUTENESTSUPPLIER_COMPUTENESTSUPPLIERCLIENT_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_COMPUTENESTSUPPLIERCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "ComputeNestSupplierExport.h"
#include "model/CreateArtifactRequest.h"
#include "model/CreateArtifactResult.h"
#include "model/DeleteArtifactRequest.h"
#include "model/DeleteArtifactResult.h"
#include "model/GetArtifactRequest.h"
#include "model/GetArtifactResult.h"
#include "model/GetArtifactRepositoryCredentialsRequest.h"
#include "model/GetArtifactRepositoryCredentialsResult.h"
#include "model/GetServiceInstanceRequest.h"
#include "model/GetServiceInstanceResult.h"
#include "model/ListArtifactVersionsRequest.h"
#include "model/ListArtifactVersionsResult.h"
#include "model/ListArtifactsRequest.h"
#include "model/ListArtifactsResult.h"
#include "model/ListServiceInstancesRequest.h"
#include "model/ListServiceInstancesResult.h"
#include "model/ReleaseArtifactRequest.h"
#include "model/ReleaseArtifactResult.h"
#include "model/UpdateArtifactRequest.h"
#include "model/UpdateArtifactResult.h"
namespace AlibabaCloud
{
namespace ComputeNestSupplier
{
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ComputeNestSupplierClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::CreateArtifactResult> CreateArtifactOutcome;
typedef std::future<CreateArtifactOutcome> CreateArtifactOutcomeCallable;
typedef std::function<void(const ComputeNestSupplierClient*, const Model::CreateArtifactRequest&, const CreateArtifactOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateArtifactAsyncHandler;
typedef Outcome<Error, Model::DeleteArtifactResult> DeleteArtifactOutcome;
typedef std::future<DeleteArtifactOutcome> DeleteArtifactOutcomeCallable;
typedef std::function<void(const ComputeNestSupplierClient*, const Model::DeleteArtifactRequest&, const DeleteArtifactOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteArtifactAsyncHandler;
typedef Outcome<Error, Model::GetArtifactResult> GetArtifactOutcome;
typedef std::future<GetArtifactOutcome> GetArtifactOutcomeCallable;
typedef std::function<void(const ComputeNestSupplierClient*, const Model::GetArtifactRequest&, const GetArtifactOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetArtifactAsyncHandler;
typedef Outcome<Error, Model::GetArtifactRepositoryCredentialsResult> GetArtifactRepositoryCredentialsOutcome;
typedef std::future<GetArtifactRepositoryCredentialsOutcome> GetArtifactRepositoryCredentialsOutcomeCallable;
typedef std::function<void(const ComputeNestSupplierClient*, const Model::GetArtifactRepositoryCredentialsRequest&, const GetArtifactRepositoryCredentialsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetArtifactRepositoryCredentialsAsyncHandler;
typedef Outcome<Error, Model::GetServiceInstanceResult> GetServiceInstanceOutcome;
typedef std::future<GetServiceInstanceOutcome> GetServiceInstanceOutcomeCallable;
typedef std::function<void(const ComputeNestSupplierClient*, const Model::GetServiceInstanceRequest&, const GetServiceInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetServiceInstanceAsyncHandler;
typedef Outcome<Error, Model::ListArtifactVersionsResult> ListArtifactVersionsOutcome;
typedef std::future<ListArtifactVersionsOutcome> ListArtifactVersionsOutcomeCallable;
typedef std::function<void(const ComputeNestSupplierClient*, const Model::ListArtifactVersionsRequest&, const ListArtifactVersionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListArtifactVersionsAsyncHandler;
typedef Outcome<Error, Model::ListArtifactsResult> ListArtifactsOutcome;
typedef std::future<ListArtifactsOutcome> ListArtifactsOutcomeCallable;
typedef std::function<void(const ComputeNestSupplierClient*, const Model::ListArtifactsRequest&, const ListArtifactsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListArtifactsAsyncHandler;
typedef Outcome<Error, Model::ListServiceInstancesResult> ListServiceInstancesOutcome;
typedef std::future<ListServiceInstancesOutcome> ListServiceInstancesOutcomeCallable;
typedef std::function<void(const ComputeNestSupplierClient*, const Model::ListServiceInstancesRequest&, const ListServiceInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListServiceInstancesAsyncHandler;
typedef Outcome<Error, Model::ReleaseArtifactResult> ReleaseArtifactOutcome;
typedef std::future<ReleaseArtifactOutcome> ReleaseArtifactOutcomeCallable;
typedef std::function<void(const ComputeNestSupplierClient*, const Model::ReleaseArtifactRequest&, const ReleaseArtifactOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseArtifactAsyncHandler;
typedef Outcome<Error, Model::UpdateArtifactResult> UpdateArtifactOutcome;
typedef std::future<UpdateArtifactOutcome> UpdateArtifactOutcomeCallable;
typedef std::function<void(const ComputeNestSupplierClient*, const Model::UpdateArtifactRequest&, const UpdateArtifactOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateArtifactAsyncHandler;
ComputeNestSupplierClient(const Credentials &credentials, const ClientConfiguration &configuration);
ComputeNestSupplierClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
ComputeNestSupplierClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~ComputeNestSupplierClient();
CreateArtifactOutcome createArtifact(const Model::CreateArtifactRequest &request)const;
void createArtifactAsync(const Model::CreateArtifactRequest& request, const CreateArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateArtifactOutcomeCallable createArtifactCallable(const Model::CreateArtifactRequest& request) const;
DeleteArtifactOutcome deleteArtifact(const Model::DeleteArtifactRequest &request)const;
void deleteArtifactAsync(const Model::DeleteArtifactRequest& request, const DeleteArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteArtifactOutcomeCallable deleteArtifactCallable(const Model::DeleteArtifactRequest& request) const;
GetArtifactOutcome getArtifact(const Model::GetArtifactRequest &request)const;
void getArtifactAsync(const Model::GetArtifactRequest& request, const GetArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetArtifactOutcomeCallable getArtifactCallable(const Model::GetArtifactRequest& request) const;
GetArtifactRepositoryCredentialsOutcome getArtifactRepositoryCredentials(const Model::GetArtifactRepositoryCredentialsRequest &request)const;
void getArtifactRepositoryCredentialsAsync(const Model::GetArtifactRepositoryCredentialsRequest& request, const GetArtifactRepositoryCredentialsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetArtifactRepositoryCredentialsOutcomeCallable getArtifactRepositoryCredentialsCallable(const Model::GetArtifactRepositoryCredentialsRequest& request) const;
GetServiceInstanceOutcome getServiceInstance(const Model::GetServiceInstanceRequest &request)const;
void getServiceInstanceAsync(const Model::GetServiceInstanceRequest& request, const GetServiceInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetServiceInstanceOutcomeCallable getServiceInstanceCallable(const Model::GetServiceInstanceRequest& request) const;
ListArtifactVersionsOutcome listArtifactVersions(const Model::ListArtifactVersionsRequest &request)const;
void listArtifactVersionsAsync(const Model::ListArtifactVersionsRequest& request, const ListArtifactVersionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListArtifactVersionsOutcomeCallable listArtifactVersionsCallable(const Model::ListArtifactVersionsRequest& request) const;
ListArtifactsOutcome listArtifacts(const Model::ListArtifactsRequest &request)const;
void listArtifactsAsync(const Model::ListArtifactsRequest& request, const ListArtifactsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListArtifactsOutcomeCallable listArtifactsCallable(const Model::ListArtifactsRequest& request) const;
ListServiceInstancesOutcome listServiceInstances(const Model::ListServiceInstancesRequest &request)const;
void listServiceInstancesAsync(const Model::ListServiceInstancesRequest& request, const ListServiceInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListServiceInstancesOutcomeCallable listServiceInstancesCallable(const Model::ListServiceInstancesRequest& request) const;
ReleaseArtifactOutcome releaseArtifact(const Model::ReleaseArtifactRequest &request)const;
void releaseArtifactAsync(const Model::ReleaseArtifactRequest& request, const ReleaseArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ReleaseArtifactOutcomeCallable releaseArtifactCallable(const Model::ReleaseArtifactRequest& request) const;
UpdateArtifactOutcome updateArtifact(const Model::UpdateArtifactRequest &request)const;
void updateArtifactAsync(const Model::UpdateArtifactRequest& request, const UpdateArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateArtifactOutcomeCallable updateArtifactCallable(const Model::UpdateArtifactRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_COMPUTENESTSUPPLIERCLIENT_H_

View File

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

View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_CREATEARTIFACTREQUEST_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_CREATEARTIFACTREQUEST_H_
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ComputeNestSupplier {
namespace Model {
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT CreateArtifactRequest : public RpcServiceRequest {
public:
CreateArtifactRequest();
~CreateArtifactRequest();
std::string getDescription() const;
void setDescription(const std::string &description);
std::vector<std::string> getSupportRegionIds() const;
void setSupportRegionIds(const std::vector<std::string> &supportRegionIds);
std::string getArtifactType() const;
void setArtifactType(const std::string &artifactType);
std::string getName() const;
void setName(const std::string &name);
std::string getArtifactId() const;
void setArtifactId(const std::string &artifactId);
std::string getArtifactProperty() const;
void setArtifactProperty(const std::string &artifactProperty);
std::string getVersionName() const;
void setVersionName(const std::string &versionName);
private:
std::string description_;
std::vector<std::string> supportRegionIds_;
std::string artifactType_;
std::string name_;
std::string artifactId_;
std::string artifactProperty_;
std::string versionName_;
};
} // namespace Model
} // namespace ComputeNestSupplier
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_CREATEARTIFACTREQUEST_H_

View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_CREATEARTIFACTRESULT_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_CREATEARTIFACTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
namespace AlibabaCloud
{
namespace ComputeNestSupplier
{
namespace Model
{
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT CreateArtifactResult : public ServiceResult
{
public:
CreateArtifactResult();
explicit CreateArtifactResult(const std::string &payload);
~CreateArtifactResult();
std::string getStatus()const;
std::string getArtifactVersion()const;
std::string getDescription()const;
std::string getArtifactId()const;
std::string getArtifactType()const;
std::string getSupportRegionIds()const;
std::string getGmtModified()const;
std::string getVersionName()const;
long getMaxVersion()const;
std::string getArtifactProperty()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
std::string artifactVersion_;
std::string description_;
std::string artifactId_;
std::string artifactType_;
std::string supportRegionIds_;
std::string gmtModified_;
std::string versionName_;
long maxVersion_;
std::string artifactProperty_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_CREATEARTIFACTRESULT_H_

View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_DELETEARTIFACTREQUEST_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_DELETEARTIFACTREQUEST_H_
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ComputeNestSupplier {
namespace Model {
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT DeleteArtifactRequest : public RpcServiceRequest {
public:
DeleteArtifactRequest();
~DeleteArtifactRequest();
std::string getArtifactVersion() const;
void setArtifactVersion(const std::string &artifactVersion);
std::string getArtifactId() const;
void setArtifactId(const std::string &artifactId);
private:
std::string artifactVersion_;
std::string artifactId_;
};
} // namespace Model
} // namespace ComputeNestSupplier
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_DELETEARTIFACTREQUEST_H_

View File

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

View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREPOSITORYCREDENTIALSREQUEST_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREPOSITORYCREDENTIALSREQUEST_H_
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ComputeNestSupplier {
namespace Model {
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT GetArtifactRepositoryCredentialsRequest : public RpcServiceRequest {
public:
GetArtifactRepositoryCredentialsRequest();
~GetArtifactRepositoryCredentialsRequest();
std::string getDeployRegionId() const;
void setDeployRegionId(const std::string &deployRegionId);
std::string getArtifactType() const;
void setArtifactType(const std::string &artifactType);
private:
std::string deployRegionId_;
std::string artifactType_;
};
} // namespace Model
} // namespace ComputeNestSupplier
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREPOSITORYCREDENTIALSREQUEST_H_

View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREPOSITORYCREDENTIALSRESULT_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREPOSITORYCREDENTIALSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
namespace AlibabaCloud
{
namespace ComputeNestSupplier
{
namespace Model
{
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT GetArtifactRepositoryCredentialsResult : public ServiceResult
{
public:
struct Credentials
{
std::string securityToken;
std::string username;
std::string accessKeyId;
std::string accessKeySecret;
std::string password;
};
struct AvailableResourcesItem
{
std::string path;
std::string repositoryName;
std::string regionId;
};
GetArtifactRepositoryCredentialsResult();
explicit GetArtifactRepositoryCredentialsResult(const std::string &payload);
~GetArtifactRepositoryCredentialsResult();
std::string getExpireDate()const;
std::vector<AvailableResourcesItem> getAvailableResources()const;
Credentials getCredentials()const;
protected:
void parse(const std::string &payload);
private:
std::string expireDate_;
std::vector<AvailableResourcesItem> availableResources_;
Credentials credentials_;
};
}
}
}
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREPOSITORYCREDENTIALSRESULT_H_

View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREQUEST_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREQUEST_H_
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ComputeNestSupplier {
namespace Model {
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT GetArtifactRequest : public RpcServiceRequest {
public:
GetArtifactRequest();
~GetArtifactRequest();
std::string getArtifactVersion() const;
void setArtifactVersion(const std::string &artifactVersion);
std::string getArtifactId() const;
void setArtifactId(const std::string &artifactId);
private:
std::string artifactVersion_;
std::string artifactId_;
};
} // namespace Model
} // namespace ComputeNestSupplier
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREQUEST_H_

View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTRESULT_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
namespace AlibabaCloud
{
namespace ComputeNestSupplier
{
namespace Model
{
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT GetArtifactResult : public ServiceResult
{
public:
GetArtifactResult();
explicit GetArtifactResult(const std::string &payload);
~GetArtifactResult();
std::string getStatus()const;
std::string getProgress()const;
std::string getArtifactVersion()const;
std::string getDescription()const;
std::string getArtifactId()const;
std::string getArtifactType()const;
std::string getSupportRegionIds()const;
std::string getGmtModified()const;
std::string getVersionName()const;
long getMaxVersion()const;
std::string getArtifactProperty()const;
std::string getName()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
std::string progress_;
std::string artifactVersion_;
std::string description_;
std::string artifactId_;
std::string artifactType_;
std::string supportRegionIds_;
std::string gmtModified_;
std::string versionName_;
long maxVersion_;
std::string artifactProperty_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTRESULT_H_

View File

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

View File

@@ -0,0 +1,146 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_COMPUTENESTSUPPLIER_MODEL_GETSERVICEINSTANCERESULT_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETSERVICEINSTANCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
namespace AlibabaCloud
{
namespace ComputeNestSupplier
{
namespace Model
{
class ALIBABACLOUD_COMPUTENESTSUPPLIER_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::string serviceId;
std::string deployMetadata;
std::string version;
std::string supplierName;
std::string serviceType;
std::vector<ServiceInfo> serviceInfos;
std::string publishTime;
std::string versionName;
std::string serviceProductUrl;
std::string supplierUrl;
std::string serviceDocUrl;
};
struct NetworkConfig
{
struct PrivateVpcConnection
{
std::string endpointServiceId;
std::string endpointId;
};
struct ReversePrivateVpcConnection
{
std::string endpointServiceId;
std::string endpointId;
};
std::string endpointServiceId;
std::vector<ReversePrivateVpcConnection> reversePrivateVpcConnections;
std::string endpointId;
std::vector<PrivateVpcConnection> privateVpcConnections;
};
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 getOperationEndTime()const;
bool getEnableInstanceOps()const;
std::string getSource()const;
std::string getName()const;
std::string getOperationStartTime()const;
std::string getServiceInstanceId()const;
std::string getServiceType()const;
std::string getLicenseMetadata()const;
std::string getTemplateName()const;
std::vector<Tag> 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;
long getUserId()const;
std::string getStatusDetail()const;
std::string getUpdateTime()const;
std::string getOutputs()const;
long getSupplierUid()const;
bool getIsOperated()const;
std::string getResources()const;
protected:
void parse(const std::string &payload);
private:
std::string operatedServiceInstanceId_;
std::string endTime_;
std::string operationEndTime_;
bool enableInstanceOps_;
std::string source_;
std::string name_;
std::string operationStartTime_;
std::string serviceInstanceId_;
std::string serviceType_;
std::string licenseMetadata_;
std::string templateName_;
std::vector<Tag> tags_;
std::string status_;
long progress_;
std::string parameters_;
std::string createTime_;
NetworkConfig networkConfig_;
Service service_;
std::string payType_;
long userId_;
std::string statusDetail_;
std::string updateTime_;
std::string outputs_;
long supplierUid_;
bool isOperated_;
std::string resources_;
};
}
}
}
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETSERVICEINSTANCERESULT_H_

View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTVERSIONSREQUEST_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTVERSIONSREQUEST_H_
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ComputeNestSupplier {
namespace Model {
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ListArtifactVersionsRequest : public RpcServiceRequest {
public:
ListArtifactVersionsRequest();
~ListArtifactVersionsRequest();
std::string getNextToken() const;
void setNextToken(const std::string &nextToken);
std::string getMaxResult() const;
void setMaxResult(const std::string &maxResult);
std::string getArtifactId() const;
void setArtifactId(const std::string &artifactId);
private:
std::string nextToken_;
std::string maxResult_;
std::string artifactId_;
};
} // namespace Model
} // namespace ComputeNestSupplier
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTVERSIONSREQUEST_H_

View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTVERSIONSRESULT_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTVERSIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
namespace AlibabaCloud
{
namespace ComputeNestSupplier
{
namespace Model
{
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ListArtifactVersionsResult : public ServiceResult
{
public:
struct Artifact
{
std::string status;
std::string progress;
std::string artifactId;
std::string supportRegionIds;
std::string gmtModified;
std::string imageDelivery;
std::string resultFile;
std::string securityAuditResult;
std::string gmtCreate;
std::string artifactVersion;
std::string artifactType;
std::string versionName;
std::string artifactProperty;
};
ListArtifactVersionsResult();
explicit ListArtifactVersionsResult(const std::string &payload);
~ListArtifactVersionsResult();
std::vector<Artifact> getArtifacts()const;
std::string getTotalCount()const;
std::string getNextToken()const;
std::string getMaxResults()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Artifact> artifacts_;
std::string totalCount_;
std::string nextToken_;
std::string maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTVERSIONSRESULT_H_

View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTSREQUEST_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTSREQUEST_H_
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ComputeNestSupplier {
namespace Model {
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ListArtifactsRequest : public RpcServiceRequest {
public:
struct Filter {
std::string name;
};
ListArtifactsRequest();
~ListArtifactsRequest();
std::string getNextToken() const;
void setNextToken(const std::string &nextToken);
std::vector<Filter> getFilter() const;
void setFilter(const std::vector<Filter> &filter);
std::string getMaxResults() const;
void setMaxResults(const std::string &maxResults);
private:
std::string nextToken_;
std::vector<Filter> filter_;
std::string maxResults_;
};
} // namespace Model
} // namespace ComputeNestSupplier
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTSREQUEST_H_

View File

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

View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTSERVICEINSTANCESREQUEST_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTSERVICEINSTANCESREQUEST_H_
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ComputeNestSupplier {
namespace Model {
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ListServiceInstancesRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
struct Filter {
std::string name;
};
ListServiceInstancesRequest();
~ListServiceInstancesRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getNextToken() const;
void setNextToken(const std::string &nextToken);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
std::vector<Filter> getFilter() const;
void setFilter(const std::vector<Filter> &filter);
std::string getMaxResults() const;
void setMaxResults(const std::string &maxResults);
private:
std::string regionId_;
std::string nextToken_;
std::vector<Tag> tag_;
std::vector<Filter> filter_;
std::string maxResults_;
};
} // namespace Model
} // namespace ComputeNestSupplier
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTSERVICEINSTANCESREQUEST_H_

View File

@@ -0,0 +1,106 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTSERVICEINSTANCESRESULT_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTSERVICEINSTANCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
namespace AlibabaCloud
{
namespace ComputeNestSupplier
{
namespace Model
{
class ALIBABACLOUD_COMPUTENESTSUPPLIER_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 deployMetadata;
std::string version;
std::string supplierName;
std::string serviceType;
std::vector<ServiceInfo> 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 operationEndTime;
std::string createTime;
bool enableInstanceOps;
Service service;
std::string payType;
std::string source;
std::string name;
std::string operationStartTime;
std::string serviceInstanceId;
long userId;
std::string serviceType;
std::string statusDetail;
std::string updateTime;
std::string templateName;
std::vector<ServiceInstance::Tag> tags;
};
ListServiceInstancesResult();
explicit ListServiceInstancesResult(const std::string &payload);
~ListServiceInstancesResult();
int getTotalCount()const;
std::vector<ServiceInstance> getServiceInstances()const;
std::string getNextToken()const;
std::string getMaxResults()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
std::vector<ServiceInstance> serviceInstances_;
std::string nextToken_;
std::string maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTSERVICEINSTANCESRESULT_H_

View File

@@ -0,0 +1,42 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_COMPUTENESTSUPPLIER_MODEL_RELEASEARTIFACTREQUEST_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_RELEASEARTIFACTREQUEST_H_
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ComputeNestSupplier {
namespace Model {
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ReleaseArtifactRequest : public RpcServiceRequest {
public:
ReleaseArtifactRequest();
~ReleaseArtifactRequest();
std::string getArtifactId() const;
void setArtifactId(const std::string &artifactId);
private:
std::string artifactId_;
};
} // namespace Model
} // namespace ComputeNestSupplier
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_RELEASEARTIFACTREQUEST_H_

View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_RELEASEARTIFACTRESULT_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_RELEASEARTIFACTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
namespace AlibabaCloud
{
namespace ComputeNestSupplier
{
namespace Model
{
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ReleaseArtifactResult : public ServiceResult
{
public:
ReleaseArtifactResult();
explicit ReleaseArtifactResult(const std::string &payload);
~ReleaseArtifactResult();
std::string getStatus()const;
std::string getArtifactVersion()const;
std::string getDescription()const;
std::string getArtifactId()const;
std::string getArtifactType()const;
std::string getGmtModified()const;
std::string getVersionName()const;
std::string getArtifactProperty()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
std::string artifactVersion_;
std::string description_;
std::string artifactId_;
std::string artifactType_;
std::string gmtModified_;
std::string versionName_;
std::string artifactProperty_;
};
}
}
}
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_RELEASEARTIFACTRESULT_H_

View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_UPDATEARTIFACTREQUEST_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_UPDATEARTIFACTREQUEST_H_
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ComputeNestSupplier {
namespace Model {
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT UpdateArtifactRequest : public RpcServiceRequest {
public:
UpdateArtifactRequest();
~UpdateArtifactRequest();
std::string getDescription() const;
void setDescription(const std::string &description);
std::vector<std::string> getSupportRegionIds() const;
void setSupportRegionIds(const std::vector<std::string> &supportRegionIds);
std::string getArtifactId() const;
void setArtifactId(const std::string &artifactId);
std::string getArtifactProperty() const;
void setArtifactProperty(const std::string &artifactProperty);
std::string getVersionName() const;
void setVersionName(const std::string &versionName);
private:
std::string description_;
std::vector<std::string> supportRegionIds_;
std::string artifactId_;
std::string artifactProperty_;
std::string versionName_;
};
} // namespace Model
} // namespace ComputeNestSupplier
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_UPDATEARTIFACTREQUEST_H_

View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_UPDATEARTIFACTRESULT_H_
#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_UPDATEARTIFACTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
namespace AlibabaCloud
{
namespace ComputeNestSupplier
{
namespace Model
{
class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT UpdateArtifactResult : public ServiceResult
{
public:
UpdateArtifactResult();
explicit UpdateArtifactResult(const std::string &payload);
~UpdateArtifactResult();
std::string getStatus()const;
std::string getArtifactVersion()const;
std::string getDescription()const;
std::string getArtifactId()const;
std::string getArtifactType()const;
std::string getSupportRegionIds()const;
std::string getGmtModified()const;
std::string getVersionName()const;
std::string getArtifactProperty()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
std::string artifactVersion_;
std::string description_;
std::string artifactId_;
std::string artifactType_;
std::string supportRegionIds_;
std::string gmtModified_;
std::string versionName_;
std::string artifactProperty_;
};
}
}
}
#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_UPDATEARTIFACTRESULT_H_

View File

@@ -0,0 +1,413 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/ComputeNestSupplierClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::ComputeNestSupplier;
using namespace AlibabaCloud::ComputeNestSupplier::Model;
namespace
{
const std::string SERVICE_NAME = "ComputeNestSupplier";
}
ComputeNestSupplierClient::ComputeNestSupplierClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
ComputeNestSupplierClient::ComputeNestSupplierClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
ComputeNestSupplierClient::ComputeNestSupplierClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
ComputeNestSupplierClient::~ComputeNestSupplierClient()
{}
ComputeNestSupplierClient::CreateArtifactOutcome ComputeNestSupplierClient::createArtifact(const CreateArtifactRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateArtifactOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateArtifactOutcome(CreateArtifactResult(outcome.result()));
else
return CreateArtifactOutcome(outcome.error());
}
void ComputeNestSupplierClient::createArtifactAsync(const CreateArtifactRequest& request, const CreateArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createArtifact(request), context);
};
asyncExecute(new Runnable(fn));
}
ComputeNestSupplierClient::CreateArtifactOutcomeCallable ComputeNestSupplierClient::createArtifactCallable(const CreateArtifactRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateArtifactOutcome()>>(
[this, request]()
{
return this->createArtifact(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ComputeNestSupplierClient::DeleteArtifactOutcome ComputeNestSupplierClient::deleteArtifact(const DeleteArtifactRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteArtifactOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteArtifactOutcome(DeleteArtifactResult(outcome.result()));
else
return DeleteArtifactOutcome(outcome.error());
}
void ComputeNestSupplierClient::deleteArtifactAsync(const DeleteArtifactRequest& request, const DeleteArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteArtifact(request), context);
};
asyncExecute(new Runnable(fn));
}
ComputeNestSupplierClient::DeleteArtifactOutcomeCallable ComputeNestSupplierClient::deleteArtifactCallable(const DeleteArtifactRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteArtifactOutcome()>>(
[this, request]()
{
return this->deleteArtifact(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ComputeNestSupplierClient::GetArtifactOutcome ComputeNestSupplierClient::getArtifact(const GetArtifactRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetArtifactOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetArtifactOutcome(GetArtifactResult(outcome.result()));
else
return GetArtifactOutcome(outcome.error());
}
void ComputeNestSupplierClient::getArtifactAsync(const GetArtifactRequest& request, const GetArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getArtifact(request), context);
};
asyncExecute(new Runnable(fn));
}
ComputeNestSupplierClient::GetArtifactOutcomeCallable ComputeNestSupplierClient::getArtifactCallable(const GetArtifactRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetArtifactOutcome()>>(
[this, request]()
{
return this->getArtifact(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ComputeNestSupplierClient::GetArtifactRepositoryCredentialsOutcome ComputeNestSupplierClient::getArtifactRepositoryCredentials(const GetArtifactRepositoryCredentialsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetArtifactRepositoryCredentialsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetArtifactRepositoryCredentialsOutcome(GetArtifactRepositoryCredentialsResult(outcome.result()));
else
return GetArtifactRepositoryCredentialsOutcome(outcome.error());
}
void ComputeNestSupplierClient::getArtifactRepositoryCredentialsAsync(const GetArtifactRepositoryCredentialsRequest& request, const GetArtifactRepositoryCredentialsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getArtifactRepositoryCredentials(request), context);
};
asyncExecute(new Runnable(fn));
}
ComputeNestSupplierClient::GetArtifactRepositoryCredentialsOutcomeCallable ComputeNestSupplierClient::getArtifactRepositoryCredentialsCallable(const GetArtifactRepositoryCredentialsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetArtifactRepositoryCredentialsOutcome()>>(
[this, request]()
{
return this->getArtifactRepositoryCredentials(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ComputeNestSupplierClient::GetServiceInstanceOutcome ComputeNestSupplierClient::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 ComputeNestSupplierClient::getServiceInstanceAsync(const GetServiceInstanceRequest& request, const GetServiceInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getServiceInstance(request), context);
};
asyncExecute(new Runnable(fn));
}
ComputeNestSupplierClient::GetServiceInstanceOutcomeCallable ComputeNestSupplierClient::getServiceInstanceCallable(const GetServiceInstanceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetServiceInstanceOutcome()>>(
[this, request]()
{
return this->getServiceInstance(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ComputeNestSupplierClient::ListArtifactVersionsOutcome ComputeNestSupplierClient::listArtifactVersions(const ListArtifactVersionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListArtifactVersionsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListArtifactVersionsOutcome(ListArtifactVersionsResult(outcome.result()));
else
return ListArtifactVersionsOutcome(outcome.error());
}
void ComputeNestSupplierClient::listArtifactVersionsAsync(const ListArtifactVersionsRequest& request, const ListArtifactVersionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listArtifactVersions(request), context);
};
asyncExecute(new Runnable(fn));
}
ComputeNestSupplierClient::ListArtifactVersionsOutcomeCallable ComputeNestSupplierClient::listArtifactVersionsCallable(const ListArtifactVersionsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListArtifactVersionsOutcome()>>(
[this, request]()
{
return this->listArtifactVersions(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ComputeNestSupplierClient::ListArtifactsOutcome ComputeNestSupplierClient::listArtifacts(const ListArtifactsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListArtifactsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListArtifactsOutcome(ListArtifactsResult(outcome.result()));
else
return ListArtifactsOutcome(outcome.error());
}
void ComputeNestSupplierClient::listArtifactsAsync(const ListArtifactsRequest& request, const ListArtifactsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listArtifacts(request), context);
};
asyncExecute(new Runnable(fn));
}
ComputeNestSupplierClient::ListArtifactsOutcomeCallable ComputeNestSupplierClient::listArtifactsCallable(const ListArtifactsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListArtifactsOutcome()>>(
[this, request]()
{
return this->listArtifacts(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ComputeNestSupplierClient::ListServiceInstancesOutcome ComputeNestSupplierClient::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 ComputeNestSupplierClient::listServiceInstancesAsync(const ListServiceInstancesRequest& request, const ListServiceInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listServiceInstances(request), context);
};
asyncExecute(new Runnable(fn));
}
ComputeNestSupplierClient::ListServiceInstancesOutcomeCallable ComputeNestSupplierClient::listServiceInstancesCallable(const ListServiceInstancesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListServiceInstancesOutcome()>>(
[this, request]()
{
return this->listServiceInstances(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ComputeNestSupplierClient::ReleaseArtifactOutcome ComputeNestSupplierClient::releaseArtifact(const ReleaseArtifactRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ReleaseArtifactOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ReleaseArtifactOutcome(ReleaseArtifactResult(outcome.result()));
else
return ReleaseArtifactOutcome(outcome.error());
}
void ComputeNestSupplierClient::releaseArtifactAsync(const ReleaseArtifactRequest& request, const ReleaseArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, releaseArtifact(request), context);
};
asyncExecute(new Runnable(fn));
}
ComputeNestSupplierClient::ReleaseArtifactOutcomeCallable ComputeNestSupplierClient::releaseArtifactCallable(const ReleaseArtifactRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ReleaseArtifactOutcome()>>(
[this, request]()
{
return this->releaseArtifact(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ComputeNestSupplierClient::UpdateArtifactOutcome ComputeNestSupplierClient::updateArtifact(const UpdateArtifactRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateArtifactOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateArtifactOutcome(UpdateArtifactResult(outcome.result()));
else
return UpdateArtifactOutcome(outcome.error());
}
void ComputeNestSupplierClient::updateArtifactAsync(const UpdateArtifactRequest& request, const UpdateArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateArtifact(request), context);
};
asyncExecute(new Runnable(fn));
}
ComputeNestSupplierClient::UpdateArtifactOutcomeCallable ComputeNestSupplierClient::updateArtifactCallable(const UpdateArtifactRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateArtifactOutcome()>>(
[this, request]()
{
return this->updateArtifact(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

View File

@@ -0,0 +1,89 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/CreateArtifactRequest.h>
using AlibabaCloud::ComputeNestSupplier::Model::CreateArtifactRequest;
CreateArtifactRequest::CreateArtifactRequest()
: RpcServiceRequest("computenestsupplier", "2021-05-21", "CreateArtifact") {
setMethod(HttpRequest::Method::Post);
}
CreateArtifactRequest::~CreateArtifactRequest() {}
std::string CreateArtifactRequest::getDescription() const {
return description_;
}
void CreateArtifactRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
std::vector<std::string> CreateArtifactRequest::getSupportRegionIds() const {
return supportRegionIds_;
}
void CreateArtifactRequest::setSupportRegionIds(const std::vector<std::string> &supportRegionIds) {
supportRegionIds_ = supportRegionIds;
}
std::string CreateArtifactRequest::getArtifactType() const {
return artifactType_;
}
void CreateArtifactRequest::setArtifactType(const std::string &artifactType) {
artifactType_ = artifactType;
setParameter(std::string("ArtifactType"), artifactType);
}
std::string CreateArtifactRequest::getName() const {
return name_;
}
void CreateArtifactRequest::setName(const std::string &name) {
name_ = name;
setParameter(std::string("Name"), name);
}
std::string CreateArtifactRequest::getArtifactId() const {
return artifactId_;
}
void CreateArtifactRequest::setArtifactId(const std::string &artifactId) {
artifactId_ = artifactId;
setParameter(std::string("ArtifactId"), artifactId);
}
std::string CreateArtifactRequest::getArtifactProperty() const {
return artifactProperty_;
}
void CreateArtifactRequest::setArtifactProperty(const std::string &artifactProperty) {
artifactProperty_ = artifactProperty;
setParameter(std::string("ArtifactProperty"), artifactProperty);
}
std::string CreateArtifactRequest::getVersionName() const {
return versionName_;
}
void CreateArtifactRequest::setVersionName(const std::string &versionName) {
versionName_ = versionName;
setParameter(std::string("VersionName"), versionName);
}

View File

@@ -0,0 +1,121 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/CreateArtifactResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ComputeNestSupplier;
using namespace AlibabaCloud::ComputeNestSupplier::Model;
CreateArtifactResult::CreateArtifactResult() :
ServiceResult()
{}
CreateArtifactResult::CreateArtifactResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateArtifactResult::~CreateArtifactResult()
{}
void CreateArtifactResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ArtifactId"].isNull())
artifactId_ = value["ArtifactId"].asString();
if(!value["ArtifactType"].isNull())
artifactType_ = value["ArtifactType"].asString();
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["VersionName"].isNull())
versionName_ = value["VersionName"].asString();
if(!value["ArtifactVersion"].isNull())
artifactVersion_ = value["ArtifactVersion"].asString();
if(!value["Description"].isNull())
description_ = value["Description"].asString();
if(!value["GmtModified"].isNull())
gmtModified_ = value["GmtModified"].asString();
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["MaxVersion"].isNull())
maxVersion_ = std::stol(value["MaxVersion"].asString());
if(!value["ArtifactProperty"].isNull())
artifactProperty_ = value["ArtifactProperty"].asString();
if(!value["SupportRegionIds"].isNull())
supportRegionIds_ = value["SupportRegionIds"].asString();
}
std::string CreateArtifactResult::getStatus()const
{
return status_;
}
std::string CreateArtifactResult::getArtifactVersion()const
{
return artifactVersion_;
}
std::string CreateArtifactResult::getDescription()const
{
return description_;
}
std::string CreateArtifactResult::getArtifactId()const
{
return artifactId_;
}
std::string CreateArtifactResult::getArtifactType()const
{
return artifactType_;
}
std::string CreateArtifactResult::getSupportRegionIds()const
{
return supportRegionIds_;
}
std::string CreateArtifactResult::getGmtModified()const
{
return gmtModified_;
}
std::string CreateArtifactResult::getVersionName()const
{
return versionName_;
}
long CreateArtifactResult::getMaxVersion()const
{
return maxVersion_;
}
std::string CreateArtifactResult::getArtifactProperty()const
{
return artifactProperty_;
}
std::string CreateArtifactResult::getName()const
{
return name_;
}

View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/DeleteArtifactRequest.h>
using AlibabaCloud::ComputeNestSupplier::Model::DeleteArtifactRequest;
DeleteArtifactRequest::DeleteArtifactRequest()
: RpcServiceRequest("computenestsupplier", "2021-05-21", "DeleteArtifact") {
setMethod(HttpRequest::Method::Post);
}
DeleteArtifactRequest::~DeleteArtifactRequest() {}
std::string DeleteArtifactRequest::getArtifactVersion() const {
return artifactVersion_;
}
void DeleteArtifactRequest::setArtifactVersion(const std::string &artifactVersion) {
artifactVersion_ = artifactVersion;
setParameter(std::string("ArtifactVersion"), artifactVersion);
}
std::string DeleteArtifactRequest::getArtifactId() const {
return artifactId_;
}
void DeleteArtifactRequest::setArtifactId(const std::string &artifactId) {
artifactId_ = artifactId;
setParameter(std::string("ArtifactId"), artifactId);
}

View File

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

View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/GetArtifactRepositoryCredentialsRequest.h>
using AlibabaCloud::ComputeNestSupplier::Model::GetArtifactRepositoryCredentialsRequest;
GetArtifactRepositoryCredentialsRequest::GetArtifactRepositoryCredentialsRequest()
: RpcServiceRequest("computenestsupplier", "2021-05-21", "GetArtifactRepositoryCredentials") {
setMethod(HttpRequest::Method::Post);
}
GetArtifactRepositoryCredentialsRequest::~GetArtifactRepositoryCredentialsRequest() {}
std::string GetArtifactRepositoryCredentialsRequest::getDeployRegionId() const {
return deployRegionId_;
}
void GetArtifactRepositoryCredentialsRequest::setDeployRegionId(const std::string &deployRegionId) {
deployRegionId_ = deployRegionId;
setParameter(std::string("DeployRegionId"), deployRegionId);
}
std::string GetArtifactRepositoryCredentialsRequest::getArtifactType() const {
return artifactType_;
}
void GetArtifactRepositoryCredentialsRequest::setArtifactType(const std::string &artifactType) {
artifactType_ = artifactType;
setParameter(std::string("ArtifactType"), artifactType);
}

View File

@@ -0,0 +1,84 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/GetArtifactRepositoryCredentialsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ComputeNestSupplier;
using namespace AlibabaCloud::ComputeNestSupplier::Model;
GetArtifactRepositoryCredentialsResult::GetArtifactRepositoryCredentialsResult() :
ServiceResult()
{}
GetArtifactRepositoryCredentialsResult::GetArtifactRepositoryCredentialsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetArtifactRepositoryCredentialsResult::~GetArtifactRepositoryCredentialsResult()
{}
void GetArtifactRepositoryCredentialsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allAvailableResourcesNode = value["AvailableResources"]["availableResourcesItem"];
for (auto valueAvailableResourcesavailableResourcesItem : allAvailableResourcesNode)
{
AvailableResourcesItem availableResourcesObject;
if(!valueAvailableResourcesavailableResourcesItem["RegionId"].isNull())
availableResourcesObject.regionId = valueAvailableResourcesavailableResourcesItem["RegionId"].asString();
if(!valueAvailableResourcesavailableResourcesItem["RepositoryName"].isNull())
availableResourcesObject.repositoryName = valueAvailableResourcesavailableResourcesItem["RepositoryName"].asString();
if(!valueAvailableResourcesavailableResourcesItem["Path"].isNull())
availableResourcesObject.path = valueAvailableResourcesavailableResourcesItem["Path"].asString();
availableResources_.push_back(availableResourcesObject);
}
auto credentialsNode = value["Credentials"];
if(!credentialsNode["Username"].isNull())
credentials_.username = credentialsNode["Username"].asString();
if(!credentialsNode["Password"].isNull())
credentials_.password = credentialsNode["Password"].asString();
if(!credentialsNode["AccessKeyId"].isNull())
credentials_.accessKeyId = credentialsNode["AccessKeyId"].asString();
if(!credentialsNode["AccessKeySecret"].isNull())
credentials_.accessKeySecret = credentialsNode["AccessKeySecret"].asString();
if(!credentialsNode["SecurityToken"].isNull())
credentials_.securityToken = credentialsNode["SecurityToken"].asString();
if(!value["ExpireDate"].isNull())
expireDate_ = value["ExpireDate"].asString();
}
std::string GetArtifactRepositoryCredentialsResult::getExpireDate()const
{
return expireDate_;
}
std::vector<GetArtifactRepositoryCredentialsResult::AvailableResourcesItem> GetArtifactRepositoryCredentialsResult::getAvailableResources()const
{
return availableResources_;
}
GetArtifactRepositoryCredentialsResult::Credentials GetArtifactRepositoryCredentialsResult::getCredentials()const
{
return credentials_;
}

View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/GetArtifactRequest.h>
using AlibabaCloud::ComputeNestSupplier::Model::GetArtifactRequest;
GetArtifactRequest::GetArtifactRequest()
: RpcServiceRequest("computenestsupplier", "2021-05-21", "GetArtifact") {
setMethod(HttpRequest::Method::Post);
}
GetArtifactRequest::~GetArtifactRequest() {}
std::string GetArtifactRequest::getArtifactVersion() const {
return artifactVersion_;
}
void GetArtifactRequest::setArtifactVersion(const std::string &artifactVersion) {
artifactVersion_ = artifactVersion;
setParameter(std::string("ArtifactVersion"), artifactVersion);
}
std::string GetArtifactRequest::getArtifactId() const {
return artifactId_;
}
void GetArtifactRequest::setArtifactId(const std::string &artifactId) {
artifactId_ = artifactId;
setParameter(std::string("ArtifactId"), artifactId);
}

View File

@@ -0,0 +1,128 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/GetArtifactResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ComputeNestSupplier;
using namespace AlibabaCloud::ComputeNestSupplier::Model;
GetArtifactResult::GetArtifactResult() :
ServiceResult()
{}
GetArtifactResult::GetArtifactResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetArtifactResult::~GetArtifactResult()
{}
void GetArtifactResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ArtifactId"].isNull())
artifactId_ = value["ArtifactId"].asString();
if(!value["ArtifactType"].isNull())
artifactType_ = value["ArtifactType"].asString();
if(!value["Name"].isNull())
name_ = value["Name"].asString();
if(!value["VersionName"].isNull())
versionName_ = value["VersionName"].asString();
if(!value["ArtifactVersion"].isNull())
artifactVersion_ = value["ArtifactVersion"].asString();
if(!value["Description"].isNull())
description_ = value["Description"].asString();
if(!value["GmtModified"].isNull())
gmtModified_ = value["GmtModified"].asString();
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["MaxVersion"].isNull())
maxVersion_ = std::stol(value["MaxVersion"].asString());
if(!value["ArtifactProperty"].isNull())
artifactProperty_ = value["ArtifactProperty"].asString();
if(!value["SupportRegionIds"].isNull())
supportRegionIds_ = value["SupportRegionIds"].asString();
if(!value["Progress"].isNull())
progress_ = value["Progress"].asString();
}
std::string GetArtifactResult::getStatus()const
{
return status_;
}
std::string GetArtifactResult::getProgress()const
{
return progress_;
}
std::string GetArtifactResult::getArtifactVersion()const
{
return artifactVersion_;
}
std::string GetArtifactResult::getDescription()const
{
return description_;
}
std::string GetArtifactResult::getArtifactId()const
{
return artifactId_;
}
std::string GetArtifactResult::getArtifactType()const
{
return artifactType_;
}
std::string GetArtifactResult::getSupportRegionIds()const
{
return supportRegionIds_;
}
std::string GetArtifactResult::getGmtModified()const
{
return gmtModified_;
}
std::string GetArtifactResult::getVersionName()const
{
return versionName_;
}
long GetArtifactResult::getMaxVersion()const
{
return maxVersion_;
}
std::string GetArtifactResult::getArtifactProperty()const
{
return artifactProperty_;
}
std::string GetArtifactResult::getName()const
{
return name_;
}

View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/GetServiceInstanceRequest.h>
using AlibabaCloud::ComputeNestSupplier::Model::GetServiceInstanceRequest;
GetServiceInstanceRequest::GetServiceInstanceRequest()
: RpcServiceRequest("computenestsupplier", "2021-05-21", "GetServiceInstance") {
setMethod(HttpRequest::Method::Post);
}
GetServiceInstanceRequest::~GetServiceInstanceRequest() {}
std::string GetServiceInstanceRequest::getRegionId() const {
return regionId_;
}
void GetServiceInstanceRequest::setRegionId(const std::string &regionId) {
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);
}

View File

@@ -0,0 +1,294 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/GetServiceInstanceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ComputeNestSupplier;
using namespace AlibabaCloud::ComputeNestSupplier::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["ServiceProductUrl"].isNull())
service_.serviceProductUrl = serviceNode["ServiceProductUrl"].asString();
if(!serviceNode["ServiceDocUrl"].isNull())
service_.serviceDocUrl = serviceNode["ServiceDocUrl"].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();
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 networkConfigNode = value["NetworkConfig"];
if(!networkConfigNode["EndpointServiceId"].isNull())
networkConfig_.endpointServiceId = networkConfigNode["EndpointServiceId"].asString();
if(!networkConfigNode["EndpointId"].isNull())
networkConfig_.endpointId = networkConfigNode["EndpointId"].asString();
auto allPrivateVpcConnectionsNode = networkConfigNode["PrivateVpcConnections"]["PrivateVpcConnection"];
for (auto networkConfigNodePrivateVpcConnectionsPrivateVpcConnection : allPrivateVpcConnectionsNode)
{
NetworkConfig::PrivateVpcConnection privateVpcConnectionObject;
if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["EndpointId"].isNull())
privateVpcConnectionObject.endpointId = networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["EndpointId"].asString();
if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["EndpointServiceId"].isNull())
privateVpcConnectionObject.endpointServiceId = networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["EndpointServiceId"].asString();
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();
if(!networkConfigNodeReversePrivateVpcConnectionsReversePrivateVpcConnection["EndpointServiceId"].isNull())
reversePrivateVpcConnectionObject.endpointServiceId = networkConfigNodeReversePrivateVpcConnectionsReversePrivateVpcConnection["EndpointServiceId"].asString();
networkConfig_.reversePrivateVpcConnections.push_back(reversePrivateVpcConnectionObject);
}
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["ServiceInstanceId"].isNull())
serviceInstanceId_ = value["ServiceInstanceId"].asString();
if(!value["CreateTime"].isNull())
createTime_ = value["CreateTime"].asString();
if(!value["UserId"].isNull())
userId_ = std::stol(value["UserId"].asString());
if(!value["SupplierUid"].isNull())
supplierUid_ = std::stol(value["SupplierUid"].asString());
if(!value["Parameters"].isNull())
parameters_ = value["Parameters"].asString();
if(!value["Progress"].isNull())
progress_ = std::stol(value["Progress"].asString());
if(!value["StatusDetail"].isNull())
statusDetail_ = value["StatusDetail"].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["IsOperated"].isNull())
isOperated_ = value["IsOperated"].asString() == "true";
if(!value["EnableInstanceOps"].isNull())
enableInstanceOps_ = value["EnableInstanceOps"].asString() == "true";
if(!value["Resources"].isNull())
resources_ = value["Resources"].asString();
if(!value["Outputs"].isNull())
outputs_ = value["Outputs"].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["LicenseMetadata"].isNull())
licenseMetadata_ = value["LicenseMetadata"].asString();
if(!value["Name"].isNull())
name_ = value["Name"].asString();
}
std::string GetServiceInstanceResult::getOperatedServiceInstanceId()const
{
return operatedServiceInstanceId_;
}
std::string GetServiceInstanceResult::getEndTime()const
{
return endTime_;
}
std::string GetServiceInstanceResult::getOperationEndTime()const
{
return operationEndTime_;
}
bool GetServiceInstanceResult::getEnableInstanceOps()const
{
return enableInstanceOps_;
}
std::string GetServiceInstanceResult::getSource()const
{
return source_;
}
std::string GetServiceInstanceResult::getName()const
{
return name_;
}
std::string GetServiceInstanceResult::getOperationStartTime()const
{
return operationStartTime_;
}
std::string GetServiceInstanceResult::getServiceInstanceId()const
{
return serviceInstanceId_;
}
std::string GetServiceInstanceResult::getServiceType()const
{
return serviceType_;
}
std::string GetServiceInstanceResult::getLicenseMetadata()const
{
return licenseMetadata_;
}
std::string GetServiceInstanceResult::getTemplateName()const
{
return templateName_;
}
std::vector<GetServiceInstanceResult::Tag> 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_;
}
long GetServiceInstanceResult::getUserId()const
{
return userId_;
}
std::string GetServiceInstanceResult::getStatusDetail()const
{
return statusDetail_;
}
std::string GetServiceInstanceResult::getUpdateTime()const
{
return updateTime_;
}
std::string GetServiceInstanceResult::getOutputs()const
{
return outputs_;
}
long GetServiceInstanceResult::getSupplierUid()const
{
return supplierUid_;
}
bool GetServiceInstanceResult::getIsOperated()const
{
return isOperated_;
}
std::string GetServiceInstanceResult::getResources()const
{
return resources_;
}

View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/ListArtifactVersionsRequest.h>
using AlibabaCloud::ComputeNestSupplier::Model::ListArtifactVersionsRequest;
ListArtifactVersionsRequest::ListArtifactVersionsRequest()
: RpcServiceRequest("computenestsupplier", "2021-05-21", "ListArtifactVersions") {
setMethod(HttpRequest::Method::Post);
}
ListArtifactVersionsRequest::~ListArtifactVersionsRequest() {}
std::string ListArtifactVersionsRequest::getNextToken() const {
return nextToken_;
}
void ListArtifactVersionsRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
std::string ListArtifactVersionsRequest::getMaxResult() const {
return maxResult_;
}
void ListArtifactVersionsRequest::setMaxResult(const std::string &maxResult) {
maxResult_ = maxResult;
setParameter(std::string("MaxResult"), maxResult);
}
std::string ListArtifactVersionsRequest::getArtifactId() const {
return artifactId_;
}
void ListArtifactVersionsRequest::setArtifactId(const std::string &artifactId) {
artifactId_ = artifactId;
setParameter(std::string("ArtifactId"), artifactId);
}

View File

@@ -0,0 +1,102 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/ListArtifactVersionsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ComputeNestSupplier;
using namespace AlibabaCloud::ComputeNestSupplier::Model;
ListArtifactVersionsResult::ListArtifactVersionsResult() :
ServiceResult()
{}
ListArtifactVersionsResult::ListArtifactVersionsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListArtifactVersionsResult::~ListArtifactVersionsResult()
{}
void ListArtifactVersionsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allArtifactsNode = value["Artifacts"]["Artifact"];
for (auto valueArtifactsArtifact : allArtifactsNode)
{
Artifact artifactsObject;
if(!valueArtifactsArtifact["ArtifactId"].isNull())
artifactsObject.artifactId = valueArtifactsArtifact["ArtifactId"].asString();
if(!valueArtifactsArtifact["ArtifactType"].isNull())
artifactsObject.artifactType = valueArtifactsArtifact["ArtifactType"].asString();
if(!valueArtifactsArtifact["VersionName"].isNull())
artifactsObject.versionName = valueArtifactsArtifact["VersionName"].asString();
if(!valueArtifactsArtifact["ArtifactVersion"].isNull())
artifactsObject.artifactVersion = valueArtifactsArtifact["ArtifactVersion"].asString();
if(!valueArtifactsArtifact["Status"].isNull())
artifactsObject.status = valueArtifactsArtifact["Status"].asString();
if(!valueArtifactsArtifact["ArtifactProperty"].isNull())
artifactsObject.artifactProperty = valueArtifactsArtifact["ArtifactProperty"].asString();
if(!valueArtifactsArtifact["SupportRegionIds"].isNull())
artifactsObject.supportRegionIds = valueArtifactsArtifact["SupportRegionIds"].asString();
if(!valueArtifactsArtifact["GmtModified"].isNull())
artifactsObject.gmtModified = valueArtifactsArtifact["GmtModified"].asString();
if(!valueArtifactsArtifact["Progress"].isNull())
artifactsObject.progress = valueArtifactsArtifact["Progress"].asString();
if(!valueArtifactsArtifact["GmtCreate"].isNull())
artifactsObject.gmtCreate = valueArtifactsArtifact["GmtCreate"].asString();
if(!valueArtifactsArtifact["ImageDelivery"].isNull())
artifactsObject.imageDelivery = valueArtifactsArtifact["ImageDelivery"].asString();
if(!valueArtifactsArtifact["SecurityAuditResult"].isNull())
artifactsObject.securityAuditResult = valueArtifactsArtifact["SecurityAuditResult"].asString();
if(!valueArtifactsArtifact["ResultFile"].isNull())
artifactsObject.resultFile = valueArtifactsArtifact["ResultFile"].asString();
artifacts_.push_back(artifactsObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
if(!value["MaxResults"].isNull())
maxResults_ = value["MaxResults"].asString();
if(!value["TotalCount"].isNull())
totalCount_ = value["TotalCount"].asString();
}
std::vector<ListArtifactVersionsResult::Artifact> ListArtifactVersionsResult::getArtifacts()const
{
return artifacts_;
}
std::string ListArtifactVersionsResult::getTotalCount()const
{
return totalCount_;
}
std::string ListArtifactVersionsResult::getNextToken()const
{
return nextToken_;
}
std::string ListArtifactVersionsResult::getMaxResults()const
{
return maxResults_;
}

View File

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/ListArtifactsRequest.h>
using AlibabaCloud::ComputeNestSupplier::Model::ListArtifactsRequest;
ListArtifactsRequest::ListArtifactsRequest()
: RpcServiceRequest("computenestsupplier", "2021-05-21", "ListArtifacts") {
setMethod(HttpRequest::Method::Post);
}
ListArtifactsRequest::~ListArtifactsRequest() {}
std::string ListArtifactsRequest::getNextToken() const {
return nextToken_;
}
void ListArtifactsRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
std::vector<ListArtifactsRequest::Filter> ListArtifactsRequest::getFilter() const {
return filter_;
}
void ListArtifactsRequest::setFilter(const std::vector<ListArtifactsRequest::Filter> &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 ListArtifactsRequest::getMaxResults() const {
return maxResults_;
}
void ListArtifactsRequest::setMaxResults(const std::string &maxResults) {
maxResults_ = maxResults;
setParameter(std::string("MaxResults"), maxResults);
}

View File

@@ -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 <alibabacloud/computenestsupplier/model/ListArtifactsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ComputeNestSupplier;
using namespace AlibabaCloud::ComputeNestSupplier::Model;
ListArtifactsResult::ListArtifactsResult() :
ServiceResult()
{}
ListArtifactsResult::ListArtifactsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListArtifactsResult::~ListArtifactsResult()
{}
void ListArtifactsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allArtifactsNode = value["Artifacts"]["Artifact"];
for (auto valueArtifactsArtifact : allArtifactsNode)
{
Artifact artifactsObject;
if(!valueArtifactsArtifact["ArtifactId"].isNull())
artifactsObject.artifactId = valueArtifactsArtifact["ArtifactId"].asString();
if(!valueArtifactsArtifact["ArtifactType"].isNull())
artifactsObject.artifactType = valueArtifactsArtifact["ArtifactType"].asString();
if(!valueArtifactsArtifact["Name"].isNull())
artifactsObject.name = valueArtifactsArtifact["Name"].asString();
if(!valueArtifactsArtifact["MaxVersion"].isNull())
artifactsObject.maxVersion = valueArtifactsArtifact["MaxVersion"].asString();
if(!valueArtifactsArtifact["Description"].isNull())
artifactsObject.description = valueArtifactsArtifact["Description"].asString();
if(!valueArtifactsArtifact["GmtModified"].isNull())
artifactsObject.gmtModified = valueArtifactsArtifact["GmtModified"].asString();
if(!valueArtifactsArtifact["Status"].isNull())
artifactsObject.status = valueArtifactsArtifact["Status"].asString();
artifacts_.push_back(artifactsObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
if(!value["MaxResults"].isNull())
maxResults_ = value["MaxResults"].asString();
if(!value["TotalCount"].isNull())
totalCount_ = value["TotalCount"].asString();
}
std::vector<ListArtifactsResult::Artifact> ListArtifactsResult::getArtifacts()const
{
return artifacts_;
}
std::string ListArtifactsResult::getTotalCount()const
{
return totalCount_;
}
std::string ListArtifactsResult::getNextToken()const
{
return nextToken_;
}
std::string ListArtifactsResult::getMaxResults()const
{
return maxResults_;
}

View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/ListServiceInstancesRequest.h>
using AlibabaCloud::ComputeNestSupplier::Model::ListServiceInstancesRequest;
ListServiceInstancesRequest::ListServiceInstancesRequest()
: RpcServiceRequest("computenestsupplier", "2021-05-21", "ListServiceInstances") {
setMethod(HttpRequest::Method::Post);
}
ListServiceInstancesRequest::~ListServiceInstancesRequest() {}
std::string ListServiceInstancesRequest::getRegionId() const {
return regionId_;
}
void ListServiceInstancesRequest::setRegionId(const std::string &regionId) {
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::Tag> ListServiceInstancesRequest::getTag() const {
return tag_;
}
void ListServiceInstancesRequest::setTag(const std::vector<ListServiceInstancesRequest::Tag> &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::Filter> ListServiceInstancesRequest::getFilter() const {
return filter_;
}
void ListServiceInstancesRequest::setFilter(const std::vector<ListServiceInstancesRequest::Filter> &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);
}

View File

@@ -0,0 +1,157 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/ListServiceInstancesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ComputeNestSupplier;
using namespace AlibabaCloud::ComputeNestSupplier::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["Status"].isNull())
serviceInstancesObject.status = valueServiceInstancesServiceInstance["Status"].asString();
if(!valueServiceInstancesServiceInstance["UpdateTime"].isNull())
serviceInstancesObject.updateTime = valueServiceInstancesServiceInstance["UpdateTime"].asString();
if(!valueServiceInstancesServiceInstance["Name"].isNull())
serviceInstancesObject.name = valueServiceInstancesServiceInstance["Name"].asString();
if(!valueServiceInstancesServiceInstance["ServiceInstanceId"].isNull())
serviceInstancesObject.serviceInstanceId = valueServiceInstancesServiceInstance["ServiceInstanceId"].asString();
if(!valueServiceInstancesServiceInstance["CreateTime"].isNull())
serviceInstancesObject.createTime = valueServiceInstancesServiceInstance["CreateTime"].asString();
if(!valueServiceInstancesServiceInstance["UserId"].isNull())
serviceInstancesObject.userId = std::stol(valueServiceInstancesServiceInstance["UserId"].asString());
if(!valueServiceInstancesServiceInstance["Parameters"].isNull())
serviceInstancesObject.parameters = valueServiceInstancesServiceInstance["Parameters"].asString();
if(!valueServiceInstancesServiceInstance["Progress"].isNull())
serviceInstancesObject.progress = std::stol(valueServiceInstancesServiceInstance["Progress"].asString());
if(!valueServiceInstancesServiceInstance["StatusDetail"].isNull())
serviceInstancesObject.statusDetail = valueServiceInstancesServiceInstance["StatusDetail"].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();
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();
if(!serviceNode["DeployMetadata"].isNull())
serviceInstancesObject.service.deployMetadata = serviceNode["DeployMetadata"].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::stoi(value["TotalCount"].asString());
if(!value["MaxResults"].isNull())
maxResults_ = value["MaxResults"].asString();
}
int ListServiceInstancesResult::getTotalCount()const
{
return totalCount_;
}
std::vector<ListServiceInstancesResult::ServiceInstance> ListServiceInstancesResult::getServiceInstances()const
{
return serviceInstances_;
}
std::string ListServiceInstancesResult::getNextToken()const
{
return nextToken_;
}
std::string ListServiceInstancesResult::getMaxResults()const
{
return maxResults_;
}

View File

@@ -0,0 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/ReleaseArtifactRequest.h>
using AlibabaCloud::ComputeNestSupplier::Model::ReleaseArtifactRequest;
ReleaseArtifactRequest::ReleaseArtifactRequest()
: RpcServiceRequest("computenestsupplier", "2021-05-21", "ReleaseArtifact") {
setMethod(HttpRequest::Method::Post);
}
ReleaseArtifactRequest::~ReleaseArtifactRequest() {}
std::string ReleaseArtifactRequest::getArtifactId() const {
return artifactId_;
}
void ReleaseArtifactRequest::setArtifactId(const std::string &artifactId) {
artifactId_ = artifactId;
setParameter(std::string("ArtifactId"), artifactId);
}

View File

@@ -0,0 +1,100 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/ReleaseArtifactResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ComputeNestSupplier;
using namespace AlibabaCloud::ComputeNestSupplier::Model;
ReleaseArtifactResult::ReleaseArtifactResult() :
ServiceResult()
{}
ReleaseArtifactResult::ReleaseArtifactResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ReleaseArtifactResult::~ReleaseArtifactResult()
{}
void ReleaseArtifactResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ArtifactId"].isNull())
artifactId_ = value["ArtifactId"].asString();
if(!value["ArtifactType"].isNull())
artifactType_ = value["ArtifactType"].asString();
if(!value["VersionName"].isNull())
versionName_ = value["VersionName"].asString();
if(!value["ArtifactVersion"].isNull())
artifactVersion_ = value["ArtifactVersion"].asString();
if(!value["Description"].isNull())
description_ = value["Description"].asString();
if(!value["GmtModified"].isNull())
gmtModified_ = value["GmtModified"].asString();
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["ArtifactProperty"].isNull())
artifactProperty_ = value["ArtifactProperty"].asString();
}
std::string ReleaseArtifactResult::getStatus()const
{
return status_;
}
std::string ReleaseArtifactResult::getArtifactVersion()const
{
return artifactVersion_;
}
std::string ReleaseArtifactResult::getDescription()const
{
return description_;
}
std::string ReleaseArtifactResult::getArtifactId()const
{
return artifactId_;
}
std::string ReleaseArtifactResult::getArtifactType()const
{
return artifactType_;
}
std::string ReleaseArtifactResult::getGmtModified()const
{
return gmtModified_;
}
std::string ReleaseArtifactResult::getVersionName()const
{
return versionName_;
}
std::string ReleaseArtifactResult::getArtifactProperty()const
{
return artifactProperty_;
}

View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/UpdateArtifactRequest.h>
using AlibabaCloud::ComputeNestSupplier::Model::UpdateArtifactRequest;
UpdateArtifactRequest::UpdateArtifactRequest()
: RpcServiceRequest("computenestsupplier", "2021-05-21", "UpdateArtifact") {
setMethod(HttpRequest::Method::Post);
}
UpdateArtifactRequest::~UpdateArtifactRequest() {}
std::string UpdateArtifactRequest::getDescription() const {
return description_;
}
void UpdateArtifactRequest::setDescription(const std::string &description) {
description_ = description;
setParameter(std::string("Description"), description);
}
std::vector<std::string> UpdateArtifactRequest::getSupportRegionIds() const {
return supportRegionIds_;
}
void UpdateArtifactRequest::setSupportRegionIds(const std::vector<std::string> &supportRegionIds) {
supportRegionIds_ = supportRegionIds;
}
std::string UpdateArtifactRequest::getArtifactId() const {
return artifactId_;
}
void UpdateArtifactRequest::setArtifactId(const std::string &artifactId) {
artifactId_ = artifactId;
setParameter(std::string("ArtifactId"), artifactId);
}
std::string UpdateArtifactRequest::getArtifactProperty() const {
return artifactProperty_;
}
void UpdateArtifactRequest::setArtifactProperty(const std::string &artifactProperty) {
artifactProperty_ = artifactProperty;
setParameter(std::string("ArtifactProperty"), artifactProperty);
}
std::string UpdateArtifactRequest::getVersionName() const {
return versionName_;
}
void UpdateArtifactRequest::setVersionName(const std::string &versionName) {
versionName_ = versionName;
setParameter(std::string("VersionName"), versionName);
}

View File

@@ -0,0 +1,107 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/computenestsupplier/model/UpdateArtifactResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ComputeNestSupplier;
using namespace AlibabaCloud::ComputeNestSupplier::Model;
UpdateArtifactResult::UpdateArtifactResult() :
ServiceResult()
{}
UpdateArtifactResult::UpdateArtifactResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
UpdateArtifactResult::~UpdateArtifactResult()
{}
void UpdateArtifactResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ArtifactId"].isNull())
artifactId_ = value["ArtifactId"].asString();
if(!value["ArtifactType"].isNull())
artifactType_ = value["ArtifactType"].asString();
if(!value["VersionName"].isNull())
versionName_ = value["VersionName"].asString();
if(!value["ArtifactVersion"].isNull())
artifactVersion_ = value["ArtifactVersion"].asString();
if(!value["Description"].isNull())
description_ = value["Description"].asString();
if(!value["GmtModified"].isNull())
gmtModified_ = value["GmtModified"].asString();
if(!value["Status"].isNull())
status_ = value["Status"].asString();
if(!value["ArtifactProperty"].isNull())
artifactProperty_ = value["ArtifactProperty"].asString();
if(!value["SupportRegionIds"].isNull())
supportRegionIds_ = value["SupportRegionIds"].asString();
}
std::string UpdateArtifactResult::getStatus()const
{
return status_;
}
std::string UpdateArtifactResult::getArtifactVersion()const
{
return artifactVersion_;
}
std::string UpdateArtifactResult::getDescription()const
{
return description_;
}
std::string UpdateArtifactResult::getArtifactId()const
{
return artifactId_;
}
std::string UpdateArtifactResult::getArtifactType()const
{
return artifactType_;
}
std::string UpdateArtifactResult::getSupportRegionIds()const
{
return supportRegionIds_;
}
std::string UpdateArtifactResult::getGmtModified()const
{
return gmtModified_;
}
std::string UpdateArtifactResult::getVersionName()const
{
return versionName_;
}
std::string UpdateArtifactResult::getArtifactProperty()const
{
return artifactProperty_;
}