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

Add auto grouping apis.

Browse Source
This commit is contained in:
sdk-team
2025-03-03 09:36:51 +00:00
parent a09160460b
commit 444397191f
96 changed files with 3689 additions and 288 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.2043
1.36.2044

52
resourcemanager/CMakeLists.txt
View File

@@ -41,6 +41,8 @@ set(resourcemanager_public_header_model
include/alibabacloud/resourcemanager/model/ChangeAccountEmailResult.h
include/alibabacloud/resourcemanager/model/CheckAccountDeleteRequest.h
include/alibabacloud/resourcemanager/model/CheckAccountDeleteResult.h
include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleRequest.h
include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleResult.h
include/alibabacloud/resourcemanager/model/CreateCloudAccountRequest.h
include/alibabacloud/resourcemanager/model/CreateCloudAccountResult.h
include/alibabacloud/resourcemanager/model/CreateControlPolicyRequest.h
@@ -63,6 +65,8 @@ set(resourcemanager_public_header_model
include/alibabacloud/resourcemanager/model/DeclineHandshakeResult.h
include/alibabacloud/resourcemanager/model/DeleteAccountRequest.h
include/alibabacloud/resourcemanager/model/DeleteAccountResult.h
include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleRequest.h
include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleResult.h
include/alibabacloud/resourcemanager/model/DeleteControlPolicyRequest.h
include/alibabacloud/resourcemanager/model/DeleteControlPolicyResult.h
include/alibabacloud/resourcemanager/model/DeleteFolderRequest.h
@@ -85,8 +89,16 @@ set(resourcemanager_public_header_model
include/alibabacloud/resourcemanager/model/DetachControlPolicyResult.h
include/alibabacloud/resourcemanager/model/DetachPolicyRequest.h
include/alibabacloud/resourcemanager/model/DetachPolicyResult.h
include/alibabacloud/resourcemanager/model/DisableAssociatedTransferRequest.h
include/alibabacloud/resourcemanager/model/DisableAssociatedTransferResult.h
include/alibabacloud/resourcemanager/model/DisableAutoGroupingRequest.h
include/alibabacloud/resourcemanager/model/DisableAutoGroupingResult.h
include/alibabacloud/resourcemanager/model/DisableControlPolicyRequest.h
include/alibabacloud/resourcemanager/model/DisableControlPolicyResult.h
include/alibabacloud/resourcemanager/model/EnableAssociatedTransferRequest.h
include/alibabacloud/resourcemanager/model/EnableAssociatedTransferResult.h
include/alibabacloud/resourcemanager/model/EnableAutoGroupingRequest.h
include/alibabacloud/resourcemanager/model/EnableAutoGroupingResult.h
include/alibabacloud/resourcemanager/model/EnableControlPolicyRequest.h
include/alibabacloud/resourcemanager/model/EnableControlPolicyResult.h
include/alibabacloud/resourcemanager/model/EnableResourceDirectoryRequest.h
@@ -97,6 +109,10 @@ set(resourcemanager_public_header_model
include/alibabacloud/resourcemanager/model/GetAccountDeletionCheckResultResult.h
include/alibabacloud/resourcemanager/model/GetAccountDeletionStatusRequest.h
include/alibabacloud/resourcemanager/model/GetAccountDeletionStatusResult.h
include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleRequest.h
include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleResult.h
include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusRequest.h
include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusResult.h
include/alibabacloud/resourcemanager/model/GetControlPolicyRequest.h
include/alibabacloud/resourcemanager/model/GetControlPolicyResult.h
include/alibabacloud/resourcemanager/model/GetControlPolicyEnablementStatusRequest.h
@@ -129,6 +145,10 @@ set(resourcemanager_public_header_model
include/alibabacloud/resourcemanager/model/ListAccountsForParentResult.h
include/alibabacloud/resourcemanager/model/ListAncestorsRequest.h
include/alibabacloud/resourcemanager/model/ListAncestorsResult.h
include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingRequest.h
include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingResult.h
include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesRequest.h
include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesResult.h
include/alibabacloud/resourcemanager/model/ListControlPoliciesRequest.h
include/alibabacloud/resourcemanager/model/ListControlPoliciesResult.h
include/alibabacloud/resourcemanager/model/ListControlPolicyAttachmentsForTargetRequest.h
@@ -195,6 +215,12 @@ set(resourcemanager_public_header_model
include/alibabacloud/resourcemanager/model/UntagResourcesResult.h
include/alibabacloud/resourcemanager/model/UpdateAccountRequest.h
include/alibabacloud/resourcemanager/model/UpdateAccountResult.h
include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingRequest.h
include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingResult.h
include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigRequest.h
include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigResult.h
include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleRequest.h
include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleResult.h
include/alibabacloud/resourcemanager/model/UpdateControlPolicyRequest.h
include/alibabacloud/resourcemanager/model/UpdateControlPolicyResult.h
include/alibabacloud/resourcemanager/model/UpdateFolderRequest.h
@@ -226,6 +252,8 @@ set(resourcemanager_src
src/model/ChangeAccountEmailResult.cc
src/model/CheckAccountDeleteRequest.cc
src/model/CheckAccountDeleteResult.cc
src/model/CreateAutoGroupingRuleRequest.cc
src/model/CreateAutoGroupingRuleResult.cc
src/model/CreateCloudAccountRequest.cc
src/model/CreateCloudAccountResult.cc
src/model/CreateControlPolicyRequest.cc
@@ -248,6 +276,8 @@ set(resourcemanager_src
src/model/DeclineHandshakeResult.cc
src/model/DeleteAccountRequest.cc
src/model/DeleteAccountResult.cc
src/model/DeleteAutoGroupingRuleRequest.cc
src/model/DeleteAutoGroupingRuleResult.cc
src/model/DeleteControlPolicyRequest.cc
src/model/DeleteControlPolicyResult.cc
src/model/DeleteFolderRequest.cc
@@ -270,8 +300,16 @@ set(resourcemanager_src
src/model/DetachControlPolicyResult.cc
src/model/DetachPolicyRequest.cc
src/model/DetachPolicyResult.cc
src/model/DisableAssociatedTransferRequest.cc
src/model/DisableAssociatedTransferResult.cc
src/model/DisableAutoGroupingRequest.cc
src/model/DisableAutoGroupingResult.cc
src/model/DisableControlPolicyRequest.cc
src/model/DisableControlPolicyResult.cc
src/model/EnableAssociatedTransferRequest.cc
src/model/EnableAssociatedTransferResult.cc
src/model/EnableAutoGroupingRequest.cc
src/model/EnableAutoGroupingResult.cc
src/model/EnableControlPolicyRequest.cc
src/model/EnableControlPolicyResult.cc
src/model/EnableResourceDirectoryRequest.cc
@@ -282,6 +320,10 @@ set(resourcemanager_src
src/model/GetAccountDeletionCheckResultResult.cc
src/model/GetAccountDeletionStatusRequest.cc
src/model/GetAccountDeletionStatusResult.cc
src/model/GetAutoGroupingRuleRequest.cc
src/model/GetAutoGroupingRuleResult.cc
src/model/GetAutoGroupingStatusRequest.cc
src/model/GetAutoGroupingStatusResult.cc
src/model/GetControlPolicyRequest.cc
src/model/GetControlPolicyResult.cc
src/model/GetControlPolicyEnablementStatusRequest.cc
@@ -314,6 +356,10 @@ set(resourcemanager_src
src/model/ListAccountsForParentResult.cc
src/model/ListAncestorsRequest.cc
src/model/ListAncestorsResult.cc
src/model/ListAssociatedTransferSettingRequest.cc
src/model/ListAssociatedTransferSettingResult.cc
src/model/ListAutoGroupingRulesRequest.cc
src/model/ListAutoGroupingRulesResult.cc
src/model/ListControlPoliciesRequest.cc
src/model/ListControlPoliciesResult.cc
src/model/ListControlPolicyAttachmentsForTargetRequest.cc
@@ -380,6 +426,12 @@ set(resourcemanager_src
src/model/UntagResourcesResult.cc
src/model/UpdateAccountRequest.cc
src/model/UpdateAccountResult.cc
src/model/UpdateAssociatedTransferSettingRequest.cc
src/model/UpdateAssociatedTransferSettingResult.cc
src/model/UpdateAutoGroupingConfigRequest.cc
src/model/UpdateAutoGroupingConfigResult.cc
src/model/UpdateAutoGroupingRuleRequest.cc
src/model/UpdateAutoGroupingRuleResult.cc
src/model/UpdateControlPolicyRequest.cc
src/model/UpdateControlPolicyResult.cc
src/model/UpdateFolderRequest.cc

104
resourcemanager/include/alibabacloud/resourcemanager/ResourceManagerClient.h
View File

@@ -42,6 +42,8 @@
#include "model/ChangeAccountEmailResult.h"
#include "model/CheckAccountDeleteRequest.h"
#include "model/CheckAccountDeleteResult.h"
#include "model/CreateAutoGroupingRuleRequest.h"
#include "model/CreateAutoGroupingRuleResult.h"
#include "model/CreateCloudAccountRequest.h"
#include "model/CreateCloudAccountResult.h"
#include "model/CreateControlPolicyRequest.h"
@@ -64,6 +66,8 @@
#include "model/DeclineHandshakeResult.h"
#include "model/DeleteAccountRequest.h"
#include "model/DeleteAccountResult.h"
#include "model/DeleteAutoGroupingRuleRequest.h"
#include "model/DeleteAutoGroupingRuleResult.h"
#include "model/DeleteControlPolicyRequest.h"
#include "model/DeleteControlPolicyResult.h"
#include "model/DeleteFolderRequest.h"
@@ -86,8 +90,16 @@
#include "model/DetachControlPolicyResult.h"
#include "model/DetachPolicyRequest.h"
#include "model/DetachPolicyResult.h"
#include "model/DisableAssociatedTransferRequest.h"
#include "model/DisableAssociatedTransferResult.h"
#include "model/DisableAutoGroupingRequest.h"
#include "model/DisableAutoGroupingResult.h"
#include "model/DisableControlPolicyRequest.h"
#include "model/DisableControlPolicyResult.h"
#include "model/EnableAssociatedTransferRequest.h"
#include "model/EnableAssociatedTransferResult.h"
#include "model/EnableAutoGroupingRequest.h"
#include "model/EnableAutoGroupingResult.h"
#include "model/EnableControlPolicyRequest.h"
#include "model/EnableControlPolicyResult.h"
#include "model/EnableResourceDirectoryRequest.h"
@@ -98,6 +110,10 @@
#include "model/GetAccountDeletionCheckResultResult.h"
#include "model/GetAccountDeletionStatusRequest.h"
#include "model/GetAccountDeletionStatusResult.h"
#include "model/GetAutoGroupingRuleRequest.h"
#include "model/GetAutoGroupingRuleResult.h"
#include "model/GetAutoGroupingStatusRequest.h"
#include "model/GetAutoGroupingStatusResult.h"
#include "model/GetControlPolicyRequest.h"
#include "model/GetControlPolicyResult.h"
#include "model/GetControlPolicyEnablementStatusRequest.h"
@@ -130,6 +146,10 @@
#include "model/ListAccountsForParentResult.h"
#include "model/ListAncestorsRequest.h"
#include "model/ListAncestorsResult.h"
#include "model/ListAssociatedTransferSettingRequest.h"
#include "model/ListAssociatedTransferSettingResult.h"
#include "model/ListAutoGroupingRulesRequest.h"
#include "model/ListAutoGroupingRulesResult.h"
#include "model/ListControlPoliciesRequest.h"
#include "model/ListControlPoliciesResult.h"
#include "model/ListControlPolicyAttachmentsForTargetRequest.h"
@@ -196,6 +216,12 @@
#include "model/UntagResourcesResult.h"
#include "model/UpdateAccountRequest.h"
#include "model/UpdateAccountResult.h"
#include "model/UpdateAssociatedTransferSettingRequest.h"
#include "model/UpdateAssociatedTransferSettingResult.h"
#include "model/UpdateAutoGroupingConfigRequest.h"
#include "model/UpdateAutoGroupingConfigResult.h"
#include "model/UpdateAutoGroupingRuleRequest.h"
#include "model/UpdateAutoGroupingRuleResult.h"
#include "model/UpdateControlPolicyRequest.h"
#include "model/UpdateControlPolicyResult.h"
#include "model/UpdateFolderRequest.h"
@@ -243,6 +269,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CheckAccountDeleteResult> CheckAccountDeleteOutcome;
typedef std::future<CheckAccountDeleteOutcome> CheckAccountDeleteOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::CheckAccountDeleteRequest&, const CheckAccountDeleteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckAccountDeleteAsyncHandler;
typedef Outcome<Error, Model::CreateAutoGroupingRuleResult> CreateAutoGroupingRuleOutcome;
typedef std::future<CreateAutoGroupingRuleOutcome> CreateAutoGroupingRuleOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::CreateAutoGroupingRuleRequest&, const CreateAutoGroupingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAutoGroupingRuleAsyncHandler;
typedef Outcome<Error, Model::CreateCloudAccountResult> CreateCloudAccountOutcome;
typedef std::future<CreateCloudAccountOutcome> CreateCloudAccountOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::CreateCloudAccountRequest&, const CreateCloudAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCloudAccountAsyncHandler;
@@ -276,6 +305,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteAccountResult> DeleteAccountOutcome;
typedef std::future<DeleteAccountOutcome> DeleteAccountOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::DeleteAccountRequest&, const DeleteAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAccountAsyncHandler;
typedef Outcome<Error, Model::DeleteAutoGroupingRuleResult> DeleteAutoGroupingRuleOutcome;
typedef std::future<DeleteAutoGroupingRuleOutcome> DeleteAutoGroupingRuleOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::DeleteAutoGroupingRuleRequest&, const DeleteAutoGroupingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAutoGroupingRuleAsyncHandler;
typedef Outcome<Error, Model::DeleteControlPolicyResult> DeleteControlPolicyOutcome;
typedef std::future<DeleteControlPolicyOutcome> DeleteControlPolicyOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::DeleteControlPolicyRequest&, const DeleteControlPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteControlPolicyAsyncHandler;
@@ -309,9 +341,21 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DetachPolicyResult> DetachPolicyOutcome;
typedef std::future<DetachPolicyOutcome> DetachPolicyOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::DetachPolicyRequest&, const DetachPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachPolicyAsyncHandler;
typedef Outcome<Error, Model::DisableAssociatedTransferResult> DisableAssociatedTransferOutcome;
typedef std::future<DisableAssociatedTransferOutcome> DisableAssociatedTransferOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::DisableAssociatedTransferRequest&, const DisableAssociatedTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableAssociatedTransferAsyncHandler;
typedef Outcome<Error, Model::DisableAutoGroupingResult> DisableAutoGroupingOutcome;
typedef std::future<DisableAutoGroupingOutcome> DisableAutoGroupingOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::DisableAutoGroupingRequest&, const DisableAutoGroupingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableAutoGroupingAsyncHandler;
typedef Outcome<Error, Model::DisableControlPolicyResult> DisableControlPolicyOutcome;
typedef std::future<DisableControlPolicyOutcome> DisableControlPolicyOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::DisableControlPolicyRequest&, const DisableControlPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableControlPolicyAsyncHandler;
typedef Outcome<Error, Model::EnableAssociatedTransferResult> EnableAssociatedTransferOutcome;
typedef std::future<EnableAssociatedTransferOutcome> EnableAssociatedTransferOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::EnableAssociatedTransferRequest&, const EnableAssociatedTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableAssociatedTransferAsyncHandler;
typedef Outcome<Error, Model::EnableAutoGroupingResult> EnableAutoGroupingOutcome;
typedef std::future<EnableAutoGroupingOutcome> EnableAutoGroupingOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::EnableAutoGroupingRequest&, const EnableAutoGroupingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableAutoGroupingAsyncHandler;
typedef Outcome<Error, Model::EnableControlPolicyResult> EnableControlPolicyOutcome;
typedef std::future<EnableControlPolicyOutcome> EnableControlPolicyOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::EnableControlPolicyRequest&, const EnableControlPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableControlPolicyAsyncHandler;
@@ -327,6 +371,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::GetAccountDeletionStatusResult> GetAccountDeletionStatusOutcome;
typedef std::future<GetAccountDeletionStatusOutcome> GetAccountDeletionStatusOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::GetAccountDeletionStatusRequest&, const GetAccountDeletionStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAccountDeletionStatusAsyncHandler;
typedef Outcome<Error, Model::GetAutoGroupingRuleResult> GetAutoGroupingRuleOutcome;
typedef std::future<GetAutoGroupingRuleOutcome> GetAutoGroupingRuleOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::GetAutoGroupingRuleRequest&, const GetAutoGroupingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAutoGroupingRuleAsyncHandler;
typedef Outcome<Error, Model::GetAutoGroupingStatusResult> GetAutoGroupingStatusOutcome;
typedef std::future<GetAutoGroupingStatusOutcome> GetAutoGroupingStatusOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::GetAutoGroupingStatusRequest&, const GetAutoGroupingStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAutoGroupingStatusAsyncHandler;
typedef Outcome<Error, Model::GetControlPolicyResult> GetControlPolicyOutcome;
typedef std::future<GetControlPolicyOutcome> GetControlPolicyOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::GetControlPolicyRequest&, const GetControlPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetControlPolicyAsyncHandler;
@@ -375,6 +425,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ListAncestorsResult> ListAncestorsOutcome;
typedef std::future<ListAncestorsOutcome> ListAncestorsOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::ListAncestorsRequest&, const ListAncestorsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAncestorsAsyncHandler;
typedef Outcome<Error, Model::ListAssociatedTransferSettingResult> ListAssociatedTransferSettingOutcome;
typedef std::future<ListAssociatedTransferSettingOutcome> ListAssociatedTransferSettingOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::ListAssociatedTransferSettingRequest&, const ListAssociatedTransferSettingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAssociatedTransferSettingAsyncHandler;
typedef Outcome<Error, Model::ListAutoGroupingRulesResult> ListAutoGroupingRulesOutcome;
typedef std::future<ListAutoGroupingRulesOutcome> ListAutoGroupingRulesOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::ListAutoGroupingRulesRequest&, const ListAutoGroupingRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAutoGroupingRulesAsyncHandler;
typedef Outcome<Error, Model::ListControlPoliciesResult> ListControlPoliciesOutcome;
typedef std::future<ListControlPoliciesOutcome> ListControlPoliciesOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::ListControlPoliciesRequest&, const ListControlPoliciesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListControlPoliciesAsyncHandler;
@@ -474,6 +530,15 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::UpdateAccountResult> UpdateAccountOutcome;
typedef std::future<UpdateAccountOutcome> UpdateAccountOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::UpdateAccountRequest&, const UpdateAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAccountAsyncHandler;
typedef Outcome<Error, Model::UpdateAssociatedTransferSettingResult> UpdateAssociatedTransferSettingOutcome;
typedef std::future<UpdateAssociatedTransferSettingOutcome> UpdateAssociatedTransferSettingOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::UpdateAssociatedTransferSettingRequest&, const UpdateAssociatedTransferSettingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAssociatedTransferSettingAsyncHandler;
typedef Outcome<Error, Model::UpdateAutoGroupingConfigResult> UpdateAutoGroupingConfigOutcome;
typedef std::future<UpdateAutoGroupingConfigOutcome> UpdateAutoGroupingConfigOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::UpdateAutoGroupingConfigRequest&, const UpdateAutoGroupingConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAutoGroupingConfigAsyncHandler;
typedef Outcome<Error, Model::UpdateAutoGroupingRuleResult> UpdateAutoGroupingRuleOutcome;
typedef std::future<UpdateAutoGroupingRuleOutcome> UpdateAutoGroupingRuleOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::UpdateAutoGroupingRuleRequest&, const UpdateAutoGroupingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAutoGroupingRuleAsyncHandler;
typedef Outcome<Error, Model::UpdateControlPolicyResult> UpdateControlPolicyOutcome;
typedef std::future<UpdateControlPolicyOutcome> UpdateControlPolicyOutcomeCallable;
typedef std::function<void(const ResourceManagerClient*, const Model::UpdateControlPolicyRequest&, const UpdateControlPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateControlPolicyAsyncHandler;
@@ -521,6 +586,9 @@ namespace AlibabaCloud
CheckAccountDeleteOutcome checkAccountDelete(const Model::CheckAccountDeleteRequest &request)const;
void checkAccountDeleteAsync(const Model::CheckAccountDeleteRequest& request, const CheckAccountDeleteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckAccountDeleteOutcomeCallable checkAccountDeleteCallable(const Model::CheckAccountDeleteRequest& request) const;
CreateAutoGroupingRuleOutcome createAutoGroupingRule(const Model::CreateAutoGroupingRuleRequest &request)const;
void createAutoGroupingRuleAsync(const Model::CreateAutoGroupingRuleRequest& request, const CreateAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateAutoGroupingRuleOutcomeCallable createAutoGroupingRuleCallable(const Model::CreateAutoGroupingRuleRequest& request) const;
CreateCloudAccountOutcome createCloudAccount(const Model::CreateCloudAccountRequest &request)const;
void createCloudAccountAsync(const Model::CreateCloudAccountRequest& request, const CreateCloudAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateCloudAccountOutcomeCallable createCloudAccountCallable(const Model::CreateCloudAccountRequest& request) const;
@@ -554,6 +622,9 @@ namespace AlibabaCloud
DeleteAccountOutcome deleteAccount(const Model::DeleteAccountRequest &request)const;
void deleteAccountAsync(const Model::DeleteAccountRequest& request, const DeleteAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteAccountOutcomeCallable deleteAccountCallable(const Model::DeleteAccountRequest& request) const;
DeleteAutoGroupingRuleOutcome deleteAutoGroupingRule(const Model::DeleteAutoGroupingRuleRequest &request)const;
void deleteAutoGroupingRuleAsync(const Model::DeleteAutoGroupingRuleRequest& request, const DeleteAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteAutoGroupingRuleOutcomeCallable deleteAutoGroupingRuleCallable(const Model::DeleteAutoGroupingRuleRequest& request) const;
DeleteControlPolicyOutcome deleteControlPolicy(const Model::DeleteControlPolicyRequest &request)const;
void deleteControlPolicyAsync(const Model::DeleteControlPolicyRequest& request, const DeleteControlPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteControlPolicyOutcomeCallable deleteControlPolicyCallable(const Model::DeleteControlPolicyRequest& request) const;
@@ -587,9 +658,21 @@ namespace AlibabaCloud
DetachPolicyOutcome detachPolicy(const Model::DetachPolicyRequest &request)const;
void detachPolicyAsync(const Model::DetachPolicyRequest& request, const DetachPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetachPolicyOutcomeCallable detachPolicyCallable(const Model::DetachPolicyRequest& request) const;
DisableAssociatedTransferOutcome disableAssociatedTransfer(const Model::DisableAssociatedTransferRequest &request)const;
void disableAssociatedTransferAsync(const Model::DisableAssociatedTransferRequest& request, const DisableAssociatedTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DisableAssociatedTransferOutcomeCallable disableAssociatedTransferCallable(const Model::DisableAssociatedTransferRequest& request) const;
DisableAutoGroupingOutcome disableAutoGrouping(const Model::DisableAutoGroupingRequest &request)const;
void disableAutoGroupingAsync(const Model::DisableAutoGroupingRequest& request, const DisableAutoGroupingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DisableAutoGroupingOutcomeCallable disableAutoGroupingCallable(const Model::DisableAutoGroupingRequest& request) const;
DisableControlPolicyOutcome disableControlPolicy(const Model::DisableControlPolicyRequest &request)const;
void disableControlPolicyAsync(const Model::DisableControlPolicyRequest& request, const DisableControlPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DisableControlPolicyOutcomeCallable disableControlPolicyCallable(const Model::DisableControlPolicyRequest& request) const;
EnableAssociatedTransferOutcome enableAssociatedTransfer(const Model::EnableAssociatedTransferRequest &request)const;
void enableAssociatedTransferAsync(const Model::EnableAssociatedTransferRequest& request, const EnableAssociatedTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableAssociatedTransferOutcomeCallable enableAssociatedTransferCallable(const Model::EnableAssociatedTransferRequest& request) const;
EnableAutoGroupingOutcome enableAutoGrouping(const Model::EnableAutoGroupingRequest &request)const;
void enableAutoGroupingAsync(const Model::EnableAutoGroupingRequest& request, const EnableAutoGroupingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableAutoGroupingOutcomeCallable enableAutoGroupingCallable(const Model::EnableAutoGroupingRequest& request) const;
EnableControlPolicyOutcome enableControlPolicy(const Model::EnableControlPolicyRequest &request)const;
void enableControlPolicyAsync(const Model::EnableControlPolicyRequest& request, const EnableControlPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableControlPolicyOutcomeCallable enableControlPolicyCallable(const Model::EnableControlPolicyRequest& request) const;
@@ -605,6 +688,12 @@ namespace AlibabaCloud
GetAccountDeletionStatusOutcome getAccountDeletionStatus(const Model::GetAccountDeletionStatusRequest &request)const;
void getAccountDeletionStatusAsync(const Model::GetAccountDeletionStatusRequest& request, const GetAccountDeletionStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAccountDeletionStatusOutcomeCallable getAccountDeletionStatusCallable(const Model::GetAccountDeletionStatusRequest& request) const;
GetAutoGroupingRuleOutcome getAutoGroupingRule(const Model::GetAutoGroupingRuleRequest &request)const;
void getAutoGroupingRuleAsync(const Model::GetAutoGroupingRuleRequest& request, const GetAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAutoGroupingRuleOutcomeCallable getAutoGroupingRuleCallable(const Model::GetAutoGroupingRuleRequest& request) const;
GetAutoGroupingStatusOutcome getAutoGroupingStatus(const Model::GetAutoGroupingStatusRequest &request)const;
void getAutoGroupingStatusAsync(const Model::GetAutoGroupingStatusRequest& request, const GetAutoGroupingStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAutoGroupingStatusOutcomeCallable getAutoGroupingStatusCallable(const Model::GetAutoGroupingStatusRequest& request) const;
GetControlPolicyOutcome getControlPolicy(const Model::GetControlPolicyRequest &request)const;
void getControlPolicyAsync(const Model::GetControlPolicyRequest& request, const GetControlPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetControlPolicyOutcomeCallable getControlPolicyCallable(const Model::GetControlPolicyRequest& request) const;
@@ -653,6 +742,12 @@ namespace AlibabaCloud
ListAncestorsOutcome listAncestors(const Model::ListAncestorsRequest &request)const;
void listAncestorsAsync(const Model::ListAncestorsRequest& request, const ListAncestorsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListAncestorsOutcomeCallable listAncestorsCallable(const Model::ListAncestorsRequest& request) const;
ListAssociatedTransferSettingOutcome listAssociatedTransferSetting(const Model::ListAssociatedTransferSettingRequest &request)const;
void listAssociatedTransferSettingAsync(const Model::ListAssociatedTransferSettingRequest& request, const ListAssociatedTransferSettingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListAssociatedTransferSettingOutcomeCallable listAssociatedTransferSettingCallable(const Model::ListAssociatedTransferSettingRequest& request) const;
ListAutoGroupingRulesOutcome listAutoGroupingRules(const Model::ListAutoGroupingRulesRequest &request)const;
void listAutoGroupingRulesAsync(const Model::ListAutoGroupingRulesRequest& request, const ListAutoGroupingRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListAutoGroupingRulesOutcomeCallable listAutoGroupingRulesCallable(const Model::ListAutoGroupingRulesRequest& request) const;
ListControlPoliciesOutcome listControlPolicies(const Model::ListControlPoliciesRequest &request)const;
void listControlPoliciesAsync(const Model::ListControlPoliciesRequest& request, const ListControlPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListControlPoliciesOutcomeCallable listControlPoliciesCallable(const Model::ListControlPoliciesRequest& request) const;
@@ -752,6 +847,15 @@ namespace AlibabaCloud
UpdateAccountOutcome updateAccount(const Model::UpdateAccountRequest &request)const;
void updateAccountAsync(const Model::UpdateAccountRequest& request, const UpdateAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateAccountOutcomeCallable updateAccountCallable(const Model::UpdateAccountRequest& request) const;
UpdateAssociatedTransferSettingOutcome updateAssociatedTransferSetting(const Model::UpdateAssociatedTransferSettingRequest &request)const;
void updateAssociatedTransferSettingAsync(const Model::UpdateAssociatedTransferSettingRequest& request, const UpdateAssociatedTransferSettingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateAssociatedTransferSettingOutcomeCallable updateAssociatedTransferSettingCallable(const Model::UpdateAssociatedTransferSettingRequest& request) const;
UpdateAutoGroupingConfigOutcome updateAutoGroupingConfig(const Model::UpdateAutoGroupingConfigRequest &request)const;
void updateAutoGroupingConfigAsync(const Model::UpdateAutoGroupingConfigRequest& request, const UpdateAutoGroupingConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateAutoGroupingConfigOutcomeCallable updateAutoGroupingConfigCallable(const Model::UpdateAutoGroupingConfigRequest& request) const;
UpdateAutoGroupingRuleOutcome updateAutoGroupingRule(const Model::UpdateAutoGroupingRuleRequest &request)const;
void updateAutoGroupingRuleAsync(const Model::UpdateAutoGroupingRuleRequest& request, const UpdateAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateAutoGroupingRuleOutcomeCallable updateAutoGroupingRuleCallable(const Model::UpdateAutoGroupingRuleRequest& request) const;
UpdateControlPolicyOutcome updateControlPolicy(const Model::UpdateControlPolicyRequest &request)const;
void updateControlPolicyAsync(const Model::UpdateControlPolicyRequest& request, const UpdateControlPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateControlPolicyOutcomeCallable updateControlPolicyCallable(const Model::UpdateControlPolicyRequest& request) const;

6
resourcemanager/include/alibabacloud/resourcemanager/model/AttachPolicyRequest.h
View File

@@ -30,21 +30,21 @@ class ALIBABACLOUD_RESOURCEMANAGER_EXPORT AttachPolicyRequest : public RpcServic
public:
AttachPolicyRequest();
~AttachPolicyRequest();
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getPolicyType() const;
void setPolicyType(const std::string &policyType);
std::string getPrincipalType() const;
void setPrincipalType(const std::string &principalType);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getPolicyName() const;
void setPolicyName(const std::string &policyName);
std::string getPrincipalName() const;
void setPrincipalName(const std::string &principalName);
private:
std::string resourceGroupId_;
std::string policyType_;
std::string principalType_;
std::string resourceGroupId_;
std::string policyName_;
std::string principalName_;
};

79
resourcemanager/include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleRequest.h Normal file
View File

@@ -0,0 +1,79 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_RESOURCEMANAGER_MODEL_CREATEAUTOGROUPINGRULEREQUEST_H_
#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_CREATEAUTOGROUPINGRULEREQUEST_H_
#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ResourceManager {
namespace Model {
class ALIBABACLOUD_RESOURCEMANAGER_EXPORT CreateAutoGroupingRuleRequest : public RpcServiceRequest {
public:
struct RuleContents {
std::string targetResourceGroupCondition;
std::string autoGroupingScopeCondition;
};
CreateAutoGroupingRuleRequest();
~CreateAutoGroupingRuleRequest();
std::string getRuleDesc() const;
void setRuleDesc(const std::string &ruleDesc);
std::string getResourceTypesScope() const;
void setResourceTypesScope(const std::string &resourceTypesScope);
std::string getRuleName() const;
void setRuleName(const std::string &ruleName);
std::string getExcludeResourceGroupIdsScope() const;
void setExcludeResourceGroupIdsScope(const std::string &excludeResourceGroupIdsScope);
std::string getRegionIdsScope() const;
void setRegionIdsScope(const std::string &regionIdsScope);
std::string getResourceIdsScope() const;
void setResourceIdsScope(const std::string &resourceIdsScope);
std::vector<RuleContents> getRuleContents() const;
void setRuleContents(const std::vector<RuleContents> &ruleContents);
std::string getExcludeResourceTypesScope() const;
void setExcludeResourceTypesScope(const std::string &excludeResourceTypesScope);
std::string getRuleType() const;
void setRuleType(const std::string &ruleType);
std::string getResourceGroupIdsScope() const;
void setResourceGroupIdsScope(const std::string &resourceGroupIdsScope);
std::string getExcludeRegionIdsScope() const;
void setExcludeRegionIdsScope(const std::string &excludeRegionIdsScope);
std::string getExcludeResourceIdsScope() const;
void setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope);
private:
std::string ruleDesc_;
std::string resourceTypesScope_;
std::string ruleName_;
std::string excludeResourceGroupIdsScope_;
std::string regionIdsScope_;
std::string resourceIdsScope_;
std::vector<RuleContents> ruleContents_;
std::string excludeResourceTypesScope_;
std::string ruleType_;
std::string resourceGroupIdsScope_;
std::string excludeRegionIdsScope_;
std::string excludeResourceIdsScope_;
};
} // namespace Model
} // namespace ResourceManager
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_CREATEAUTOGROUPINGRULEREQUEST_H_

51
resourcemanager/include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleResult.h Normal file
View File

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

2
resourcemanager/include/alibabacloud/resourcemanager/model/CreateCloudAccountResult.h
View File

@@ -37,8 +37,8 @@ namespace AlibabaCloud
std::string status;
std::string joinMethod;
std::string modifyTime;
std::string type;
std::string resourceDirectoryId;
std::string type;
std::string accountId;
std::string displayName;
std::string folderId;

7
resourcemanager/include/alibabacloud/resourcemanager/model/CreateResourceGroupRequest.h
View File

@@ -28,16 +28,23 @@ namespace ResourceManager {
namespace Model {
class ALIBABACLOUD_RESOURCEMANAGER_EXPORT CreateResourceGroupRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
CreateResourceGroupRequest();
~CreateResourceGroupRequest();
std::string getDisplayName() const;
void setDisplayName(const std::string &displayName);
std::string getName() const;
void setName(const std::string &name);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
private:
std::string displayName_;
std::string name_;
std::vector<Tag> tag_;
};
} // namespace Model
} // namespace ResourceManager

42
resourcemanager/include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleRequest.h Normal file
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_RESOURCEMANAGER_MODEL_DELETEAUTOGROUPINGRULEREQUEST_H_
#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_DELETEAUTOGROUPINGRULEREQUEST_H_
#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ResourceManager {
namespace Model {
class ALIBABACLOUD_RESOURCEMANAGER_EXPORT DeleteAutoGroupingRuleRequest : public RpcServiceRequest {
public:
DeleteAutoGroupingRuleRequest();
~DeleteAutoGroupingRuleRequest();
std::string getRuleId() const;
void setRuleId(const std::string &ruleId);
private:
std::string ruleId_;
};
} // namespace Model
} // namespace ResourceManager
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_DELETEAUTOGROUPINGRULEREQUEST_H_

49
resourcemanager/include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleResult.h Normal file
View File

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

6
resourcemanager/include/alibabacloud/resourcemanager/model/DetachPolicyRequest.h
View File

@@ -30,21 +30,21 @@ class ALIBABACLOUD_RESOURCEMANAGER_EXPORT DetachPolicyRequest : public RpcServic
public:
DetachPolicyRequest();
~DetachPolicyRequest();
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getPolicyType() const;
void setPolicyType(const std::string &policyType);
std::string getPrincipalType() const;
void setPrincipalType(const std::string &principalType);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getPolicyName() const;
void setPolicyName(const std::string &policyName);
std::string getPrincipalName() const;
void setPrincipalName(const std::string &principalName);
private:
std::string resourceGroupId_;
std::string policyType_;
std::string principalType_;
std::string resourceGroupId_;
std::string policyName_;
std::string principalName_;
};

39
resourcemanager/include/alibabacloud/resourcemanager/model/DisableAssociatedTransferRequest.h Normal file
View File

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

49
resourcemanager/include/alibabacloud/resourcemanager/model/DisableAssociatedTransferResult.h Normal file
View File

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

39
resourcemanager/include/alibabacloud/resourcemanager/model/DisableAutoGroupingRequest.h Normal file
View File

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

49
resourcemanager/include/alibabacloud/resourcemanager/model/DisableAutoGroupingResult.h Normal file
View File

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

39
resourcemanager/include/alibabacloud/resourcemanager/model/EnableAssociatedTransferRequest.h Normal file
View File

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

49
resourcemanager/include/alibabacloud/resourcemanager/model/EnableAssociatedTransferResult.h Normal file
View File

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

39
resourcemanager/include/alibabacloud/resourcemanager/model/EnableAutoGroupingRequest.h Normal file
View File

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

49
resourcemanager/include/alibabacloud/resourcemanager/model/EnableAutoGroupingResult.h Normal file
View File

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

42
resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleRequest.h Normal file
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_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGRULEREQUEST_H_
#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGRULEREQUEST_H_
#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ResourceManager {
namespace Model {
class ALIBABACLOUD_RESOURCEMANAGER_EXPORT GetAutoGroupingRuleRequest : public RpcServiceRequest {
public:
GetAutoGroupingRuleRequest();
~GetAutoGroupingRuleRequest();
std::string getRuleId() const;
void setRuleId(const std::string &ruleId);
private:
std::string ruleId_;
};
} // namespace Model
} // namespace ResourceManager
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGRULEREQUEST_H_

75
resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleResult.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGRULERESULT_H_
#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGRULERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
namespace AlibabaCloud
{
namespace ResourceManager
{
namespace Model
{
class ALIBABACLOUD_RESOURCEMANAGER_EXPORT GetAutoGroupingRuleResult : public ServiceResult
{
public:
struct Rule
{
struct RuleContent
{
std::string autoGroupingScopeCondition;
std::string ruleContentId;
std::string targetResourceGroupCondition;
};
std::string modifyTime;
std::string excludeResourceGroupIdsScope;
std::string excludeResourceIdsScope;
std::string excludeResourceTypesScope;
std::string resourceIdsScope;
std::vector<RuleContent> ruleContents;
std::string createTime;
std::string ruleId;
std::string ruleType;
std::string excludeRegionIdsScope;
std::string regionIdsScope;
std::string resourceGroupIdsScope;
std::string ruleDesc;
std::string resourceTypesScope;
std::string ruleName;
};
GetAutoGroupingRuleResult();
explicit GetAutoGroupingRuleResult(const std::string &payload);
~GetAutoGroupingRuleResult();
Rule getRule()const;
protected:
void parse(const std::string &payload);
private:
Rule rule_;
};
}
}
}
#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGRULERESULT_H_

39
resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusRequest.h Normal file
View File

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

53
resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusResult.h Normal file
View File

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

2
resourcemanager/include/alibabacloud/resourcemanager/model/GetPolicyResult.h
View File

@@ -34,8 +34,8 @@ namespace AlibabaCloud
public:
struct Policy
{
std::string updateDate;
std::string policyType;
std::string updateDate;
std::string description;
int attachmentCount;
std::string defaultVersion;

2
resourcemanager/include/alibabacloud/resourcemanager/model/GetResourceDirectoryResult.h
View File

@@ -38,9 +38,9 @@ namespace AlibabaCloud
std::string resourceDirectoryId;
std::string scpStatus;
std::string memberDeletionStatus;
std::string rootFolderId;
std::string createTime;
std::string masterAccountName;
std::string rootFolderId;
std::string controlPolicyStatus;
std::string masterAccountId;
};

4
resourcemanager/include/alibabacloud/resourcemanager/model/GetRoleResult.h
View File

@@ -36,11 +36,11 @@ namespace AlibabaCloud
{
struct LatestDeletionTask
{
std::string deletionTaskId;
std::string createDate;
std::string deletionTaskId;
};
std::string updateDate;
long maxSessionDuration;
std::string updateDate;
std::string roleName;
std::string description;
std::string assumeRolePolicyDocument;

2
resourcemanager/include/alibabacloud/resourcemanager/model/InitResourceDirectoryResult.h
View File

@@ -35,9 +35,9 @@ namespace AlibabaCloud
struct ResourceDirectory
{
std::string resourceDirectoryId;
std::string rootFolderId;
std::string createTime;
std::string masterAccountName;
std::string rootFolderId;
std::string masterAccountId;
};

18
resourcemanager/include/alibabacloud/resourcemanager/model/ListAccountsForParentRequest.h
View File

@@ -34,26 +34,26 @@ public:
};
ListAccountsForParentRequest();
~ListAccountsForParentRequest();
std::string getQueryKeyword() const;
void setQueryKeyword(const std::string &queryKeyword);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getParentFolderId() const;
void setParentFolderId(const std::string &parentFolderId);
bool getIncludeTags() const;
void setIncludeTags(bool includeTags);
int getPageSize() const;
void setPageSize(int pageSize);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
std::string getQueryKeyword() const;
void setQueryKeyword(const std::string &queryKeyword);
std::string getParentFolderId() const;
void setParentFolderId(const std::string &parentFolderId);
bool getIncludeTags() const;
void setIncludeTags(bool includeTags);
private:
std::string queryKeyword_;
int pageNumber_;
std::string parentFolderId_;
bool includeTags_;
int pageSize_;
std::vector<Tag> tag_;
std::string queryKeyword_;
std::string parentFolderId_;
bool includeTags_;
};
} // namespace Model
} // namespace ResourceManager

39
resourcemanager/include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingRequest.h Normal file
View File

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

69
resourcemanager/include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingResult.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTASSOCIATEDTRANSFERSETTINGRESULT_H_
#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTASSOCIATEDTRANSFERSETTINGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
namespace AlibabaCloud
{
namespace ResourceManager
{
namespace Model
{
class ALIBABACLOUD_RESOURCEMANAGER_EXPORT ListAssociatedTransferSettingResult : public ServiceResult
{
public:
struct AssociatedTransferSetting
{
struct RuleSetting
{
std::string status;
std::string triggerType;
std::string associatedService;
std::string masterResourceType;
std::string ruleId;
std::string associatedResourceType;
std::string masterService;
};
std::string status;
std::string enablePartialRule;
std::string accountId;
std::string enableExistingResourcesTransfer;
std::vector<RuleSetting> ruleSettings;
};
ListAssociatedTransferSettingResult();
explicit ListAssociatedTransferSettingResult(const std::string &payload);
~ListAssociatedTransferSettingResult();
AssociatedTransferSetting getAssociatedTransferSetting()const;
protected:
void parse(const std::string &payload);
private:
AssociatedTransferSetting associatedTransferSetting_;
};
}
}
}
#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTASSOCIATEDTRANSFERSETTINGRESULT_H_

54
resourcemanager/include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESREQUEST_H_
#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESREQUEST_H_
#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ResourceManager {
namespace Model {
class ALIBABACLOUD_RESOURCEMANAGER_EXPORT ListAutoGroupingRulesRequest : public RpcServiceRequest {
public:
ListAutoGroupingRulesRequest();
~ListAutoGroupingRulesRequest();
std::string getRuleName() const;
void setRuleName(const std::string &ruleName);
std::string getNextToken() const;
void setNextToken(const std::string &nextToken);
std::string getRuleType() const;
void setRuleType(const std::string &ruleType);
int getMaxResults() const;
void setMaxResults(int maxResults);
std::string getRuleId() const;
void setRuleId(const std::string &ruleId);
private:
std::string ruleName_;
std::string nextToken_;
std::string ruleType_;
int maxResults_;
std::string ruleId_;
};
} // namespace Model
} // namespace ResourceManager
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESREQUEST_H_

79
resourcemanager/include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesResult.h Normal file
View File

@@ -0,0 +1,79 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESRESULT_H_
#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
namespace AlibabaCloud
{
namespace ResourceManager
{
namespace Model
{
class ALIBABACLOUD_RESOURCEMANAGER_EXPORT ListAutoGroupingRulesResult : public ServiceResult
{
public:
struct Rule
{
struct RuleContent
{
std::string autoGroupingScopeCondition;
std::string ruleContentId;
std::string targetResourceGroupCondition;
};
std::string modifyTime;
std::string excludeResourceGroupIdsScope;
std::string excludeResourceIdsScope;
std::string excludeResourceTypesScope;
std::string resourceIdsScope;
std::vector<Rule::RuleContent> ruleContents;
std::string createTime;
std::string ruleId;
std::string ruleType;
std::string excludeRegionIdsScope;
std::string regionIdsScope;
std::string resourceGroupIdsScope;
std::string ruleDesc;
std::string resourceTypesScope;
std::string ruleName;
};
ListAutoGroupingRulesResult();
explicit ListAutoGroupingRulesResult(const std::string &payload);
~ListAutoGroupingRulesResult();
std::string getNextToken()const;
int getMaxResults()const;
std::vector<Rule> getRules()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
int maxResults_;
std::vector<Rule> rules_;
};
}
}
}
#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESRESULT_H_

2
resourcemanager/include/alibabacloud/resourcemanager/model/ListPoliciesResult.h
View File

@@ -34,8 +34,8 @@ namespace AlibabaCloud
public:
struct Policy
{
std::string updateDate;
std::string policyType;
std::string updateDate;
std::string description;
int attachmentCount;
std::string defaultVersion;

4
resourcemanager/include/alibabacloud/resourcemanager/model/ListRolesResult.h
View File

@@ -36,11 +36,11 @@ namespace AlibabaCloud
{
struct LatestDeletionTask
{
std::string deletionTaskId;
std::string createDate;
std::string deletionTaskId;
};
std::string updateDate;
long maxSessionDuration;
std::string updateDate;
std::string roleName;
std::string description;
LatestDeletionTask latestDeletionTask;

12
resourcemanager/include/alibabacloud/resourcemanager/model/ListTagResourcesRequest.h
View File

@@ -34,23 +34,23 @@ public:
};
ListTagResourcesRequest();
~ListTagResourcesRequest();
std::string getNextToken() const;
void setNextToken(const std::string &nextToken);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
std::vector<std::string> getResourceId() const;
void setResourceId(const std::vector<std::string> &resourceId);
std::string getResourceType() const;
void setResourceType(const std::string &resourceType);
std::string getNextToken() const;
void setNextToken(const std::string &nextToken);
int getMaxResults() const;
void setMaxResults(int maxResults);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
private:
std::string nextToken_;
std::vector<Tag> tag_;
std::vector<std::string> resourceId_;
std::string resourceType_;
std::string nextToken_;
int maxResults_;
std::vector<Tag> tag_;
};
} // namespace Model
} // namespace ResourceManager

2
resourcemanager/include/alibabacloud/resourcemanager/model/PromoteResourceAccountResult.h
View File

@@ -37,8 +37,8 @@ namespace AlibabaCloud
std::string status;
std::string joinMethod;
std::string modifyTime;
std::string type;
std::string resourceDirectoryId;
std::string type;
std::string accountId;
std::string displayName;
std::string joinTime;

2
resourcemanager/include/alibabacloud/resourcemanager/model/ResendCreateCloudAccountEmailResult.h
View File

@@ -37,8 +37,8 @@ namespace AlibabaCloud
std::string status;
std::string joinMethod;
std::string modifyTime;
std::string type;
std::string resourceDirectoryId;
std::string type;
std::string accountId;
std::string displayName;
std::string joinTime;

2
resourcemanager/include/alibabacloud/resourcemanager/model/ResendPromoteResourceAccountEmailResult.h
View File

@@ -37,8 +37,8 @@ namespace AlibabaCloud
std::string status;
std::string joinMethod;
std::string modifyTime;
std::string type;
std::string resourceDirectoryId;
std::string type;
std::string accountId;
std::string displayName;
std::string joinTime;

53
resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingRequest.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEASSOCIATEDTRANSFERSETTINGREQUEST_H_
#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEASSOCIATEDTRANSFERSETTINGREQUEST_H_
#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ResourceManager {
namespace Model {
class ALIBABACLOUD_RESOURCEMANAGER_EXPORT UpdateAssociatedTransferSettingRequest : public RpcServiceRequest {
public:
struct RuleSettings {
std::string associatedService;
std::string masterService;
std::string masterResourceType;
std::string associatedResourceType;
std::string ruleId;
std::string status;
};
UpdateAssociatedTransferSettingRequest();
~UpdateAssociatedTransferSettingRequest();
std::vector<RuleSettings> getRuleSettings() const;
void setRuleSettings(const std::vector<RuleSettings> &ruleSettings);
std::string getEnableExistingResourcesTransfer() const;
void setEnableExistingResourcesTransfer(const std::string &enableExistingResourcesTransfer);
private:
std::vector<RuleSettings> ruleSettings_;
std::string enableExistingResourcesTransfer_;
};
} // namespace Model
} // namespace ResourceManager
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEASSOCIATEDTRANSFERSETTINGREQUEST_H_

49
resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingResult.h Normal file
View File

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

42
resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigRequest.h Normal file
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_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGCONFIGREQUEST_H_
#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGCONFIGREQUEST_H_
#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ResourceManager {
namespace Model {
class ALIBABACLOUD_RESOURCEMANAGER_EXPORT UpdateAutoGroupingConfigRequest : public RpcServiceRequest {
public:
UpdateAutoGroupingConfigRequest();
~UpdateAutoGroupingConfigRequest();
bool getEnableExistingResourcesTransfer() const;
void setEnableExistingResourcesTransfer(bool enableExistingResourcesTransfer);
private:
bool enableExistingResourcesTransfer_;
};
} // namespace Model
} // namespace ResourceManager
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGCONFIGREQUEST_H_

49
resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigResult.h Normal file
View File

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

80
resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleRequest.h Normal file
View File

@@ -0,0 +1,80 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGRULEREQUEST_H_
#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGRULEREQUEST_H_
#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace ResourceManager {
namespace Model {
class ALIBABACLOUD_RESOURCEMANAGER_EXPORT UpdateAutoGroupingRuleRequest : public RpcServiceRequest {
public:
struct RuleContents {
std::string ruleContentId;
std::string targetResourceGroupCondition;
std::string autoGroupingScopeCondition;
};
UpdateAutoGroupingRuleRequest();
~UpdateAutoGroupingRuleRequest();
std::string getRuleDesc() const;
void setRuleDesc(const std::string &ruleDesc);
std::string getResourceTypesScope() const;
void setResourceTypesScope(const std::string &resourceTypesScope);
std::string getRuleName() const;
void setRuleName(const std::string &ruleName);
std::string getExcludeResourceGroupIdsScope() const;
void setExcludeResourceGroupIdsScope(const std::string &excludeResourceGroupIdsScope);
std::string getRegionIdsScope() const;
void setRegionIdsScope(const std::string &regionIdsScope);
std::string getResourceIdsScope() const;
void setResourceIdsScope(const std::string &resourceIdsScope);
std::vector<RuleContents> getRuleContents() const;
void setRuleContents(const std::vector<RuleContents> &ruleContents);
std::string getExcludeResourceTypesScope() const;
void setExcludeResourceTypesScope(const std::string &excludeResourceTypesScope);
std::string getResourceGroupIdsScope() const;
void setResourceGroupIdsScope(const std::string &resourceGroupIdsScope);
std::string getExcludeRegionIdsScope() const;
void setExcludeRegionIdsScope(const std::string &excludeRegionIdsScope);
std::string getExcludeResourceIdsScope() const;
void setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope);
std::string getRuleId() const;
void setRuleId(const std::string &ruleId);
private:
std::string ruleDesc_;
std::string resourceTypesScope_;
std::string ruleName_;
std::string excludeResourceGroupIdsScope_;
std::string regionIdsScope_;
std::string resourceIdsScope_;
std::vector<RuleContents> ruleContents_;
std::string excludeResourceTypesScope_;
std::string resourceGroupIdsScope_;
std::string excludeRegionIdsScope_;
std::string excludeResourceIdsScope_;
std::string ruleId_;
};
} // namespace Model
} // namespace ResourceManager
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGRULEREQUEST_H_

49
resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleResult.h Normal file
View File

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

2
resourcemanager/include/alibabacloud/resourcemanager/model/UpdateRoleResult.h
View File

@@ -34,8 +34,8 @@ namespace AlibabaCloud
public:
struct Role
{
std::string updateDate;
long maxSessionDuration;
std::string updateDate;
std::string roleName;
std::string description;
std::string assumeRolePolicyDocument;

474
resourcemanager/src/ResourceManagerClient.cc
View File

@@ -31,21 +31,21 @@ ResourceManagerClient::ResourceManagerClient(const Credentials &credentials, con
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, "");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "resourcemanager");
}
ResourceManagerClient::ResourceManagerClient(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, "");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "resourcemanager");
}
ResourceManagerClient::ResourceManagerClient(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, "");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "resourcemanager");
}
ResourceManagerClient::~ResourceManagerClient()
@@ -411,6 +411,42 @@ ResourceManagerClient::CheckAccountDeleteOutcomeCallable ResourceManagerClient::
return task->get_future();
}
ResourceManagerClient::CreateAutoGroupingRuleOutcome ResourceManagerClient::createAutoGroupingRule(const CreateAutoGroupingRuleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateAutoGroupingRuleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateAutoGroupingRuleOutcome(CreateAutoGroupingRuleResult(outcome.result()));
else
return CreateAutoGroupingRuleOutcome(outcome.error());
}
void ResourceManagerClient::createAutoGroupingRuleAsync(const CreateAutoGroupingRuleRequest& request, const CreateAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createAutoGroupingRule(request), context);
};
asyncExecute(new Runnable(fn));
}
ResourceManagerClient::CreateAutoGroupingRuleOutcomeCallable ResourceManagerClient::createAutoGroupingRuleCallable(const CreateAutoGroupingRuleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateAutoGroupingRuleOutcome()>>(
[this, request]()
{
return this->createAutoGroupingRule(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ResourceManagerClient::CreateCloudAccountOutcome ResourceManagerClient::createCloudAccount(const CreateCloudAccountRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -807,6 +843,42 @@ ResourceManagerClient::DeleteAccountOutcomeCallable ResourceManagerClient::delet
return task->get_future();
}
ResourceManagerClient::DeleteAutoGroupingRuleOutcome ResourceManagerClient::deleteAutoGroupingRule(const DeleteAutoGroupingRuleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteAutoGroupingRuleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteAutoGroupingRuleOutcome(DeleteAutoGroupingRuleResult(outcome.result()));
else
return DeleteAutoGroupingRuleOutcome(outcome.error());
}
void ResourceManagerClient::deleteAutoGroupingRuleAsync(const DeleteAutoGroupingRuleRequest& request, const DeleteAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteAutoGroupingRule(request), context);
};
asyncExecute(new Runnable(fn));
}
ResourceManagerClient::DeleteAutoGroupingRuleOutcomeCallable ResourceManagerClient::deleteAutoGroupingRuleCallable(const DeleteAutoGroupingRuleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteAutoGroupingRuleOutcome()>>(
[this, request]()
{
return this->deleteAutoGroupingRule(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ResourceManagerClient::DeleteControlPolicyOutcome ResourceManagerClient::deleteControlPolicy(const DeleteControlPolicyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1203,6 +1275,78 @@ ResourceManagerClient::DetachPolicyOutcomeCallable ResourceManagerClient::detach
return task->get_future();
}
ResourceManagerClient::DisableAssociatedTransferOutcome ResourceManagerClient::disableAssociatedTransfer(const DisableAssociatedTransferRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DisableAssociatedTransferOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DisableAssociatedTransferOutcome(DisableAssociatedTransferResult(outcome.result()));
else
return DisableAssociatedTransferOutcome(outcome.error());
}
void ResourceManagerClient::disableAssociatedTransferAsync(const DisableAssociatedTransferRequest& request, const DisableAssociatedTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, disableAssociatedTransfer(request), context);
};
asyncExecute(new Runnable(fn));
}
ResourceManagerClient::DisableAssociatedTransferOutcomeCallable ResourceManagerClient::disableAssociatedTransferCallable(const DisableAssociatedTransferRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DisableAssociatedTransferOutcome()>>(
[this, request]()
{
return this->disableAssociatedTransfer(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ResourceManagerClient::DisableAutoGroupingOutcome ResourceManagerClient::disableAutoGrouping(const DisableAutoGroupingRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DisableAutoGroupingOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DisableAutoGroupingOutcome(DisableAutoGroupingResult(outcome.result()));
else
return DisableAutoGroupingOutcome(outcome.error());
}
void ResourceManagerClient::disableAutoGroupingAsync(const DisableAutoGroupingRequest& request, const DisableAutoGroupingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, disableAutoGrouping(request), context);
};
asyncExecute(new Runnable(fn));
}
ResourceManagerClient::DisableAutoGroupingOutcomeCallable ResourceManagerClient::disableAutoGroupingCallable(const DisableAutoGroupingRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DisableAutoGroupingOutcome()>>(
[this, request]()
{
return this->disableAutoGrouping(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ResourceManagerClient::DisableControlPolicyOutcome ResourceManagerClient::disableControlPolicy(const DisableControlPolicyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1239,6 +1383,78 @@ ResourceManagerClient::DisableControlPolicyOutcomeCallable ResourceManagerClient
return task->get_future();
}
ResourceManagerClient::EnableAssociatedTransferOutcome ResourceManagerClient::enableAssociatedTransfer(const EnableAssociatedTransferRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return EnableAssociatedTransferOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return EnableAssociatedTransferOutcome(EnableAssociatedTransferResult(outcome.result()));
else
return EnableAssociatedTransferOutcome(outcome.error());
}
void ResourceManagerClient::enableAssociatedTransferAsync(const EnableAssociatedTransferRequest& request, const EnableAssociatedTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, enableAssociatedTransfer(request), context);
};
asyncExecute(new Runnable(fn));
}
ResourceManagerClient::EnableAssociatedTransferOutcomeCallable ResourceManagerClient::enableAssociatedTransferCallable(const EnableAssociatedTransferRequest &request) const
{
auto task = std::make_shared<std::packaged_task<EnableAssociatedTransferOutcome()>>(
[this, request]()
{
return this->enableAssociatedTransfer(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ResourceManagerClient::EnableAutoGroupingOutcome ResourceManagerClient::enableAutoGrouping(const EnableAutoGroupingRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return EnableAutoGroupingOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return EnableAutoGroupingOutcome(EnableAutoGroupingResult(outcome.result()));
else
return EnableAutoGroupingOutcome(outcome.error());
}
void ResourceManagerClient::enableAutoGroupingAsync(const EnableAutoGroupingRequest& request, const EnableAutoGroupingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, enableAutoGrouping(request), context);
};
asyncExecute(new Runnable(fn));
}
ResourceManagerClient::EnableAutoGroupingOutcomeCallable ResourceManagerClient::enableAutoGroupingCallable(const EnableAutoGroupingRequest &request) const
{
auto task = std::make_shared<std::packaged_task<EnableAutoGroupingOutcome()>>(
[this, request]()
{
return this->enableAutoGrouping(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ResourceManagerClient::EnableControlPolicyOutcome ResourceManagerClient::enableControlPolicy(const EnableControlPolicyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1419,6 +1635,78 @@ ResourceManagerClient::GetAccountDeletionStatusOutcomeCallable ResourceManagerCl
return task->get_future();
}
ResourceManagerClient::GetAutoGroupingRuleOutcome ResourceManagerClient::getAutoGroupingRule(const GetAutoGroupingRuleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetAutoGroupingRuleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetAutoGroupingRuleOutcome(GetAutoGroupingRuleResult(outcome.result()));
else
return GetAutoGroupingRuleOutcome(outcome.error());
}
void ResourceManagerClient::getAutoGroupingRuleAsync(const GetAutoGroupingRuleRequest& request, const GetAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getAutoGroupingRule(request), context);
};
asyncExecute(new Runnable(fn));
}
ResourceManagerClient::GetAutoGroupingRuleOutcomeCallable ResourceManagerClient::getAutoGroupingRuleCallable(const GetAutoGroupingRuleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetAutoGroupingRuleOutcome()>>(
[this, request]()
{
return this->getAutoGroupingRule(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ResourceManagerClient::GetAutoGroupingStatusOutcome ResourceManagerClient::getAutoGroupingStatus(const GetAutoGroupingStatusRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetAutoGroupingStatusOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetAutoGroupingStatusOutcome(GetAutoGroupingStatusResult(outcome.result()));
else
return GetAutoGroupingStatusOutcome(outcome.error());
}
void ResourceManagerClient::getAutoGroupingStatusAsync(const GetAutoGroupingStatusRequest& request, const GetAutoGroupingStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getAutoGroupingStatus(request), context);
};
asyncExecute(new Runnable(fn));
}
ResourceManagerClient::GetAutoGroupingStatusOutcomeCallable ResourceManagerClient::getAutoGroupingStatusCallable(const GetAutoGroupingStatusRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetAutoGroupingStatusOutcome()>>(
[this, request]()
{
return this->getAutoGroupingStatus(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ResourceManagerClient::GetControlPolicyOutcome ResourceManagerClient::getControlPolicy(const GetControlPolicyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1995,6 +2283,78 @@ ResourceManagerClient::ListAncestorsOutcomeCallable ResourceManagerClient::listA
return task->get_future();
}
ResourceManagerClient::ListAssociatedTransferSettingOutcome ResourceManagerClient::listAssociatedTransferSetting(const ListAssociatedTransferSettingRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListAssociatedTransferSettingOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListAssociatedTransferSettingOutcome(ListAssociatedTransferSettingResult(outcome.result()));
else
return ListAssociatedTransferSettingOutcome(outcome.error());
}
void ResourceManagerClient::listAssociatedTransferSettingAsync(const ListAssociatedTransferSettingRequest& request, const ListAssociatedTransferSettingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listAssociatedTransferSetting(request), context);
};
asyncExecute(new Runnable(fn));
}
ResourceManagerClient::ListAssociatedTransferSettingOutcomeCallable ResourceManagerClient::listAssociatedTransferSettingCallable(const ListAssociatedTransferSettingRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListAssociatedTransferSettingOutcome()>>(
[this, request]()
{
return this->listAssociatedTransferSetting(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ResourceManagerClient::ListAutoGroupingRulesOutcome ResourceManagerClient::listAutoGroupingRules(const ListAutoGroupingRulesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListAutoGroupingRulesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListAutoGroupingRulesOutcome(ListAutoGroupingRulesResult(outcome.result()));
else
return ListAutoGroupingRulesOutcome(outcome.error());
}
void ResourceManagerClient::listAutoGroupingRulesAsync(const ListAutoGroupingRulesRequest& request, const ListAutoGroupingRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listAutoGroupingRules(request), context);
};
asyncExecute(new Runnable(fn));
}
ResourceManagerClient::ListAutoGroupingRulesOutcomeCallable ResourceManagerClient::listAutoGroupingRulesCallable(const ListAutoGroupingRulesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListAutoGroupingRulesOutcome()>>(
[this, request]()
{
return this->listAutoGroupingRules(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ResourceManagerClient::ListControlPoliciesOutcome ResourceManagerClient::listControlPolicies(const ListControlPoliciesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3183,6 +3543,114 @@ ResourceManagerClient::UpdateAccountOutcomeCallable ResourceManagerClient::updat
return task->get_future();
}
ResourceManagerClient::UpdateAssociatedTransferSettingOutcome ResourceManagerClient::updateAssociatedTransferSetting(const UpdateAssociatedTransferSettingRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateAssociatedTransferSettingOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateAssociatedTransferSettingOutcome(UpdateAssociatedTransferSettingResult(outcome.result()));
else
return UpdateAssociatedTransferSettingOutcome(outcome.error());
}
void ResourceManagerClient::updateAssociatedTransferSettingAsync(const UpdateAssociatedTransferSettingRequest& request, const UpdateAssociatedTransferSettingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateAssociatedTransferSetting(request), context);
};
asyncExecute(new Runnable(fn));
}
ResourceManagerClient::UpdateAssociatedTransferSettingOutcomeCallable ResourceManagerClient::updateAssociatedTransferSettingCallable(const UpdateAssociatedTransferSettingRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateAssociatedTransferSettingOutcome()>>(
[this, request]()
{
return this->updateAssociatedTransferSetting(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ResourceManagerClient::UpdateAutoGroupingConfigOutcome ResourceManagerClient::updateAutoGroupingConfig(const UpdateAutoGroupingConfigRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateAutoGroupingConfigOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateAutoGroupingConfigOutcome(UpdateAutoGroupingConfigResult(outcome.result()));
else
return UpdateAutoGroupingConfigOutcome(outcome.error());
}
void ResourceManagerClient::updateAutoGroupingConfigAsync(const UpdateAutoGroupingConfigRequest& request, const UpdateAutoGroupingConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateAutoGroupingConfig(request), context);
};
asyncExecute(new Runnable(fn));
}
ResourceManagerClient::UpdateAutoGroupingConfigOutcomeCallable ResourceManagerClient::updateAutoGroupingConfigCallable(const UpdateAutoGroupingConfigRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateAutoGroupingConfigOutcome()>>(
[this, request]()
{
return this->updateAutoGroupingConfig(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ResourceManagerClient::UpdateAutoGroupingRuleOutcome ResourceManagerClient::updateAutoGroupingRule(const UpdateAutoGroupingRuleRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpdateAutoGroupingRuleOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpdateAutoGroupingRuleOutcome(UpdateAutoGroupingRuleResult(outcome.result()));
else
return UpdateAutoGroupingRuleOutcome(outcome.error());
}
void ResourceManagerClient::updateAutoGroupingRuleAsync(const UpdateAutoGroupingRuleRequest& request, const UpdateAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, updateAutoGroupingRule(request), context);
};
asyncExecute(new Runnable(fn));
}
ResourceManagerClient::UpdateAutoGroupingRuleOutcomeCallable ResourceManagerClient::updateAutoGroupingRuleCallable(const UpdateAutoGroupingRuleRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpdateAutoGroupingRuleOutcome()>>(
[this, request]()
{
return this->updateAutoGroupingRule(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ResourceManagerClient::UpdateControlPolicyOutcome ResourceManagerClient::updateControlPolicy(const UpdateControlPolicyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

18
resourcemanager/src/model/AttachPolicyRequest.cc
View File

@@ -25,6 +25,15 @@ AttachPolicyRequest::AttachPolicyRequest()
AttachPolicyRequest::~AttachPolicyRequest() {}
std::string AttachPolicyRequest::getResourceGroupId() const {
return resourceGroupId_;
}
void AttachPolicyRequest::setResourceGroupId(const std::string &resourceGroupId) {
resourceGroupId_ = resourceGroupId;
setParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string AttachPolicyRequest::getPolicyType() const {
return policyType_;
}
@@ -43,15 +52,6 @@ void AttachPolicyRequest::setPrincipalType(const std::string &principalType) {
setParameter(std::string("PrincipalType"), principalType);
}
std::string AttachPolicyRequest::getResourceGroupId() const {
return resourceGroupId_;
}
void AttachPolicyRequest::setResourceGroupId(const std::string &resourceGroupId) {
resourceGroupId_ = resourceGroupId;
setParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string AttachPolicyRequest::getPolicyName() const {
return policyName_;
}

140
resourcemanager/src/model/CreateAutoGroupingRuleRequest.cc Normal file
View File

@@ -0,0 +1,140 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/resourcemanager/model/CreateAutoGroupingRuleRequest.h>
using AlibabaCloud::ResourceManager::Model::CreateAutoGroupingRuleRequest;
CreateAutoGroupingRuleRequest::CreateAutoGroupingRuleRequest()
: RpcServiceRequest("resourcemanager", "2020-03-31", "CreateAutoGroupingRule") {
setMethod(HttpRequest::Method::Post);
}
CreateAutoGroupingRuleRequest::~CreateAutoGroupingRuleRequest() {}
std::string CreateAutoGroupingRuleRequest::getRuleDesc() const {
return ruleDesc_;
}
void CreateAutoGroupingRuleRequest::setRuleDesc(const std::string &ruleDesc) {
ruleDesc_ = ruleDesc;
setParameter(std::string("RuleDesc"), ruleDesc);
}
std::string CreateAutoGroupingRuleRequest::getResourceTypesScope() const {
return resourceTypesScope_;
}
void CreateAutoGroupingRuleRequest::setResourceTypesScope(const std::string &resourceTypesScope) {
resourceTypesScope_ = resourceTypesScope;
setParameter(std::string("ResourceTypesScope"), resourceTypesScope);
}
std::string CreateAutoGroupingRuleRequest::getRuleName() const {
return ruleName_;
}
void CreateAutoGroupingRuleRequest::setRuleName(const std::string &ruleName) {
ruleName_ = ruleName;
setParameter(std::string("RuleName"), ruleName);
}
std::string CreateAutoGroupingRuleRequest::getExcludeResourceGroupIdsScope() const {
return excludeResourceGroupIdsScope_;
}
void CreateAutoGroupingRuleRequest::setExcludeResourceGroupIdsScope(const std::string &excludeResourceGroupIdsScope) {
excludeResourceGroupIdsScope_ = excludeResourceGroupIdsScope;
setParameter(std::string("ExcludeResourceGroupIdsScope"), excludeResourceGroupIdsScope);
}
std::string CreateAutoGroupingRuleRequest::getRegionIdsScope() const {
return regionIdsScope_;
}
void CreateAutoGroupingRuleRequest::setRegionIdsScope(const std::string &regionIdsScope) {
regionIdsScope_ = regionIdsScope;
setParameter(std::string("RegionIdsScope"), regionIdsScope);
}
std::string CreateAutoGroupingRuleRequest::getResourceIdsScope() const {
return resourceIdsScope_;
}
void CreateAutoGroupingRuleRequest::setResourceIdsScope(const std::string &resourceIdsScope) {
resourceIdsScope_ = resourceIdsScope;
setParameter(std::string("ResourceIdsScope"), resourceIdsScope);
}
std::vector<CreateAutoGroupingRuleRequest::RuleContents> CreateAutoGroupingRuleRequest::getRuleContents() const {
return ruleContents_;
}
void CreateAutoGroupingRuleRequest::setRuleContents(const std::vector<CreateAutoGroupingRuleRequest::RuleContents> &ruleContents) {
ruleContents_ = ruleContents;
for(int dep1 = 0; dep1 != ruleContents.size(); dep1++) {
auto ruleContentsObj = ruleContents.at(dep1);
std::string ruleContentsObjStr = std::string("RuleContents") + "." + std::to_string(dep1 + 1);
setParameter(ruleContentsObjStr + ".TargetResourceGroupCondition", ruleContentsObj.targetResourceGroupCondition);
setParameter(ruleContentsObjStr + ".AutoGroupingScopeCondition", ruleContentsObj.autoGroupingScopeCondition);
}
}
std::string CreateAutoGroupingRuleRequest::getExcludeResourceTypesScope() const {
return excludeResourceTypesScope_;
}
void CreateAutoGroupingRuleRequest::setExcludeResourceTypesScope(const std::string &excludeResourceTypesScope) {
excludeResourceTypesScope_ = excludeResourceTypesScope;
setParameter(std::string("ExcludeResourceTypesScope"), excludeResourceTypesScope);
}
std::string CreateAutoGroupingRuleRequest::getRuleType() const {
return ruleType_;
}
void CreateAutoGroupingRuleRequest::setRuleType(const std::string &ruleType) {
ruleType_ = ruleType;
setParameter(std::string("RuleType"), ruleType);
}
std::string CreateAutoGroupingRuleRequest::getResourceGroupIdsScope() const {
return resourceGroupIdsScope_;
}
void CreateAutoGroupingRuleRequest::setResourceGroupIdsScope(const std::string &resourceGroupIdsScope) {
resourceGroupIdsScope_ = resourceGroupIdsScope;
setParameter(std::string("ResourceGroupIdsScope"), resourceGroupIdsScope);
}
std::string CreateAutoGroupingRuleRequest::getExcludeRegionIdsScope() const {
return excludeRegionIdsScope_;
}
void CreateAutoGroupingRuleRequest::setExcludeRegionIdsScope(const std::string &excludeRegionIdsScope) {
excludeRegionIdsScope_ = excludeRegionIdsScope;
setParameter(std::string("ExcludeRegionIdsScope"), excludeRegionIdsScope);
}
std::string CreateAutoGroupingRuleRequest::getExcludeResourceIdsScope() const {
return excludeResourceIdsScope_;
}
void CreateAutoGroupingRuleRequest::setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope) {
excludeResourceIdsScope_ = excludeResourceIdsScope;
setParameter(std::string("ExcludeResourceIdsScope"), excludeResourceIdsScope);
}

51
resourcemanager/src/model/CreateAutoGroupingRuleResult.cc Normal file
View File

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

24
resourcemanager/src/model/CreateCloudAccountResult.cc
View File

@@ -40,26 +40,26 @@ void CreateCloudAccountResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto accountNode = value["Account"];
if(!accountNode["Status"].isNull())
account_.status = accountNode["Status"].asString();
if(!accountNode["Type"].isNull())
account_.type = accountNode["Type"].asString();
if(!accountNode["AccountId"].isNull())
account_.accountId = accountNode["AccountId"].asString();
if(!accountNode["AccountName"].isNull())
account_.accountName = accountNode["AccountName"].asString();
if(!accountNode["DisplayName"].isNull())
account_.displayName = accountNode["DisplayName"].asString();
if(!accountNode["FolderId"].isNull())
account_.folderId = accountNode["FolderId"].asString();
if(!accountNode["ResourceDirectoryId"].isNull())
account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
if(!accountNode["RecordId"].isNull())
account_.recordId = accountNode["RecordId"].asString();
if(!accountNode["AccountId"].isNull())
account_.accountId = accountNode["AccountId"].asString();
if(!accountNode["JoinMethod"].isNull())
account_.joinMethod = accountNode["JoinMethod"].asString();
if(!accountNode["ModifyTime"].isNull())
account_.modifyTime = accountNode["ModifyTime"].asString();
if(!accountNode["AccountName"].isNull())
account_.accountName = accountNode["AccountName"].asString();
if(!accountNode["RecordId"].isNull())
account_.recordId = accountNode["RecordId"].asString();
if(!accountNode["ResourceDirectoryId"].isNull())
account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
if(!accountNode["Status"].isNull())
account_.status = accountNode["Status"].asString();
if(!accountNode["Type"].isNull())
account_.type = accountNode["Type"].asString();
}

4
resourcemanager/src/model/CreatePolicyResult.cc
View File

@@ -40,14 +40,14 @@ void CreatePolicyResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto policyNode = value["Policy"];
if(!policyNode["CreateDate"].isNull())
policy_.createDate = policyNode["CreateDate"].asString();
if(!policyNode["DefaultVersion"].isNull())
policy_.defaultVersion = policyNode["DefaultVersion"].asString();
if(!policyNode["Description"].isNull())
policy_.description = policyNode["Description"].asString();
if(!policyNode["PolicyName"].isNull())
policy_.policyName = policyNode["PolicyName"].asString();
if(!policyNode["CreateDate"].isNull())
policy_.createDate = policyNode["CreateDate"].asString();
if(!policyNode["PolicyType"].isNull())
policy_.policyType = policyNode["PolicyType"].asString();

4
resourcemanager/src/model/CreatePolicyVersionResult.cc
View File

@@ -40,12 +40,12 @@ void CreatePolicyVersionResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto policyVersionNode = value["PolicyVersion"];
if(!policyVersionNode["CreateDate"].isNull())
policyVersion_.createDate = policyVersionNode["CreateDate"].asString();
if(!policyVersionNode["IsDefaultVersion"].isNull())
policyVersion_.isDefaultVersion = policyVersionNode["IsDefaultVersion"].asString() == "true";
if(!policyVersionNode["VersionId"].isNull())
policyVersion_.versionId = policyVersionNode["VersionId"].asString();
if(!policyVersionNode["CreateDate"].isNull())
policyVersion_.createDate = policyVersionNode["CreateDate"].asString();
}

12
resourcemanager/src/model/CreateResourceGroupRequest.cc
View File

@@ -43,3 +43,15 @@ void CreateResourceGroupRequest::setName(const std::string &name) {
setParameter(std::string("Name"), name);
}
std::vector<CreateResourceGroupRequest::Tag> CreateResourceGroupRequest::getTag() const {
return tag_;
}
void CreateResourceGroupRequest::setTag(const std::vector<CreateResourceGroupRequest::Tag> &tag) {
tag_ = tag;
for(int dep1 = 0; dep1 != tag.size(); dep1++) {
setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Value", tag[dep1].value);
setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Key", tag[dep1].key);
}
}

16
resourcemanager/src/model/CreateResourceGroupResult.cc
View File

@@ -40,26 +40,26 @@ void CreateResourceGroupResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto resourceGroupNode = value["ResourceGroup"];
if(!resourceGroupNode["DisplayName"].isNull())
resourceGroup_.displayName = resourceGroupNode["DisplayName"].asString();
if(!resourceGroupNode["Status"].isNull())
resourceGroup_.status = resourceGroupNode["Status"].asString();
if(!resourceGroupNode["AccountId"].isNull())
resourceGroup_.accountId = resourceGroupNode["AccountId"].asString();
if(!resourceGroupNode["Name"].isNull())
resourceGroup_.name = resourceGroupNode["Name"].asString();
if(!resourceGroupNode["CreateDate"].isNull())
resourceGroup_.createDate = resourceGroupNode["CreateDate"].asString();
if(!resourceGroupNode["DisplayName"].isNull())
resourceGroup_.displayName = resourceGroupNode["DisplayName"].asString();
if(!resourceGroupNode["Id"].isNull())
resourceGroup_.id = resourceGroupNode["Id"].asString();
if(!resourceGroupNode["Name"].isNull())
resourceGroup_.name = resourceGroupNode["Name"].asString();
if(!resourceGroupNode["Status"].isNull())
resourceGroup_.status = resourceGroupNode["Status"].asString();
auto allRegionStatusesNode = resourceGroupNode["RegionStatuses"]["RegionStatus"];
for (auto resourceGroupNodeRegionStatusesRegionStatus : allRegionStatusesNode)
{
ResourceGroup::RegionStatus regionStatusObject;
if(!resourceGroupNodeRegionStatusesRegionStatus["Status"].isNull())
regionStatusObject.status = resourceGroupNodeRegionStatusesRegionStatus["Status"].asString();
if(!resourceGroupNodeRegionStatusesRegionStatus["RegionId"].isNull())
regionStatusObject.regionId = resourceGroupNodeRegionStatusesRegionStatus["RegionId"].asString();
if(!resourceGroupNodeRegionStatusesRegionStatus["Status"].isNull())
regionStatusObject.status = resourceGroupNodeRegionStatusesRegionStatus["Status"].asString();
resourceGroup_.regionStatuses.push_back(regionStatusObject);
}

16
resourcemanager/src/model/CreateRoleResult.cc
View File

@@ -40,22 +40,22 @@ void CreateRoleResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto roleNode = value["Role"];
if(!roleNode["Arn"].isNull())
role_.arn = roleNode["Arn"].asString();
if(!roleNode["AssumeRolePolicyDocument"].isNull())
role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString();
if(!roleNode["RolePrincipalName"].isNull())
role_.rolePrincipalName = roleNode["RolePrincipalName"].asString();
if(!roleNode["CreateDate"].isNull())
role_.createDate = roleNode["CreateDate"].asString();
if(!roleNode["Description"].isNull())
role_.description = roleNode["Description"].asString();
if(!roleNode["MaxSessionDuration"].isNull())
role_.maxSessionDuration = std::stol(roleNode["MaxSessionDuration"].asString());
if(!roleNode["RoleName"].isNull())
role_.roleName = roleNode["RoleName"].asString();
if(!roleNode["CreateDate"].isNull())
role_.createDate = roleNode["CreateDate"].asString();
if(!roleNode["Arn"].isNull())
role_.arn = roleNode["Arn"].asString();
if(!roleNode["RoleId"].isNull())
role_.roleId = roleNode["RoleId"].asString();
if(!roleNode["RoleName"].isNull())
role_.roleName = roleNode["RoleName"].asString();
if(!roleNode["RolePrincipalName"].isNull())
role_.rolePrincipalName = roleNode["RolePrincipalName"].asString();
}

24
resourcemanager/src/model/CreateServiceLinkedRoleResult.cc
View File

@@ -40,22 +40,22 @@ void CreateServiceLinkedRoleResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto roleNode = value["Role"];
if(!roleNode["AssumeRolePolicyDocument"].isNull())
role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString();
if(!roleNode["RolePrincipalName"].isNull())
role_.rolePrincipalName = roleNode["RolePrincipalName"].asString();
if(!roleNode["Description"].isNull())
role_.description = roleNode["Description"].asString();
if(!roleNode["RoleName"].isNull())
role_.roleName = roleNode["RoleName"].asString();
if(!roleNode["CreateDate"].isNull())
role_.createDate = roleNode["CreateDate"].asString();
if(!roleNode["Arn"].isNull())
role_.arn = roleNode["Arn"].asString();
if(!roleNode["RoleId"].isNull())
role_.roleId = roleNode["RoleId"].asString();
if(!roleNode["AssumeRolePolicyDocument"].isNull())
role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString();
if(!roleNode["CreateDate"].isNull())
role_.createDate = roleNode["CreateDate"].asString();
if(!roleNode["Description"].isNull())
role_.description = roleNode["Description"].asString();
if(!roleNode["IsServiceLinkedRole"].isNull())
role_.isServiceLinkedRole = roleNode["IsServiceLinkedRole"].asString() == "true";
if(!roleNode["RoleId"].isNull())
role_.roleId = roleNode["RoleId"].asString();
if(!roleNode["RoleName"].isNull())
role_.roleName = roleNode["RoleName"].asString();
if(!roleNode["RolePrincipalName"].isNull())
role_.rolePrincipalName = roleNode["RolePrincipalName"].asString();
}

36
resourcemanager/src/model/DeleteAutoGroupingRuleRequest.cc Normal file
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/resourcemanager/model/DeleteAutoGroupingRuleRequest.h>
using AlibabaCloud::ResourceManager::Model::DeleteAutoGroupingRuleRequest;
DeleteAutoGroupingRuleRequest::DeleteAutoGroupingRuleRequest()
: RpcServiceRequest("resourcemanager", "2020-03-31", "DeleteAutoGroupingRule") {
setMethod(HttpRequest::Method::Post);
}
DeleteAutoGroupingRuleRequest::~DeleteAutoGroupingRuleRequest() {}
std::string DeleteAutoGroupingRuleRequest::getRuleId() const {
return ruleId_;
}
void DeleteAutoGroupingRuleRequest::setRuleId(const std::string &ruleId) {
ruleId_ = ruleId;
setParameter(std::string("RuleId"), ruleId);
}

44
resourcemanager/src/model/DeleteAutoGroupingRuleResult.cc Normal file
View File

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

18
resourcemanager/src/model/DetachPolicyRequest.cc
View File

@@ -25,6 +25,15 @@ DetachPolicyRequest::DetachPolicyRequest()
DetachPolicyRequest::~DetachPolicyRequest() {}
std::string DetachPolicyRequest::getResourceGroupId() const {
return resourceGroupId_;
}
void DetachPolicyRequest::setResourceGroupId(const std::string &resourceGroupId) {
resourceGroupId_ = resourceGroupId;
setParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string DetachPolicyRequest::getPolicyType() const {
return policyType_;
}
@@ -43,15 +52,6 @@ void DetachPolicyRequest::setPrincipalType(const std::string &principalType) {
setParameter(std::string("PrincipalType"), principalType);
}
std::string DetachPolicyRequest::getResourceGroupId() const {
return resourceGroupId_;
}
void DetachPolicyRequest::setResourceGroupId(const std::string &resourceGroupId) {
resourceGroupId_ = resourceGroupId;
setParameter(std::string("ResourceGroupId"), resourceGroupId);
}
std::string DetachPolicyRequest::getPolicyName() const {
return policyName_;
}

27
resourcemanager/src/model/DisableAssociatedTransferRequest.cc Normal file
View File

@@ -0,0 +1,27 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/resourcemanager/model/DisableAssociatedTransferRequest.h>
using AlibabaCloud::ResourceManager::Model::DisableAssociatedTransferRequest;
DisableAssociatedTransferRequest::DisableAssociatedTransferRequest()
: RpcServiceRequest("resourcemanager", "2020-03-31", "DisableAssociatedTransfer") {
setMethod(HttpRequest::Method::Post);
}
DisableAssociatedTransferRequest::~DisableAssociatedTransferRequest() {}

44
resourcemanager/src/model/DisableAssociatedTransferResult.cc Normal file
View File

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

27
resourcemanager/src/model/DisableAutoGroupingRequest.cc Normal file
View File

@@ -0,0 +1,27 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/resourcemanager/model/DisableAutoGroupingRequest.h>
using AlibabaCloud::ResourceManager::Model::DisableAutoGroupingRequest;
DisableAutoGroupingRequest::DisableAutoGroupingRequest()
: RpcServiceRequest("resourcemanager", "2020-03-31", "DisableAutoGrouping") {
setMethod(HttpRequest::Method::Post);
}
DisableAutoGroupingRequest::~DisableAutoGroupingRequest() {}

44
resourcemanager/src/model/DisableAutoGroupingResult.cc Normal file
View File

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

27
resourcemanager/src/model/EnableAssociatedTransferRequest.cc Normal file
View File

@@ -0,0 +1,27 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/resourcemanager/model/EnableAssociatedTransferRequest.h>
using AlibabaCloud::ResourceManager::Model::EnableAssociatedTransferRequest;
EnableAssociatedTransferRequest::EnableAssociatedTransferRequest()
: RpcServiceRequest("resourcemanager", "2020-03-31", "EnableAssociatedTransfer") {
setMethod(HttpRequest::Method::Post);
}
EnableAssociatedTransferRequest::~EnableAssociatedTransferRequest() {}

44
resourcemanager/src/model/EnableAssociatedTransferResult.cc Normal file
View File

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

27
resourcemanager/src/model/EnableAutoGroupingRequest.cc Normal file
View File

@@ -0,0 +1,27 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/resourcemanager/model/EnableAutoGroupingRequest.h>
using AlibabaCloud::ResourceManager::Model::EnableAutoGroupingRequest;
EnableAutoGroupingRequest::EnableAutoGroupingRequest()
: RpcServiceRequest("resourcemanager", "2020-03-31", "EnableAutoGrouping") {
setMethod(HttpRequest::Method::Post);
}
EnableAutoGroupingRequest::~EnableAutoGroupingRequest() {}

44
resourcemanager/src/model/EnableAutoGroupingResult.cc Normal file
View File

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

36
resourcemanager/src/model/GetAutoGroupingRuleRequest.cc Normal file
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/resourcemanager/model/GetAutoGroupingRuleRequest.h>
using AlibabaCloud::ResourceManager::Model::GetAutoGroupingRuleRequest;
GetAutoGroupingRuleRequest::GetAutoGroupingRuleRequest()
: RpcServiceRequest("resourcemanager", "2020-03-31", "GetAutoGroupingRule") {
setMethod(HttpRequest::Method::Post);
}
GetAutoGroupingRuleRequest::~GetAutoGroupingRuleRequest() {}
std::string GetAutoGroupingRuleRequest::getRuleId() const {
return ruleId_;
}
void GetAutoGroupingRuleRequest::setRuleId(const std::string &ruleId) {
ruleId_ = ruleId;
setParameter(std::string("RuleId"), ruleId);
}

90
resourcemanager/src/model/GetAutoGroupingRuleResult.cc Normal file
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/resourcemanager/model/GetAutoGroupingRuleResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ResourceManager;
using namespace AlibabaCloud::ResourceManager::Model;
GetAutoGroupingRuleResult::GetAutoGroupingRuleResult() :
ServiceResult()
{}
GetAutoGroupingRuleResult::GetAutoGroupingRuleResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetAutoGroupingRuleResult::~GetAutoGroupingRuleResult()
{}
void GetAutoGroupingRuleResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto ruleNode = value["Rule"];
if(!ruleNode["CreateTime"].isNull())
rule_.createTime = ruleNode["CreateTime"].asString();
if(!ruleNode["ExcludeRegionIdsScope"].isNull())
rule_.excludeRegionIdsScope = ruleNode["ExcludeRegionIdsScope"].asString();
if(!ruleNode["ExcludeResourceGroupIdsScope"].isNull())
rule_.excludeResourceGroupIdsScope = ruleNode["ExcludeResourceGroupIdsScope"].asString();
if(!ruleNode["ExcludeResourceIdsScope"].isNull())
rule_.excludeResourceIdsScope = ruleNode["ExcludeResourceIdsScope"].asString();
if(!ruleNode["ExcludeResourceTypesScope"].isNull())
rule_.excludeResourceTypesScope = ruleNode["ExcludeResourceTypesScope"].asString();
if(!ruleNode["ModifyTime"].isNull())
rule_.modifyTime = ruleNode["ModifyTime"].asString();
if(!ruleNode["RegionIdsScope"].isNull())
rule_.regionIdsScope = ruleNode["RegionIdsScope"].asString();
if(!ruleNode["ResourceGroupIdsScope"].isNull())
rule_.resourceGroupIdsScope = ruleNode["ResourceGroupIdsScope"].asString();
if(!ruleNode["ResourceIdsScope"].isNull())
rule_.resourceIdsScope = ruleNode["ResourceIdsScope"].asString();
if(!ruleNode["ResourceTypesScope"].isNull())
rule_.resourceTypesScope = ruleNode["ResourceTypesScope"].asString();
if(!ruleNode["RuleDesc"].isNull())
rule_.ruleDesc = ruleNode["RuleDesc"].asString();
if(!ruleNode["RuleId"].isNull())
rule_.ruleId = ruleNode["RuleId"].asString();
if(!ruleNode["RuleName"].isNull())
rule_.ruleName = ruleNode["RuleName"].asString();
if(!ruleNode["RuleType"].isNull())
rule_.ruleType = ruleNode["RuleType"].asString();
auto allRuleContentsNode = ruleNode["RuleContents"]["RuleContent"];
for (auto ruleNodeRuleContentsRuleContent : allRuleContentsNode)
{
Rule::RuleContent ruleContentObject;
if(!ruleNodeRuleContentsRuleContent["AutoGroupingScopeCondition"].isNull())
ruleContentObject.autoGroupingScopeCondition = ruleNodeRuleContentsRuleContent["AutoGroupingScopeCondition"].asString();
if(!ruleNodeRuleContentsRuleContent["RuleContentId"].isNull())
ruleContentObject.ruleContentId = ruleNodeRuleContentsRuleContent["RuleContentId"].asString();
if(!ruleNodeRuleContentsRuleContent["TargetResourceGroupCondition"].isNull())
ruleContentObject.targetResourceGroupCondition = ruleNodeRuleContentsRuleContent["TargetResourceGroupCondition"].asString();
rule_.ruleContents.push_back(ruleContentObject);
}
}
GetAutoGroupingRuleResult::Rule GetAutoGroupingRuleResult::getRule()const
{
return rule_;
}

27
resourcemanager/src/model/GetAutoGroupingStatusRequest.cc Normal file
View File

@@ -0,0 +1,27 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/resourcemanager/model/GetAutoGroupingStatusRequest.h>
using AlibabaCloud::ResourceManager::Model::GetAutoGroupingStatusRequest;
GetAutoGroupingStatusRequest::GetAutoGroupingStatusRequest()
: RpcServiceRequest("resourcemanager", "2020-03-31", "GetAutoGroupingStatus") {
setMethod(HttpRequest::Method::Post);
}
GetAutoGroupingStatusRequest::~GetAutoGroupingStatusRequest() {}

58
resourcemanager/src/model/GetAutoGroupingStatusResult.cc Normal file
View File

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

12
resourcemanager/src/model/GetPolicyResult.cc
View File

@@ -40,22 +40,22 @@ void GetPolicyResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto policyNode = value["Policy"];
if(!policyNode["AttachmentCount"].isNull())
policy_.attachmentCount = std::stoi(policyNode["AttachmentCount"].asString());
if(!policyNode["CreateDate"].isNull())
policy_.createDate = policyNode["CreateDate"].asString();
if(!policyNode["DefaultVersion"].isNull())
policy_.defaultVersion = policyNode["DefaultVersion"].asString();
if(!policyNode["UpdateDate"].isNull())
policy_.updateDate = policyNode["UpdateDate"].asString();
if(!policyNode["Description"].isNull())
policy_.description = policyNode["Description"].asString();
if(!policyNode["PolicyDocument"].isNull())
policy_.policyDocument = policyNode["PolicyDocument"].asString();
if(!policyNode["AttachmentCount"].isNull())
policy_.attachmentCount = std::stoi(policyNode["AttachmentCount"].asString());
if(!policyNode["PolicyName"].isNull())
policy_.policyName = policyNode["PolicyName"].asString();
if(!policyNode["CreateDate"].isNull())
policy_.createDate = policyNode["CreateDate"].asString();
if(!policyNode["PolicyType"].isNull())
policy_.policyType = policyNode["PolicyType"].asString();
if(!policyNode["UpdateDate"].isNull())
policy_.updateDate = policyNode["UpdateDate"].asString();
}

4
resourcemanager/src/model/GetPolicyVersionResult.cc
View File

@@ -40,14 +40,14 @@ void GetPolicyVersionResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto policyVersionNode = value["PolicyVersion"];
if(!policyVersionNode["CreateDate"].isNull())
policyVersion_.createDate = policyVersionNode["CreateDate"].asString();
if(!policyVersionNode["IsDefaultVersion"].isNull())
policyVersion_.isDefaultVersion = policyVersionNode["IsDefaultVersion"].asString() == "true";
if(!policyVersionNode["PolicyDocument"].isNull())
policyVersion_.policyDocument = policyVersionNode["PolicyDocument"].asString();
if(!policyVersionNode["VersionId"].isNull())
policyVersion_.versionId = policyVersionNode["VersionId"].asString();
if(!policyVersionNode["CreateDate"].isNull())
policyVersion_.createDate = policyVersionNode["CreateDate"].asString();
}

20
resourcemanager/src/model/GetResourceDirectoryResult.cc
View File

@@ -40,24 +40,24 @@ void GetResourceDirectoryResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto resourceDirectoryNode = value["ResourceDirectory"];
if(!resourceDirectoryNode["RootFolderId"].isNull())
resourceDirectory_.rootFolderId = resourceDirectoryNode["RootFolderId"].asString();
if(!resourceDirectoryNode["ResourceDirectoryId"].isNull())
resourceDirectory_.resourceDirectoryId = resourceDirectoryNode["ResourceDirectoryId"].asString();
if(!resourceDirectoryNode["ControlPolicyStatus"].isNull())
resourceDirectory_.controlPolicyStatus = resourceDirectoryNode["ControlPolicyStatus"].asString();
if(!resourceDirectoryNode["CreateTime"].isNull())
resourceDirectory_.createTime = resourceDirectoryNode["CreateTime"].asString();
if(!resourceDirectoryNode["IdentityInformation"].isNull())
resourceDirectory_.identityInformation = resourceDirectoryNode["IdentityInformation"].asString();
if(!resourceDirectoryNode["MasterAccountId"].isNull())
resourceDirectory_.masterAccountId = resourceDirectoryNode["MasterAccountId"].asString();
if(!resourceDirectoryNode["MasterAccountName"].isNull())
resourceDirectory_.masterAccountName = resourceDirectoryNode["MasterAccountName"].asString();
if(!resourceDirectoryNode["ScpStatus"].isNull())
resourceDirectory_.scpStatus = resourceDirectoryNode["ScpStatus"].asString();
if(!resourceDirectoryNode["ControlPolicyStatus"].isNull())
resourceDirectory_.controlPolicyStatus = resourceDirectoryNode["ControlPolicyStatus"].asString();
if(!resourceDirectoryNode["MemberDeletionStatus"].isNull())
resourceDirectory_.memberDeletionStatus = resourceDirectoryNode["MemberDeletionStatus"].asString();
if(!resourceDirectoryNode["IdentityInformation"].isNull())
resourceDirectory_.identityInformation = resourceDirectoryNode["IdentityInformation"].asString();
if(!resourceDirectoryNode["ResourceDirectoryId"].isNull())
resourceDirectory_.resourceDirectoryId = resourceDirectoryNode["ResourceDirectoryId"].asString();
if(!resourceDirectoryNode["RootFolderId"].isNull())
resourceDirectory_.rootFolderId = resourceDirectoryNode["RootFolderId"].asString();
if(!resourceDirectoryNode["ScpStatus"].isNull())
resourceDirectory_.scpStatus = resourceDirectoryNode["ScpStatus"].asString();
}

32
resourcemanager/src/model/GetRoleResult.cc
View File

@@ -40,31 +40,31 @@ void GetRoleResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto roleNode = value["Role"];
if(!roleNode["Arn"].isNull())
role_.arn = roleNode["Arn"].asString();
if(!roleNode["AssumeRolePolicyDocument"].isNull())
role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString();
if(!roleNode["CreateDate"].isNull())
role_.createDate = roleNode["CreateDate"].asString();
if(!roleNode["Description"].isNull())
role_.description = roleNode["Description"].asString();
if(!roleNode["IsServiceLinkedRole"].isNull())
role_.isServiceLinkedRole = roleNode["IsServiceLinkedRole"].asString() == "true";
if(!roleNode["MaxSessionDuration"].isNull())
role_.maxSessionDuration = std::stol(roleNode["MaxSessionDuration"].asString());
if(!roleNode["RoleId"].isNull())
role_.roleId = roleNode["RoleId"].asString();
if(!roleNode["RoleName"].isNull())
role_.roleName = roleNode["RoleName"].asString();
if(!roleNode["RolePrincipalName"].isNull())
role_.rolePrincipalName = roleNode["RolePrincipalName"].asString();
if(!roleNode["UpdateDate"].isNull())
role_.updateDate = roleNode["UpdateDate"].asString();
if(!roleNode["Description"].isNull())
role_.description = roleNode["Description"].asString();
if(!roleNode["MaxSessionDuration"].isNull())
role_.maxSessionDuration = std::stol(roleNode["MaxSessionDuration"].asString());
if(!roleNode["RoleName"].isNull())
role_.roleName = roleNode["RoleName"].asString();
if(!roleNode["CreateDate"].isNull())
role_.createDate = roleNode["CreateDate"].asString();
if(!roleNode["RoleId"].isNull())
role_.roleId = roleNode["RoleId"].asString();
if(!roleNode["Arn"].isNull())
role_.arn = roleNode["Arn"].asString();
if(!roleNode["IsServiceLinkedRole"].isNull())
role_.isServiceLinkedRole = roleNode["IsServiceLinkedRole"].asString() == "true";
auto latestDeletionTaskNode = roleNode["LatestDeletionTask"];
if(!latestDeletionTaskNode["DeletionTaskId"].isNull())
role_.latestDeletionTask.deletionTaskId = latestDeletionTaskNode["DeletionTaskId"].asString();
if(!latestDeletionTaskNode["CreateDate"].isNull())
role_.latestDeletionTask.createDate = latestDeletionTaskNode["CreateDate"].asString();
if(!latestDeletionTaskNode["DeletionTaskId"].isNull())
role_.latestDeletionTask.deletionTaskId = latestDeletionTaskNode["DeletionTaskId"].asString();
}

8
resourcemanager/src/model/InitResourceDirectoryResult.cc
View File

@@ -40,16 +40,16 @@ void InitResourceDirectoryResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto resourceDirectoryNode = value["ResourceDirectory"];
if(!resourceDirectoryNode["RootFolderId"].isNull())
resourceDirectory_.rootFolderId = resourceDirectoryNode["RootFolderId"].asString();
if(!resourceDirectoryNode["ResourceDirectoryId"].isNull())
resourceDirectory_.resourceDirectoryId = resourceDirectoryNode["ResourceDirectoryId"].asString();
if(!resourceDirectoryNode["CreateTime"].isNull())
resourceDirectory_.createTime = resourceDirectoryNode["CreateTime"].asString();
if(!resourceDirectoryNode["MasterAccountId"].isNull())
resourceDirectory_.masterAccountId = resourceDirectoryNode["MasterAccountId"].asString();
if(!resourceDirectoryNode["MasterAccountName"].isNull())
resourceDirectory_.masterAccountName = resourceDirectoryNode["MasterAccountName"].asString();
if(!resourceDirectoryNode["ResourceDirectoryId"].isNull())
resourceDirectory_.resourceDirectoryId = resourceDirectoryNode["ResourceDirectoryId"].asString();
if(!resourceDirectoryNode["RootFolderId"].isNull())
resourceDirectory_.rootFolderId = resourceDirectoryNode["RootFolderId"].asString();
}

54
resourcemanager/src/model/ListAccountsForParentRequest.cc
View File

@@ -25,15 +25,6 @@ ListAccountsForParentRequest::ListAccountsForParentRequest()
ListAccountsForParentRequest::~ListAccountsForParentRequest() {}
std::string ListAccountsForParentRequest::getQueryKeyword() const {
return queryKeyword_;
}
void ListAccountsForParentRequest::setQueryKeyword(const std::string &queryKeyword) {
queryKeyword_ = queryKeyword;
setParameter(std::string("QueryKeyword"), queryKeyword);
}
int ListAccountsForParentRequest::getPageNumber() const {
return pageNumber_;
}
@@ -43,24 +34,6 @@ void ListAccountsForParentRequest::setPageNumber(int pageNumber) {
setParameter(std::string("PageNumber"), std::to_string(pageNumber));
}
std::string ListAccountsForParentRequest::getParentFolderId() const {
return parentFolderId_;
}
void ListAccountsForParentRequest::setParentFolderId(const std::string &parentFolderId) {
parentFolderId_ = parentFolderId;
setParameter(std::string("ParentFolderId"), parentFolderId);
}
bool ListAccountsForParentRequest::getIncludeTags() const {
return includeTags_;
}
void ListAccountsForParentRequest::setIncludeTags(bool includeTags) {
includeTags_ = includeTags;
setParameter(std::string("IncludeTags"), includeTags ? "true" : "false");
}
int ListAccountsForParentRequest::getPageSize() const {
return pageSize_;
}
@@ -82,3 +55,30 @@ void ListAccountsForParentRequest::setTag(const std::vector<ListAccountsForParen
}
}
std::string ListAccountsForParentRequest::getQueryKeyword() const {
return queryKeyword_;
}
void ListAccountsForParentRequest::setQueryKeyword(const std::string &queryKeyword) {
queryKeyword_ = queryKeyword;
setParameter(std::string("QueryKeyword"), queryKeyword);
}
std::string ListAccountsForParentRequest::getParentFolderId() const {
return parentFolderId_;
}
void ListAccountsForParentRequest::setParentFolderId(const std::string &parentFolderId) {
parentFolderId_ = parentFolderId;
setParameter(std::string("ParentFolderId"), parentFolderId);
}
bool ListAccountsForParentRequest::getIncludeTags() const {
return includeTags_;
}
void ListAccountsForParentRequest::setIncludeTags(bool includeTags) {
includeTags_ = includeTags;
setParameter(std::string("IncludeTags"), includeTags ? "true" : "false");
}

27
resourcemanager/src/model/ListAssociatedTransferSettingRequest.cc Normal file
View File

@@ -0,0 +1,27 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/resourcemanager/model/ListAssociatedTransferSettingRequest.h>
using AlibabaCloud::ResourceManager::Model::ListAssociatedTransferSettingRequest;
ListAssociatedTransferSettingRequest::ListAssociatedTransferSettingRequest()
: RpcServiceRequest("resourcemanager", "2020-03-31", "ListAssociatedTransferSetting") {
setMethod(HttpRequest::Method::Post);
}
ListAssociatedTransferSettingRequest::~ListAssociatedTransferSettingRequest() {}

78
resourcemanager/src/model/ListAssociatedTransferSettingResult.cc Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/resourcemanager/model/ListAssociatedTransferSettingResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ResourceManager;
using namespace AlibabaCloud::ResourceManager::Model;
ListAssociatedTransferSettingResult::ListAssociatedTransferSettingResult() :
ServiceResult()
{}
ListAssociatedTransferSettingResult::ListAssociatedTransferSettingResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListAssociatedTransferSettingResult::~ListAssociatedTransferSettingResult()
{}
void ListAssociatedTransferSettingResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto associatedTransferSettingNode = value["AssociatedTransferSetting"];
if(!associatedTransferSettingNode["AccountId"].isNull())
associatedTransferSetting_.accountId = associatedTransferSettingNode["AccountId"].asString();
if(!associatedTransferSettingNode["Status"].isNull())
associatedTransferSetting_.status = associatedTransferSettingNode["Status"].asString();
if(!associatedTransferSettingNode["EnablePartialRule"].isNull())
associatedTransferSetting_.enablePartialRule = associatedTransferSettingNode["EnablePartialRule"].asString();
if(!associatedTransferSettingNode["EnableExistingResourcesTransfer"].isNull())
associatedTransferSetting_.enableExistingResourcesTransfer = associatedTransferSettingNode["EnableExistingResourcesTransfer"].asString();
auto allRuleSettingsNode = associatedTransferSettingNode["RuleSettings"]["RuleSetting"];
for (auto associatedTransferSettingNodeRuleSettingsRuleSetting : allRuleSettingsNode)
{
AssociatedTransferSetting::RuleSetting ruleSettingObject;
if(!associatedTransferSettingNodeRuleSettingsRuleSetting["AssociatedResourceType"].isNull())
ruleSettingObject.associatedResourceType = associatedTransferSettingNodeRuleSettingsRuleSetting["AssociatedResourceType"].asString();
if(!associatedTransferSettingNodeRuleSettingsRuleSetting["MasterResourceType"].isNull())
ruleSettingObject.masterResourceType = associatedTransferSettingNodeRuleSettingsRuleSetting["MasterResourceType"].asString();
if(!associatedTransferSettingNodeRuleSettingsRuleSetting["AssociatedService"].isNull())
ruleSettingObject.associatedService = associatedTransferSettingNodeRuleSettingsRuleSetting["AssociatedService"].asString();
if(!associatedTransferSettingNodeRuleSettingsRuleSetting["MasterService"].isNull())
ruleSettingObject.masterService = associatedTransferSettingNodeRuleSettingsRuleSetting["MasterService"].asString();
if(!associatedTransferSettingNodeRuleSettingsRuleSetting["TriggerType"].isNull())
ruleSettingObject.triggerType = associatedTransferSettingNodeRuleSettingsRuleSetting["TriggerType"].asString();
if(!associatedTransferSettingNodeRuleSettingsRuleSetting["RuleId"].isNull())
ruleSettingObject.ruleId = associatedTransferSettingNodeRuleSettingsRuleSetting["RuleId"].asString();
if(!associatedTransferSettingNodeRuleSettingsRuleSetting["Status"].isNull())
ruleSettingObject.status = associatedTransferSettingNodeRuleSettingsRuleSetting["Status"].asString();
associatedTransferSetting_.ruleSettings.push_back(ruleSettingObject);
}
}
ListAssociatedTransferSettingResult::AssociatedTransferSetting ListAssociatedTransferSettingResult::getAssociatedTransferSetting()const
{
return associatedTransferSetting_;
}

72
resourcemanager/src/model/ListAutoGroupingRulesRequest.cc Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/resourcemanager/model/ListAutoGroupingRulesRequest.h>
using AlibabaCloud::ResourceManager::Model::ListAutoGroupingRulesRequest;
ListAutoGroupingRulesRequest::ListAutoGroupingRulesRequest()
: RpcServiceRequest("resourcemanager", "2020-03-31", "ListAutoGroupingRules") {
setMethod(HttpRequest::Method::Post);
}
ListAutoGroupingRulesRequest::~ListAutoGroupingRulesRequest() {}
std::string ListAutoGroupingRulesRequest::getRuleName() const {
return ruleName_;
}
void ListAutoGroupingRulesRequest::setRuleName(const std::string &ruleName) {
ruleName_ = ruleName;
setParameter(std::string("RuleName"), ruleName);
}
std::string ListAutoGroupingRulesRequest::getNextToken() const {
return nextToken_;
}
void ListAutoGroupingRulesRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
std::string ListAutoGroupingRulesRequest::getRuleType() const {
return ruleType_;
}
void ListAutoGroupingRulesRequest::setRuleType(const std::string &ruleType) {
ruleType_ = ruleType;
setParameter(std::string("RuleType"), ruleType);
}
int ListAutoGroupingRulesRequest::getMaxResults() const {
return maxResults_;
}
void ListAutoGroupingRulesRequest::setMaxResults(int maxResults) {
maxResults_ = maxResults;
setParameter(std::string("MaxResults"), std::to_string(maxResults));
}
std::string ListAutoGroupingRulesRequest::getRuleId() const {
return ruleId_;
}
void ListAutoGroupingRulesRequest::setRuleId(const std::string &ruleId) {
ruleId_ = ruleId;
setParameter(std::string("RuleId"), ruleId);
}

109
resourcemanager/src/model/ListAutoGroupingRulesResult.cc Normal file
View File

@@ -0,0 +1,109 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/resourcemanager/model/ListAutoGroupingRulesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::ResourceManager;
using namespace AlibabaCloud::ResourceManager::Model;
ListAutoGroupingRulesResult::ListAutoGroupingRulesResult() :
ServiceResult()
{}
ListAutoGroupingRulesResult::ListAutoGroupingRulesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ListAutoGroupingRulesResult::~ListAutoGroupingRulesResult()
{}
void ListAutoGroupingRulesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allRulesNode = value["Rules"]["Rule"];
for (auto valueRulesRule : allRulesNode)
{
Rule rulesObject;
if(!valueRulesRule["CreateTime"].isNull())
rulesObject.createTime = valueRulesRule["CreateTime"].asString();
if(!valueRulesRule["ExcludeRegionIdsScope"].isNull())
rulesObject.excludeRegionIdsScope = valueRulesRule["ExcludeRegionIdsScope"].asString();
if(!valueRulesRule["ExcludeResourceGroupIdsScope"].isNull())
rulesObject.excludeResourceGroupIdsScope = valueRulesRule["ExcludeResourceGroupIdsScope"].asString();
if(!valueRulesRule["ExcludeResourceIdsScope"].isNull())
rulesObject.excludeResourceIdsScope = valueRulesRule["ExcludeResourceIdsScope"].asString();
if(!valueRulesRule["ExcludeResourceTypesScope"].isNull())
rulesObject.excludeResourceTypesScope = valueRulesRule["ExcludeResourceTypesScope"].asString();
if(!valueRulesRule["ModifyTime"].isNull())
rulesObject.modifyTime = valueRulesRule["ModifyTime"].asString();
if(!valueRulesRule["RegionIdsScope"].isNull())
rulesObject.regionIdsScope = valueRulesRule["RegionIdsScope"].asString();
if(!valueRulesRule["ResourceGroupIdsScope"].isNull())
rulesObject.resourceGroupIdsScope = valueRulesRule["ResourceGroupIdsScope"].asString();
if(!valueRulesRule["ResourceIdsScope"].isNull())
rulesObject.resourceIdsScope = valueRulesRule["ResourceIdsScope"].asString();
if(!valueRulesRule["ResourceTypesScope"].isNull())
rulesObject.resourceTypesScope = valueRulesRule["ResourceTypesScope"].asString();
if(!valueRulesRule["RuleDesc"].isNull())
rulesObject.ruleDesc = valueRulesRule["RuleDesc"].asString();
if(!valueRulesRule["RuleId"].isNull())
rulesObject.ruleId = valueRulesRule["RuleId"].asString();
if(!valueRulesRule["RuleName"].isNull())
rulesObject.ruleName = valueRulesRule["RuleName"].asString();
if(!valueRulesRule["RuleType"].isNull())
rulesObject.ruleType = valueRulesRule["RuleType"].asString();
auto allRuleContentsNode = valueRulesRule["RuleContents"]["RuleContent"];
for (auto valueRulesRuleRuleContentsRuleContent : allRuleContentsNode)
{
Rule::RuleContent ruleContentsObject;
if(!valueRulesRuleRuleContentsRuleContent["AutoGroupingScopeCondition"].isNull())
ruleContentsObject.autoGroupingScopeCondition = valueRulesRuleRuleContentsRuleContent["AutoGroupingScopeCondition"].asString();
if(!valueRulesRuleRuleContentsRuleContent["RuleContentId"].isNull())
ruleContentsObject.ruleContentId = valueRulesRuleRuleContentsRuleContent["RuleContentId"].asString();
if(!valueRulesRuleRuleContentsRuleContent["TargetResourceGroupCondition"].isNull())
ruleContentsObject.targetResourceGroupCondition = valueRulesRuleRuleContentsRuleContent["TargetResourceGroupCondition"].asString();
rulesObject.ruleContents.push_back(ruleContentsObject);
}
rules_.push_back(rulesObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
if(!value["MaxResults"].isNull())
maxResults_ = std::stoi(value["MaxResults"].asString());
}
std::string ListAutoGroupingRulesResult::getNextToken()const
{
return nextToken_;
}
int ListAutoGroupingRulesResult::getMaxResults()const
{
return maxResults_;
}
std::vector<ListAutoGroupingRulesResult::Rule> ListAutoGroupingRulesResult::getRules()const
{
return rules_;
}

20
resourcemanager/src/model/ListPoliciesResult.cc
View File

@@ -43,28 +43,28 @@ void ListPoliciesResult::parse(const std::string &payload)
for (auto valuePoliciesPolicy : allPoliciesNode)
{
Policy policiesObject;
if(!valuePoliciesPolicy["AttachmentCount"].isNull())
policiesObject.attachmentCount = std::stoi(valuePoliciesPolicy["AttachmentCount"].asString());
if(!valuePoliciesPolicy["CreateDate"].isNull())
policiesObject.createDate = valuePoliciesPolicy["CreateDate"].asString();
if(!valuePoliciesPolicy["DefaultVersion"].isNull())
policiesObject.defaultVersion = valuePoliciesPolicy["DefaultVersion"].asString();
if(!valuePoliciesPolicy["Description"].isNull())
policiesObject.description = valuePoliciesPolicy["Description"].asString();
if(!valuePoliciesPolicy["UpdateDate"].isNull())
policiesObject.updateDate = valuePoliciesPolicy["UpdateDate"].asString();
if(!valuePoliciesPolicy["AttachmentCount"].isNull())
policiesObject.attachmentCount = std::stoi(valuePoliciesPolicy["AttachmentCount"].asString());
if(!valuePoliciesPolicy["PolicyName"].isNull())
policiesObject.policyName = valuePoliciesPolicy["PolicyName"].asString();
if(!valuePoliciesPolicy["CreateDate"].isNull())
policiesObject.createDate = valuePoliciesPolicy["CreateDate"].asString();
if(!valuePoliciesPolicy["PolicyType"].isNull())
policiesObject.policyType = valuePoliciesPolicy["PolicyType"].asString();
if(!valuePoliciesPolicy["UpdateDate"].isNull())
policiesObject.updateDate = valuePoliciesPolicy["UpdateDate"].asString();
policies_.push_back(policiesObject);
}
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}

24
resourcemanager/src/model/ListPolicyAttachmentsResult.cc
View File

@@ -43,28 +43,28 @@ void ListPolicyAttachmentsResult::parse(const std::string &payload)
for (auto valuePolicyAttachmentsPolicyAttachment : allPolicyAttachmentsNode)
{
PolicyAttachment policyAttachmentsObject;
if(!valuePolicyAttachmentsPolicyAttachment["Description"].isNull())
policyAttachmentsObject.description = valuePolicyAttachmentsPolicyAttachment["Description"].asString();
if(!valuePolicyAttachmentsPolicyAttachment["ResourceGroupId"].isNull())
policyAttachmentsObject.resourceGroupId = valuePolicyAttachmentsPolicyAttachment["ResourceGroupId"].asString();
if(!valuePolicyAttachmentsPolicyAttachment["PolicyName"].isNull())
policyAttachmentsObject.policyName = valuePolicyAttachmentsPolicyAttachment["PolicyName"].asString();
if(!valuePolicyAttachmentsPolicyAttachment["PrincipalName"].isNull())
policyAttachmentsObject.principalName = valuePolicyAttachmentsPolicyAttachment["PrincipalName"].asString();
if(!valuePolicyAttachmentsPolicyAttachment["AttachDate"].isNull())
policyAttachmentsObject.attachDate = valuePolicyAttachmentsPolicyAttachment["AttachDate"].asString();
if(!valuePolicyAttachmentsPolicyAttachment["Description"].isNull())
policyAttachmentsObject.description = valuePolicyAttachmentsPolicyAttachment["Description"].asString();
if(!valuePolicyAttachmentsPolicyAttachment["PolicyName"].isNull())
policyAttachmentsObject.policyName = valuePolicyAttachmentsPolicyAttachment["PolicyName"].asString();
if(!valuePolicyAttachmentsPolicyAttachment["PolicyType"].isNull())
policyAttachmentsObject.policyType = valuePolicyAttachmentsPolicyAttachment["PolicyType"].asString();
if(!valuePolicyAttachmentsPolicyAttachment["PrincipalName"].isNull())
policyAttachmentsObject.principalName = valuePolicyAttachmentsPolicyAttachment["PrincipalName"].asString();
if(!valuePolicyAttachmentsPolicyAttachment["PrincipalType"].isNull())
policyAttachmentsObject.principalType = valuePolicyAttachmentsPolicyAttachment["PrincipalType"].asString();
if(!valuePolicyAttachmentsPolicyAttachment["ResourceGroupId"].isNull())
policyAttachmentsObject.resourceGroupId = valuePolicyAttachmentsPolicyAttachment["ResourceGroupId"].asString();
policyAttachments_.push_back(policyAttachmentsObject);
}
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}

4
resourcemanager/src/model/ListPolicyVersionsResult.cc
View File

@@ -43,12 +43,12 @@ void ListPolicyVersionsResult::parse(const std::string &payload)
for (auto valuePolicyVersionsPolicyVersion : allPolicyVersionsNode)
{
PolicyVersion policyVersionsObject;
if(!valuePolicyVersionsPolicyVersion["CreateDate"].isNull())
policyVersionsObject.createDate = valuePolicyVersionsPolicyVersion["CreateDate"].asString();
if(!valuePolicyVersionsPolicyVersion["IsDefaultVersion"].isNull())
policyVersionsObject.isDefaultVersion = valuePolicyVersionsPolicyVersion["IsDefaultVersion"].asString() == "true";
if(!valuePolicyVersionsPolicyVersion["VersionId"].isNull())
policyVersionsObject.versionId = valuePolicyVersionsPolicyVersion["VersionId"].asString();
if(!valuePolicyVersionsPolicyVersion["CreateDate"].isNull())
policyVersionsObject.createDate = valuePolicyVersionsPolicyVersion["CreateDate"].asString();
policyVersions_.push_back(policyVersionsObject);
}

40
resourcemanager/src/model/ListRolesResult.cc
View File

@@ -43,37 +43,37 @@ void ListRolesResult::parse(const std::string &payload)
for (auto valueRolesRole : allRolesNode)
{
Role rolesObject;
if(!valueRolesRole["Arn"].isNull())
rolesObject.arn = valueRolesRole["Arn"].asString();
if(!valueRolesRole["CreateDate"].isNull())
rolesObject.createDate = valueRolesRole["CreateDate"].asString();
if(!valueRolesRole["Description"].isNull())
rolesObject.description = valueRolesRole["Description"].asString();
if(!valueRolesRole["IsServiceLinkedRole"].isNull())
rolesObject.isServiceLinkedRole = valueRolesRole["IsServiceLinkedRole"].asString() == "true";
if(!valueRolesRole["MaxSessionDuration"].isNull())
rolesObject.maxSessionDuration = std::stol(valueRolesRole["MaxSessionDuration"].asString());
if(!valueRolesRole["RoleId"].isNull())
rolesObject.roleId = valueRolesRole["RoleId"].asString();
if(!valueRolesRole["RoleName"].isNull())
rolesObject.roleName = valueRolesRole["RoleName"].asString();
if(!valueRolesRole["RolePrincipalName"].isNull())
rolesObject.rolePrincipalName = valueRolesRole["RolePrincipalName"].asString();
if(!valueRolesRole["UpdateDate"].isNull())
rolesObject.updateDate = valueRolesRole["UpdateDate"].asString();
if(!valueRolesRole["Description"].isNull())
rolesObject.description = valueRolesRole["Description"].asString();
if(!valueRolesRole["MaxSessionDuration"].isNull())
rolesObject.maxSessionDuration = std::stol(valueRolesRole["MaxSessionDuration"].asString());
if(!valueRolesRole["RoleName"].isNull())
rolesObject.roleName = valueRolesRole["RoleName"].asString();
if(!valueRolesRole["CreateDate"].isNull())
rolesObject.createDate = valueRolesRole["CreateDate"].asString();
if(!valueRolesRole["RoleId"].isNull())
rolesObject.roleId = valueRolesRole["RoleId"].asString();
if(!valueRolesRole["Arn"].isNull())
rolesObject.arn = valueRolesRole["Arn"].asString();
if(!valueRolesRole["IsServiceLinkedRole"].isNull())
rolesObject.isServiceLinkedRole = valueRolesRole["IsServiceLinkedRole"].asString() == "true";
auto latestDeletionTaskNode = value["LatestDeletionTask"];
if(!latestDeletionTaskNode["DeletionTaskId"].isNull())
rolesObject.latestDeletionTask.deletionTaskId = latestDeletionTaskNode["DeletionTaskId"].asString();
if(!latestDeletionTaskNode["CreateDate"].isNull())
rolesObject.latestDeletionTask.createDate = latestDeletionTaskNode["CreateDate"].asString();
if(!latestDeletionTaskNode["DeletionTaskId"].isNull())
rolesObject.latestDeletionTask.deletionTaskId = latestDeletionTaskNode["DeletionTaskId"].asString();
roles_.push_back(rolesObject);
}
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
}

42
resourcemanager/src/model/ListTagResourcesRequest.cc
View File

@@ -25,6 +25,27 @@ ListTagResourcesRequest::ListTagResourcesRequest()
ListTagResourcesRequest::~ListTagResourcesRequest() {}
std::string ListTagResourcesRequest::getNextToken() const {
return nextToken_;
}
void ListTagResourcesRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
std::vector<ListTagResourcesRequest::Tag> ListTagResourcesRequest::getTag() const {
return tag_;
}
void ListTagResourcesRequest::setTag(const std::vector<ListTagResourcesRequest::Tag> &tag) {
tag_ = tag;
for(int dep1 = 0; dep1 != tag.size(); dep1++) {
setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Value", tag[dep1].value);
setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Key", tag[dep1].key);
}
}
std::vector<ListTagResourcesRequest::std::string> ListTagResourcesRequest::getResourceId() const {
return resourceId_;
}
@@ -45,15 +66,6 @@ void ListTagResourcesRequest::setResourceType(const std::string &resourceType) {
setParameter(std::string("ResourceType"), resourceType);
}
std::string ListTagResourcesRequest::getNextToken() const {
return nextToken_;
}
void ListTagResourcesRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
int ListTagResourcesRequest::getMaxResults() const {
return maxResults_;
}
@@ -63,15 +75,3 @@ void ListTagResourcesRequest::setMaxResults(int maxResults) {
setParameter(std::string("MaxResults"), std::to_string(maxResults));
}
std::vector<ListTagResourcesRequest::Tag> ListTagResourcesRequest::getTag() const {
return tag_;
}
void ListTagResourcesRequest::setTag(const std::vector<ListTagResourcesRequest::Tag> &tag) {
tag_ = tag;
for(int dep1 = 0; dep1 != tag.size(); dep1++) {
setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Value", tag[dep1].value);
setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Key", tag[dep1].key);
}
}

28
resourcemanager/src/model/PromoteResourceAccountResult.cc
View File

@@ -40,28 +40,28 @@ void PromoteResourceAccountResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto accountNode = value["Account"];
if(!accountNode["Status"].isNull())
account_.status = accountNode["Status"].asString();
if(!accountNode["Type"].isNull())
account_.type = accountNode["Type"].asString();
if(!accountNode["AccountId"].isNull())
account_.accountId = accountNode["AccountId"].asString();
if(!accountNode["AccountName"].isNull())
account_.accountName = accountNode["AccountName"].asString();
if(!accountNode["DisplayName"].isNull())
account_.displayName = accountNode["DisplayName"].asString();
if(!accountNode["FolderId"].isNull())
account_.folderId = accountNode["FolderId"].asString();
if(!accountNode["ResourceDirectoryId"].isNull())
account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
if(!accountNode["RecordId"].isNull())
account_.recordId = accountNode["RecordId"].asString();
if(!accountNode["JoinTime"].isNull())
account_.joinTime = accountNode["JoinTime"].asString();
if(!accountNode["AccountId"].isNull())
account_.accountId = accountNode["AccountId"].asString();
if(!accountNode["JoinMethod"].isNull())
account_.joinMethod = accountNode["JoinMethod"].asString();
if(!accountNode["AccountName"].isNull())
account_.accountName = accountNode["AccountName"].asString();
if(!accountNode["JoinTime"].isNull())
account_.joinTime = accountNode["JoinTime"].asString();
if(!accountNode["ModifyTime"].isNull())
account_.modifyTime = accountNode["ModifyTime"].asString();
if(!accountNode["RecordId"].isNull())
account_.recordId = accountNode["RecordId"].asString();
if(!accountNode["ResourceDirectoryId"].isNull())
account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
if(!accountNode["Status"].isNull())
account_.status = accountNode["Status"].asString();
if(!accountNode["Type"].isNull())
account_.type = accountNode["Type"].asString();
}

28
resourcemanager/src/model/ResendCreateCloudAccountEmailResult.cc
View File

@@ -40,28 +40,28 @@ void ResendCreateCloudAccountEmailResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto accountNode = value["Account"];
if(!accountNode["Status"].isNull())
account_.status = accountNode["Status"].asString();
if(!accountNode["Type"].isNull())
account_.type = accountNode["Type"].asString();
if(!accountNode["AccountId"].isNull())
account_.accountId = accountNode["AccountId"].asString();
if(!accountNode["AccountName"].isNull())
account_.accountName = accountNode["AccountName"].asString();
if(!accountNode["DisplayName"].isNull())
account_.displayName = accountNode["DisplayName"].asString();
if(!accountNode["FolderId"].isNull())
account_.folderId = accountNode["FolderId"].asString();
if(!accountNode["ResourceDirectoryId"].isNull())
account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
if(!accountNode["RecordId"].isNull())
account_.recordId = accountNode["RecordId"].asString();
if(!accountNode["JoinTime"].isNull())
account_.joinTime = accountNode["JoinTime"].asString();
if(!accountNode["AccountId"].isNull())
account_.accountId = accountNode["AccountId"].asString();
if(!accountNode["JoinMethod"].isNull())
account_.joinMethod = accountNode["JoinMethod"].asString();
if(!accountNode["AccountName"].isNull())
account_.accountName = accountNode["AccountName"].asString();
if(!accountNode["JoinTime"].isNull())
account_.joinTime = accountNode["JoinTime"].asString();
if(!accountNode["ModifyTime"].isNull())
account_.modifyTime = accountNode["ModifyTime"].asString();
if(!accountNode["RecordId"].isNull())
account_.recordId = accountNode["RecordId"].asString();
if(!accountNode["ResourceDirectoryId"].isNull())
account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
if(!accountNode["Status"].isNull())
account_.status = accountNode["Status"].asString();
if(!accountNode["Type"].isNull())
account_.type = accountNode["Type"].asString();
}

28
resourcemanager/src/model/ResendPromoteResourceAccountEmailResult.cc
View File

@@ -40,28 +40,28 @@ void ResendPromoteResourceAccountEmailResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto accountNode = value["Account"];
if(!accountNode["Status"].isNull())
account_.status = accountNode["Status"].asString();
if(!accountNode["Type"].isNull())
account_.type = accountNode["Type"].asString();
if(!accountNode["AccountId"].isNull())
account_.accountId = accountNode["AccountId"].asString();
if(!accountNode["AccountName"].isNull())
account_.accountName = accountNode["AccountName"].asString();
if(!accountNode["DisplayName"].isNull())
account_.displayName = accountNode["DisplayName"].asString();
if(!accountNode["FolderId"].isNull())
account_.folderId = accountNode["FolderId"].asString();
if(!accountNode["ResourceDirectoryId"].isNull())
account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
if(!accountNode["RecordId"].isNull())
account_.recordId = accountNode["RecordId"].asString();
if(!accountNode["JoinTime"].isNull())
account_.joinTime = accountNode["JoinTime"].asString();
if(!accountNode["AccountId"].isNull())
account_.accountId = accountNode["AccountId"].asString();
if(!accountNode["JoinMethod"].isNull())
account_.joinMethod = accountNode["JoinMethod"].asString();
if(!accountNode["AccountName"].isNull())
account_.accountName = accountNode["AccountName"].asString();
if(!accountNode["JoinTime"].isNull())
account_.joinTime = accountNode["JoinTime"].asString();
if(!accountNode["ModifyTime"].isNull())
account_.modifyTime = accountNode["ModifyTime"].asString();
if(!accountNode["RecordId"].isNull())
account_.recordId = accountNode["RecordId"].asString();
if(!accountNode["ResourceDirectoryId"].isNull())
account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
if(!accountNode["Status"].isNull())
account_.status = accountNode["Status"].asString();
if(!accountNode["Type"].isNull())
account_.type = accountNode["Type"].asString();
}

52
resourcemanager/src/model/UpdateAssociatedTransferSettingRequest.cc Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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/resourcemanager/model/UpdateAssociatedTransferSettingRequest.h>
using AlibabaCloud::ResourceManager::Model::UpdateAssociatedTransferSettingRequest;
UpdateAssociatedTransferSettingRequest::UpdateAssociatedTransferSettingRequest()
: RpcServiceRequest("resourcemanager", "2020-03-31", "UpdateAssociatedTransferSetting") {
setMethod(HttpRequest::Method::Post);
}
UpdateAssociatedTransferSettingRequest::~UpdateAssociatedTransferSettingRequest() {}
std::vector<UpdateAssociatedTransferSettingRequest::RuleSettings> UpdateAssociatedTransferSettingRequest::getRuleSettings() const {
return ruleSettings_;
}
void UpdateAssociatedTransferSettingRequest::setRuleSettings(const std::vector<UpdateAssociatedTransferSettingRequest::RuleSettings> &ruleSettings) {
ruleSettings_ = ruleSettings;
for(int dep1 = 0; dep1 != ruleSettings.size(); dep1++) {
setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".AssociatedService", ruleSettings[dep1].associatedService);
setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".MasterService", ruleSettings[dep1].masterService);
setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".MasterResourceType", ruleSettings[dep1].masterResourceType);
setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".AssociatedResourceType", ruleSettings[dep1].associatedResourceType);
setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".RuleId", ruleSettings[dep1].ruleId);
setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".Status", ruleSettings[dep1].status);
}
}
std::string UpdateAssociatedTransferSettingRequest::getEnableExistingResourcesTransfer() const {
return enableExistingResourcesTransfer_;
}
void UpdateAssociatedTransferSettingRequest::setEnableExistingResourcesTransfer(const std::string &enableExistingResourcesTransfer) {
enableExistingResourcesTransfer_ = enableExistingResourcesTransfer;
setParameter(std::string("EnableExistingResourcesTransfer"), enableExistingResourcesTransfer);
}

44
resourcemanager/src/model/UpdateAssociatedTransferSettingResult.cc Normal file
View File

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

36
resourcemanager/src/model/UpdateAutoGroupingConfigRequest.cc Normal file
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/resourcemanager/model/UpdateAutoGroupingConfigRequest.h>
using AlibabaCloud::ResourceManager::Model::UpdateAutoGroupingConfigRequest;
UpdateAutoGroupingConfigRequest::UpdateAutoGroupingConfigRequest()
: RpcServiceRequest("resourcemanager", "2020-03-31", "UpdateAutoGroupingConfig") {
setMethod(HttpRequest::Method::Post);
}
UpdateAutoGroupingConfigRequest::~UpdateAutoGroupingConfigRequest() {}
bool UpdateAutoGroupingConfigRequest::getEnableExistingResourcesTransfer() const {
return enableExistingResourcesTransfer_;
}
void UpdateAutoGroupingConfigRequest::setEnableExistingResourcesTransfer(bool enableExistingResourcesTransfer) {
enableExistingResourcesTransfer_ = enableExistingResourcesTransfer;
setParameter(std::string("EnableExistingResourcesTransfer"), enableExistingResourcesTransfer ? "true" : "false");
}

44
resourcemanager/src/model/UpdateAutoGroupingConfigResult.cc Normal file
View File

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

141
resourcemanager/src/model/UpdateAutoGroupingRuleRequest.cc Normal file
View File

@@ -0,0 +1,141 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleRequest.h>
using AlibabaCloud::ResourceManager::Model::UpdateAutoGroupingRuleRequest;
UpdateAutoGroupingRuleRequest::UpdateAutoGroupingRuleRequest()
: RpcServiceRequest("resourcemanager", "2020-03-31", "UpdateAutoGroupingRule") {
setMethod(HttpRequest::Method::Post);
}
UpdateAutoGroupingRuleRequest::~UpdateAutoGroupingRuleRequest() {}
std::string UpdateAutoGroupingRuleRequest::getRuleDesc() const {
return ruleDesc_;
}
void UpdateAutoGroupingRuleRequest::setRuleDesc(const std::string &ruleDesc) {
ruleDesc_ = ruleDesc;
setParameter(std::string("RuleDesc"), ruleDesc);
}
std::string UpdateAutoGroupingRuleRequest::getResourceTypesScope() const {
return resourceTypesScope_;
}
void UpdateAutoGroupingRuleRequest::setResourceTypesScope(const std::string &resourceTypesScope) {
resourceTypesScope_ = resourceTypesScope;
setParameter(std::string("ResourceTypesScope"), resourceTypesScope);
}
std::string UpdateAutoGroupingRuleRequest::getRuleName() const {
return ruleName_;
}
void UpdateAutoGroupingRuleRequest::setRuleName(const std::string &ruleName) {
ruleName_ = ruleName;
setParameter(std::string("RuleName"), ruleName);
}
std::string UpdateAutoGroupingRuleRequest::getExcludeResourceGroupIdsScope() const {
return excludeResourceGroupIdsScope_;
}
void UpdateAutoGroupingRuleRequest::setExcludeResourceGroupIdsScope(const std::string &excludeResourceGroupIdsScope) {
excludeResourceGroupIdsScope_ = excludeResourceGroupIdsScope;
setParameter(std::string("ExcludeResourceGroupIdsScope"), excludeResourceGroupIdsScope);
}
std::string UpdateAutoGroupingRuleRequest::getRegionIdsScope() const {
return regionIdsScope_;
}
void UpdateAutoGroupingRuleRequest::setRegionIdsScope(const std::string &regionIdsScope) {
regionIdsScope_ = regionIdsScope;
setParameter(std::string("RegionIdsScope"), regionIdsScope);
}
std::string UpdateAutoGroupingRuleRequest::getResourceIdsScope() const {
return resourceIdsScope_;
}
void UpdateAutoGroupingRuleRequest::setResourceIdsScope(const std::string &resourceIdsScope) {
resourceIdsScope_ = resourceIdsScope;
setParameter(std::string("ResourceIdsScope"), resourceIdsScope);
}
std::vector<UpdateAutoGroupingRuleRequest::RuleContents> UpdateAutoGroupingRuleRequest::getRuleContents() const {
return ruleContents_;
}
void UpdateAutoGroupingRuleRequest::setRuleContents(const std::vector<UpdateAutoGroupingRuleRequest::RuleContents> &ruleContents) {
ruleContents_ = ruleContents;
for(int dep1 = 0; dep1 != ruleContents.size(); dep1++) {
auto ruleContentsObj = ruleContents.at(dep1);
std::string ruleContentsObjStr = std::string("RuleContents") + "." + std::to_string(dep1 + 1);
setParameter(ruleContentsObjStr + ".RuleContentId", ruleContentsObj.ruleContentId);
setParameter(ruleContentsObjStr + ".TargetResourceGroupCondition", ruleContentsObj.targetResourceGroupCondition);
setParameter(ruleContentsObjStr + ".AutoGroupingScopeCondition", ruleContentsObj.autoGroupingScopeCondition);
}
}
std::string UpdateAutoGroupingRuleRequest::getExcludeResourceTypesScope() const {
return excludeResourceTypesScope_;
}
void UpdateAutoGroupingRuleRequest::setExcludeResourceTypesScope(const std::string &excludeResourceTypesScope) {
excludeResourceTypesScope_ = excludeResourceTypesScope;
setParameter(std::string("ExcludeResourceTypesScope"), excludeResourceTypesScope);
}
std::string UpdateAutoGroupingRuleRequest::getResourceGroupIdsScope() const {
return resourceGroupIdsScope_;
}
void UpdateAutoGroupingRuleRequest::setResourceGroupIdsScope(const std::string &resourceGroupIdsScope) {
resourceGroupIdsScope_ = resourceGroupIdsScope;
setParameter(std::string("ResourceGroupIdsScope"), resourceGroupIdsScope);
}
std::string UpdateAutoGroupingRuleRequest::getExcludeRegionIdsScope() const {
return excludeRegionIdsScope_;
}
void UpdateAutoGroupingRuleRequest::setExcludeRegionIdsScope(const std::string &excludeRegionIdsScope) {
excludeRegionIdsScope_ = excludeRegionIdsScope;
setParameter(std::string("ExcludeRegionIdsScope"), excludeRegionIdsScope);
}
std::string UpdateAutoGroupingRuleRequest::getExcludeResourceIdsScope() const {
return excludeResourceIdsScope_;
}
void UpdateAutoGroupingRuleRequest::setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope) {
excludeResourceIdsScope_ = excludeResourceIdsScope;
setParameter(std::string("ExcludeResourceIdsScope"), excludeResourceIdsScope);
}
std::string UpdateAutoGroupingRuleRequest::getRuleId() const {
return ruleId_;
}
void UpdateAutoGroupingRuleRequest::setRuleId(const std::string &ruleId) {
ruleId_ = ruleId;
setParameter(std::string("RuleId"), ruleId);
}

44
resourcemanager/src/model/UpdateAutoGroupingRuleResult.cc Normal file
View File

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

32
resourcemanager/src/model/UpdateRoleResult.cc
View File

@@ -40,24 +40,24 @@ void UpdateRoleResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto roleNode = value["Role"];
if(!roleNode["AssumeRolePolicyDocument"].isNull())
role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString();
if(!roleNode["RolePrincipalName"].isNull())
role_.rolePrincipalName = roleNode["RolePrincipalName"].asString();
if(!roleNode["Description"].isNull())
role_.description = roleNode["Description"].asString();
if(!roleNode["UpdateDate"].isNull())
role_.updateDate = roleNode["UpdateDate"].asString();
if(!roleNode["MaxSessionDuration"].isNull())
role_.maxSessionDuration = std::stol(roleNode["MaxSessionDuration"].asString());
if(!roleNode["RoleName"].isNull())
role_.roleName = roleNode["RoleName"].asString();
if(!roleNode["CreateDate"].isNull())
role_.createDate = roleNode["CreateDate"].asString();
if(!roleNode["RoleId"].isNull())
role_.roleId = roleNode["RoleId"].asString();
if(!roleNode["Arn"].isNull())
role_.arn = roleNode["Arn"].asString();
if(!roleNode["AssumeRolePolicyDocument"].isNull())
role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString();
if(!roleNode["CreateDate"].isNull())
role_.createDate = roleNode["CreateDate"].asString();
if(!roleNode["Description"].isNull())
role_.description = roleNode["Description"].asString();
if(!roleNode["MaxSessionDuration"].isNull())
role_.maxSessionDuration = std::stol(roleNode["MaxSessionDuration"].asString());
if(!roleNode["RoleId"].isNull())
role_.roleId = roleNode["RoleId"].asString();
if(!roleNode["RoleName"].isNull())
role_.roleName = roleNode["RoleName"].asString();
if(!roleNode["RolePrincipalName"].isNull())
role_.rolePrincipalName = roleNode["RolePrincipalName"].asString();
if(!roleNode["UpdateDate"].isNull())
role_.updateDate = roleNode["UpdateDate"].asString();
}